feat(v0.3.0): paradigm shift — TimeWeb-only LLM + persistent advisor trail + improvement queue

This is the rc.4 batch the user requested:

  1. Emergency triggers (low HP + close hostile, lava-under-foot)
     bypass the long cooldown so the LLM is consulted BEFORE the bot
     dies, not after.
  2. Active manifesto need is now included in the advisor user prompt
     — the LLM picks suggestions that satisfy the bot's current
     concrete need (L2 tools_wood → "gather logs nearby" not
     "explore further").
  3. Every advisor recommendation is persisted to SQLite
     (advisor_recommendations table) with full token usage. The
     reflex marks 'applied=1' when it dispatches and updates
     outcome_ok/code when the dispatch completes. Ground truth for
     "is the LLM actually helping" lives in the DB, not in logs.
  4. Pi CLI is OUT of every background loop. coach/postmortem and
     coach/reflect now go through the same TimeWeb endpoint
     fast-advisor uses, via the shared coach/llm-call.js helper.
     Pi is reserved for manual operator commands.
  5. The LLM (postmortem, reflect, advisor) can flag "structural
     gaps" — missing skills/features the operator should implement.
     These land in the new improvement_requests table. Dedup by
     title bumps `votes` instead of inserting duplicates so the
     queue doesn't bloat. Operator views via
     `node scripts/list-improvements.js`.
  6. A deterministic trigger-tuner runs hourly: reads 24h of
     recommendation stats, flags triggers whose success rate is
     below 25% (sample ≥ 5) or whose prompts are expensive (>1000
     input tokens) with mediocre payoff. Improvements get
     source="tuner", category="tuning". No LLM call.

New files:
  runtime/coach/llm-call.js        — askAnalytical() helper
  runtime/coach/trigger-tuner.js   — stats → improvements
  runtime/coach/trigger-tuner.test.js
  scripts/list-improvements.js     — operator CLI

Schema additions:
  advisor_recommendations: id, ts, trigger_reason, planned_skill,
    recommended_skill, action, rationale, active_need, tokens_in,
    tokens_out, latency_ms, applied, outcome_ok, outcome_code, outcome_at
  improvement_requests: id, ts, source, category, title, description,
    context, priority, status, duplicate_of, votes, implemented_at, notes

Renamed env-var consumers:
  Pi-coach drainOnce({ askPi })   → drainOnce({ askAnalyticalFn? })
  Pi-reflect runOnce({ askPi })   → runOnce({ askAnalyticalFn? })
  bot.js attachCoach/attachReflect no longer pass askPi
  attachTuner() added to bot.js spawn handler
  lessons.source 'pi-coach'   → 'timeweb-coach'
  lessons.source 'pi-reflect' → 'timeweb-reflect'

Token cost measured live:
  ~705 input + 45 output = ~750 total per advisor call
  worst case @ 6 calls/hour rate cap = ~108K tokens/day
  OpenAI gpt-5-mini reference price: ~$0.60/month

Operator usage:
  node scripts/list-improvements.js                # open queue
  node scripts/list-improvements.js --stats        # advisor performance
  node scripts/list-improvements.js --done 17 "shipped in 0.3.1"
  node scripts/list-improvements.js --reject 18 "duplicate"

Tests: 360 green (was 332, +28 new).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

runtime/knowledge/knowledge.test.js

@@ -22,6 +22,14 @@ import {
 	recordPOI,
 	poiNearby,
 	logChat,
+	insertRecommendation,
+	markRecommendationApplied,
+	markRecommendationOutcome,
+	recommendationStats,
+	recentRecommendations,
+	createImprovementRequest,
+	listImprovements,
+	markImprovementStatus,
 } from "./index.js";
 import { __resetForTests, closeStore } from "./store.js";
 
@@ -217,6 +225,112 @@ test("chat log: append + select", async () => {
 	assert.ok(id1 && id2);
 });
 
