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/coach/llm-call.js

@@ -0,0 +1,44 @@
+// Shared helper for the slow-analytical coach loops (postmortem.js,
+// reflect.js). Replaces the old askPi-based subprocess path with a
+// direct TimeWeb / OpenAI-compatible HTTP call.
+//
+// Why this split: postmortem and reflect each took 5-15s via Pi CLI
+// (with its own subprocess + auth + sometimes a fresh MC connection)
+// and were rate-limited by the subscription. Now they take 5-15s via
+// the same TimeWeb endpoint the fast-advisor uses — but they're
+// analytical, NOT tactical, so they ask for a different prompt shape
+// and a longer reply.
+//
+// The Pi CLI is no longer driven from background timers. It remains
+// available for manual operator commands.
+
+import { complete } from "../llm/provider.js";
+import { warn } from "../log.js";
+
+const ANALYTICAL_TIMEOUT_MS = 30_000;
+
+/**
+ * askAnalytical({ system, user, json }) → text|object|null
+ *
+ * Higher-timeout, lower-temperature companion to fast-advisor's
+ * complete(). Returns just the parsed text/object on success or null
+ * on failure (so callers can keep their old "no reply" branch).
+ *
+ * Token usage is logged via the underlying provider — no extra
+ * accounting here.
+ */
+export async function askAnalytical({ system, user, json = true, timeoutMs } = {}) {
+	const res = await complete({
+		system,
+		user,
+		json,
+		timeoutMs: timeoutMs ?? ANALYTICAL_TIMEOUT_MS,
+	});
+	if (!res.ok) {
+		warn("coach-llm", `analytical call failed: ${res.code} (${res.detail})`);
+		return null;
+	}
+	return res.text;
+}
+
+export { ANALYTICAL_TIMEOUT_MS };