feat(v0.3.1): storyline — canonical Minecraft survival quest

The bot has been stuck in a loop for two days:
  acquire-food (fail: no nearby food) → explore.far → pillar-up (fail) → repeat

Diagnosis: manifesto + LLM advisor both correctly identify "you need
food" but neither expresses *what concretely to do next*. Manifesto is
a priority ladder (need-detection), not a narrative arc.

This commit adds the missing narrative layer — an ordered list of
operational steps that mirror the vanilla Minecraft survival path:

  1. orient_self      — Понять где я
  2. first_wood       — Собрать 8 поленьев
  3. crafting_basics  — Сделать верстак и палки
  4. first_tools      — Деревянные орудия
  5. first_food       — Найти первую еду
  6. shelter_minimal  — Простой шелтер с кроватью
  7. stone_tier       — Каменные орудия
  8. food_security    — Запас еды на 16+
  9. iron_age         — Железо и печь
  10. settle_base     — Постоянная база
  11. village_grow    — Развивать деревню (ongoing)

Each step has:
  - completed(snapshot) → bool — detects achievement from snapshot
  - suggestSkill(snapshot) → { skillId, args? } — concrete next dispatch
  - emergencyPause(snapshot) → bool — defers to manifesto L0 alive
    emergencies (low HP near hostile, lava under foot, food = 0)
  - narration_ru — chat-friendly Russian one-liner spoken on entry

Components:

- runtime/goal/storyline.js — 11-step canonical quest catalogue
- runtime/goal/state.js — pickCurrentStep(snapshot) walks the list,
  returns first non-completed step + its suggestion. 3s cache.
  Validates suggestSkill's skillId against the live registry.
- runtime/reflex.js — curriculumReflex dispatch priority is now:
    1. manifesto (L0 alive emergencies always win)
    2. storyline (concrete operational subgoal)
    3. curriculum plan (legacy fallback)
  Tests pass ctx.disableStoryline=true for isolation.
- runtime/bot.js — snapshot.storyStep populated each tick so
  chatter/advisor/reflect observers see the same view.
- runtime/coach/fast-advisor.js — buildUserPrompt now embeds the
  current step + its suggested skill, so LLM advice is anchored
  ("step 5 first_food, storyline wants survive.acquire-food, but
  recent dispatches show it's failing — try explore.far + scout").
- runtime/coach/advisor-trigger.js — forwards ctx.storyStep into
  advise() and logs step id at trigger time.
- runtime/coach/reflect.js — reflection prompt includes storyline
  progress so 30-min self-assessment is anchored.
- runtime/persona/chatter.js — narrates step.narration_ru on
  transition. Rate-limited via existing maybeNarrateRaw().

New operator CLI:

- scripts/show-story.js — fetches the live snapshot via IPC sock and
  prints step progress with ✓/→/ markers, current skill, inventory.
  Falls back to --plain catalogue view when bot offline.

Token cost impact: ~+30 input tokens per advise() call (one extra
line in user prompt). Trivial vs the value of grounding LLM advice
in a concrete narrative.

Operator usage:

  node scripts/show-story.js          # live progress + which step + why
  node scripts/show-story.js --plain  # static catalogue of all 11 steps

Tests: 376 green (was 360, +16 storyline tests).

Also in this branch (already committed): dev/v0.3.1/PRD.md —
LLM prompt cost optimization design doc.

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

runtime/goal/state.js

@@ -0,0 +1,88 @@
+// Storyline state: which step the bot is currently on.
+//
+// pickCurrentStep(snapshot) walks STORYLINE from the top and returns
+// the first non-completed step. If an emergency condition fires
+// (low HP near hostile, lava under foot, etc.) the step is paused and
+// callers should defer to manifesto's L0 alive emergency dispatch
+// instead of step.suggestSkill.
+
+import { STORYLINE, getStep } from "./storyline.js";
+import { isRegistered } from "../skill-registry.js";
+import { info } from "../log.js";
+
+const CACHE_TTL_MS = 3_000;
+
+let _cache = null;
+let _lastStepId = null;
+
+export function _resetForTest() {
+	_cache = null;
+	_lastStepId = null;
+}
+
+/**
+ * pickCurrentStep(snapshot) →
+ *   {
+ *     step: { id, title, narration_ru },
+ *     index: number,                            // 0-based position
+ *     suggestion: { skillId, args } | null,
+ *     emergency: boolean,                        // true if emergencyPause fires
+ *     completedSteps: number                     // how many done so far
+ *   } | null
+ */
+export function pickCurrentStep(snapshot) {
+	if (!snapshot?.connected) return null;
+	const now = Date.now();
+	if (_cache && _cache.snapshot === snapshot && now - _cache.ts < CACHE_TTL_MS) {
+		return _cache.result;
+	}
+	let completedSteps = 0;
+	let chosen = null;
+	for (let i = 0; i < STORYLINE.length; i++) {
+		const step = STORYLINE[i];
+		let done;
+		try { done = !!step.completed(snapshot); } catch { done = false; }
+		if (done) {
+			completedSteps += 1;
+			continue;
+		}
+		let emergency = false;
+		try { emergency = !!step.emergencyPause?.(snapshot); } catch {}
+		let suggestion = null;
+		if (!emergency) {
+			try { suggestion = step.suggestSkill(snapshot) ?? null; } catch { suggestion = null; }
+			if (suggestion?.skillId && !isRegistered(suggestion.skillId)) {
+				info("storyline", `step ${step.id}: suggested unknown skill ${suggestion.skillId}; dropping`);
+				suggestion = null;
+			}
+		}
+		chosen = {
+			step: { id: step.id, title: step.title, narration_ru: step.narration_ru },
+			index: i,
+			suggestion,
+			emergency,
+			completedSteps,
+		};
+		break;
+	}
+	if (chosen && _lastStepId !== chosen.step.id) {
+		info("storyline", `step ${chosen.index + 1}/${STORYLINE.length}: ${chosen.step.id} — ${chosen.step.title} → ${chosen.suggestion?.skillId ?? "(no concrete skill)"}`);
+		_lastStepId = chosen.step.id;
+	}
+	_cache = { snapshot, ts: now, result: chosen };
+	return chosen;
+}
+
+/**
+ * progressSummary(snapshot) → string, e.g.
+ *   "step 3/11 'first_tools' — Деревянные орудия → craft.wooden-pickaxe"
+ */
+export function progressSummary(snapshot) {
+	const cur = pickCurrentStep(snapshot);
+	if (!cur) return "(no storyline progress — disconnected)";
+	const tail = cur.suggestion?.skillId ? ` → ${cur.suggestion.skillId}` : "";
+	const emer = cur.emergency ? " [EMERGENCY PAUSE]" : "";
+	return `step ${cur.index + 1}/${STORYLINE.length} '${cur.step.id}' — ${cur.step.title}${tail}${emer}`;
+}
+
+export { STORYLINE, getStep };