+// ---- v0.3.0 advisor recommendations ---------------------------------------
+
+test("advisor recommendations: insert → markApplied → markOutcome → stats", async () => {
+	await bootstrap();
+	if (!isAvailable()) {
+		assert.equal(insertRecommendation({ triggerReason: "x", action: "switch_skill" }), null);
+		return;
+	}
+	const id = insertRecommendation({
+		triggerReason: "wedged_90s",
+		plannedSkill: "explore.far",
+		recommendedSkill: "recovery.tunnel-out",
+		action: "switch_skill",
+		rationale: "Stuck wedged, tunnel out.",
+		activeNeed: "L2 tools_wood",
+		tokensIn: 700, tokensOut: 40, latencyMs: 5000,
+	});
+	assert.ok(id, "got recommendation id");
+	markRecommendationApplied(id);
+	markRecommendationOutcome(id, { ok: true, code: "done" });
+
+	const recent = recentRecommendations({ limit: 5 });
+	const row = recent.find((r) => r.id === id);
+	assert.ok(row);
+	assert.equal(row.applied, 1);
+	assert.equal(row.outcome_ok, 1);
+
+	// second insert with same trigger to test stats grouping
+	const id2 = insertRecommendation({
+		triggerReason: "wedged_90s",
+		plannedSkill: "explore.far",
+		recommendedSkill: "survive.pillar-up",
+		action: "switch_skill",
+		rationale: "Try pillar.",
+		tokensIn: 720, tokensOut: 50, latencyMs: 6000,
+	});
+	markRecommendationApplied(id2);
+	markRecommendationOutcome(id2, { ok: false, code: "no_progress" });
+
+	const stats = recommendationStats({ sinceHours: 24 });
+	const wedged = stats.find((s) => s.trigger_reason === "wedged_90s");
+	assert.ok(wedged);
+	assert.equal(wedged.total, 2);
+	assert.equal(wedged.applied, 2);
+	assert.equal(wedged.succeeded, 1);
+	assert.equal(wedged.failed, 1);
+});
+
+test("advisor recommendations: graceful no-op on unknown id", async () => {
+	await bootstrap();
+	if (!isAvailable()) return;
+	markRecommendationApplied(null);
+	markRecommendationOutcome(null, { ok: true });
+	markRecommendationOutcome(999999, { ok: true });
+	// no throw = pass
+});
+
+// ---- v0.3.0 improvement requests ------------------------------------------
+
+test("improvement requests: create, dedup-by-title bumps votes, list filters", async () => {
+	await bootstrap();
+	if (!isAvailable()) {
+		assert.equal(createImprovementRequest({ title: "x" }), null);
+		return;
+	}
+	const id1 = createImprovementRequest({
+		source: "postmortem",
+		category: "skill",
+		title: "Add craft.iron-pickaxe skill",
+		description: "Bot has iron ingots but no skill to craft tier-3 pickaxe.",
+		priority: 2,
+	});
+	assert.ok(id1);
+
+	// duplicate title → bumps votes, returns same id
+	const id2 = createImprovementRequest({
+		source: "reflect",
+		category: "skill",
+		title: "Add craft.iron-pickaxe skill",
+		priority: 2,
+	});
+	assert.equal(id2, id1, "dedup returns original id");
+
+	const list = listImprovements({ status: "open", category: "skill" });
+	const row = list.find((r) => r.id === id1);
+	assert.ok(row);
+	assert.equal(row.votes, 2, "votes bumped by duplicate");
+
+	markImprovementStatus(id1, { status: "implemented", notes: "Shipped in v0.3.1" });
+	const updated = listImprovements({ status: "implemented" });
+	assert.ok(updated.some((r) => r.id === id1));
+	const stillOpen = listImprovements({ status: "open" });
+	assert.ok(!stillOpen.some((r) => r.id === id1));
+});
+
+test("improvement requests: priority and status ordering", async () => {
+	await bootstrap();
+	if (!isAvailable()) return;
+	const a = createImprovementRequest({ source: "manual", title: "low-prio thing", priority: 5 });
+	const b = createImprovementRequest({ source: "manual", title: "high-prio thing", priority: 1 });
+	const list = listImprovements({ status: "open" });
+	const ai = list.findIndex((r) => r.id === a);
+	const bi = list.findIndex((r) => r.id === b);
+	assert.ok(bi < ai, "priority 1 listed before priority 5");
+});
+
 // Cleanup: close DB and remove tmp dir.
 test("teardown", () => {
 	closeStore();