@forbocai/test-game 0.6.0 → 0.6.2

package/dist/cli.mjs

@@ -1,7 +1,747 @@
 #!/usr/bin/env node
-import {
-  runGame
-} from "./chunk-4XIOL463.mjs";
+
+// src/game.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/features/autoplay/slices/harnessSlice.ts
+import { createSlice } from "@reduxjs/toolkit";
+
+// src/lib/coverage.ts
+var REQUIRED_GROUPS = [
+  "status",
+  "npc_lifecycle",
+  "npc_process_chat",
+  "memory_list",
+  "memory_recall",
+  "memory_store",
+  "memory_clear",
+  "memory_export",
+  "bridge_rules",
+  "bridge_validate",
+  "bridge_preset",
+  "soul_export",
+  "soul_import",
+  "soul_list",
+  "soul_chat",
+  "ghost_lifecycle",
+  "cortex_init"
+];
+
+// src/features/autoplay/slices/harnessSlice.ts
+var initialState = {
+  covered: {}
+};
+var harnessSlice = createSlice({
+  name: "harness",
+  initialState,
+  reducers: {
+    markCovered: (state, action) => {
+      state.covered[action.payload] = true;
+    },
+    resetCoverage: (state) => {
+      state.covered = {};
+    }
+  }
+});
+var harnessReducer = harnessSlice.reducer;
+var harnessActions = harnessSlice.actions;
+var selectMissingGroups = (covered) => REQUIRED_GROUPS.filter((g) => !covered[g]);
+
+// src/features/mechanics/slices/socialSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {};
+var socialSlice = createSlice2({
+  name: "social",
+  initialState: initialState2,
+  reducers: {
+    setDialogue: (state, action) => {
+      state.activeDialogue = action.payload;
+    },
+    setTradeOffer: (state, action) => {
+      state.activeTrade = action.payload;
+    },
+    clearSocialState: (state) => {
+      state.activeDialogue = void 0;
+      state.activeTrade = void 0;
+    }
+  }
+});
+var socialReducer = socialSlice.reducer;
+var socialActions = socialSlice.actions;
+
+// src/features/mechanics/slices/stealthSlice.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
+  doorOpen: false,
+  alertLevel: 0
+};
+var stealthSlice = createSlice3({
+  name: "stealth",
+  initialState: initialState3,
+  reducers: {
+    setDoorOpen: (state, action) => {
+      state.doorOpen = action.payload;
+    },
+    bumpAlert: (state, action) => {
+      state.alertLevel = Math.max(0, Math.min(100, state.alertLevel + action.payload));
+    }
+  }
+});
+var stealthReducer = stealthSlice.reducer;
+var stealthActions = stealthSlice.actions;
+
+// src/features/entities/slices/npcsSlice.ts
+import { createEntityAdapter, createSlice as createSlice4 } from "@reduxjs/toolkit";
+var npcsAdapter = createEntityAdapter();
+var npcsSlice = createSlice4({
+  name: "npcs",
+  initialState: npcsAdapter.getInitialState(),
+  reducers: {
+    upsertNPC: npcsAdapter.upsertOne,
+    moveNPC: (state, action) => {
+      npcsAdapter.updateOne(state, {
+        id: action.payload.id,
+        changes: { position: action.payload.position }
+      });
+    },
+    patchNPC: (state, action) => {
+      npcsAdapter.updateOne(state, {
+        id: action.payload.id,
+        changes: action.payload.patch
+      });
+    },
+    /**
+     * Applies a validated verdict handed back via the SDK (real CLI output).
+     * This is a "fat reducer" containing business logic for state transitions.
+     */
+    applyNpcVerdict: (state, action) => {
+      const { id, verdict } = action.payload;
+      const npc = state.entities[id];
+      if (!npc) return;
+      npcsAdapter.updateOne(state, {
+        id,
+        changes: {
+          ...verdict.stateDelta,
+          // If the action is a MOVE, update the position from the payload
+          position: verdict.action.type === "MOVE" ? verdict.action.payload.targetHex : npc.position
+        }
+      });
+    }
+  }
+});
+var npcsReducer = npcsSlice.reducer;
+var npcsActions = npcsSlice.actions;
+var npcsSelectors = npcsAdapter.getSelectors(
+  (root) => root.npcs
+);
+
+// src/features/entities/slices/playerSlice.ts
+import { createSlice as createSlice5 } from "@reduxjs/toolkit";
+var initialState4 = {
+  name: "Scout",
+  hp: 100,
+  hidden: true,
+  position: { x: 1, y: 1 },
+  inventory: ["coin-pouch"]
+};
+var playerSlice = createSlice5({
+  name: "player",
+  initialState: initialState4,
+  reducers: {
+    setPosition: (state, action) => {
+      state.position = action.payload;
+    },
+    setHidden: (state, action) => {
+      state.hidden = action.payload;
+    },
+    patchPlayer: (state, action) => {
+      Object.assign(state, action.payload);
+    }
+  }
+});
+var playerReducer = playerSlice.reducer;
+var playerActions = playerSlice.actions;
+
+// src/features/store/slices/memorySlice.ts
+import { createEntityAdapter as createEntityAdapter2, createSlice as createSlice6 } from "@reduxjs/toolkit";
+var memoryAdapter = createEntityAdapter2();
+var memorySlice = createSlice6({
+  name: "memory",
+  initialState: memoryAdapter.getInitialState(),
+  reducers: {
+    storeMemory: memoryAdapter.addOne,
+    clearMemoryForNpc: (state, action) => {
+      const npcMemories = Object.values(state.entities).filter((r) => r?.npcId === action.payload).map((r) => r.id);
+      memoryAdapter.removeMany(state, npcMemories);
+    }
+  }
+});
+var memoryReducer = memorySlice.reducer;
+var memoryActions = memorySlice.actions;
+var memorySelectors = memoryAdapter.getSelectors(
+  (root) => root.memory
+);
+
+// src/features/store/slices/soulSlice.ts
+import { createSlice as createSlice7 } from "@reduxjs/toolkit";
+var initialState5 = {
+  exportsByNpc: {},
+  importedSoulTxIds: []
+};
+var soulSlice = createSlice7({
+  name: "soul",
+  initialState: initialState5,
+  reducers: {
+    markSoulExported: (state, action) => {
+      state.exportsByNpc[action.payload.npcId] = action.payload.txId;
+    },
+    markSoulImported: (state, action) => {
+      state.importedSoulTxIds.push(action.payload);
+    }
+  }
+});
+var soulReducer = soulSlice.reducer;
+var soulActions = soulSlice.actions;
+
+// src/features/terminal/slices/transcriptSlice.ts
+import { createSlice as createSlice8 } from "@reduxjs/toolkit";
+var initialState6 = {
+  entries: []
+};
+var transcriptSlice = createSlice8({
+  name: "transcript",
+  initialState: initialState6,
+  reducers: {
+    recordTranscript: {
+      reducer: (state, action) => {
+        state.entries.push(action.payload);
+      },
+      prepare: (payload) => ({
+        payload: {
+          ...payload,
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      })
+    },
+    resetTranscript: (state) => {
+      state.entries = [];
+    }
+  }
+});
+var transcriptReducer = transcriptSlice.reducer;
+var transcriptActions = transcriptSlice.actions;
+
+// src/features/terminal/slices/uiSlice.ts
+import { createSlice as createSlice9 } from "@reduxjs/toolkit";
+var initialState7 = {
+  mode: "autoplay",
+  messages: ["SYSTEM_OVERRIDE :: terminal HUD online"]
+};
+var uiSlice = createSlice9({
+  name: "ui",
+  initialState: initialState7,
+  reducers: {
+    setMode: (state, action) => {
+      state.mode = action.payload;
+    },
+    addMessage: (state, action) => {
+      state.messages.push(action.payload);
+    }
+  }
+});
+var uiReducer = uiSlice.reducer;
+var uiActions = uiSlice.actions;
+
+// src/lib/commandRunner.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var runCommand = async (command) => {
+  try {
+    const { stdout, stderr } = await execAsync(command.command, { timeout: 1e4 });
+    const output2 = [stdout, stderr].filter(Boolean).join("\n").trim();
+    return { status: "ok", output: output2 || "Command completed." };
+  } catch (error) {
+    const output2 = [error?.stdout, error?.stderr, error?.message].filter(Boolean).join("\n").trim();
+    return { status: "error", output: output2 || "Command failed." };
+  }
+};
+
+// src/lib/render.ts
+var cellAt = (pos, state) => {
+  const isBlocked = state.grid.blocked.some((b) => b.x === pos.x && b.y === pos.y);
+  if (isBlocked) return "#";
+  if (state.player.position.x === pos.x && state.player.position.y === pos.y) {
+    return "P";
+  }
+  for (const npc of Object.values(state.npcs.entities)) {
+    if (!npc) continue;
+    if (npc.position.x === pos.x && npc.position.y === pos.y) return npc.id === "miller" ? "M" : "D";
+  }
+  return ".";
+};
+var renderGrid = (state) => {
+  const rows = [];
+  for (let y = 0; y < state.grid.height; y += 1) {
+    const cells = [];
+    for (let x = 0; x < state.grid.width; x += 1) {
+      cells.push(cellAt({ x, y }, state));
+    }
+    rows.push(cells.join(" "));
+  }
+  return rows.join("\n");
+};
+var renderLegend = () => "Legend :: P=Scout  D=Doomguard  M=Miller  #=Blocked Tile  .=Open Tile";
+
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+
+// src/features/mechanics/slices/gridSlice.ts
+import { createSlice as createSlice10 } from "@reduxjs/toolkit";
+var initialState8 = {
+  width: 8,
+  height: 8,
+  blocked: [{ x: 4, y: 4 }, { x: 4, y: 5 }, { x: 6, y: 2 }]
+};
+var gridSlice = createSlice10({
+  name: "grid",
+  initialState: initialState8,
+  reducers: {
+    setGridSize: (state, action) => {
+      state.width = action.payload.width;
+      state.height = action.payload.height;
+    },
+    setBlocked: (state, action) => {
+      state.blocked = action.payload;
+    }
+  }
+});
+var gridReducer = gridSlice.reducer;
+var gridActions = gridSlice.actions;
+
+// src/features/mechanics/slices/bridgeSlice.ts
+import { createSlice as createSlice11 } from "@reduxjs/toolkit";
+var initialState9 = {
+  maxJumpForce: 500,
+  maxMoveDistance: 2,
+  activePreset: "default"
+};
+var bridgeSlice = createSlice11({
+  name: "bridge",
+  initialState: initialState9,
+  reducers: {
+    setBridgeRules: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    loadBridgePreset: (state, action) => {
+      state.activePreset = action.payload;
+      if (action.payload === "social") {
+        state.maxMoveDistance = 1;
+      }
+      if (action.payload === "default") {
+        state.maxMoveDistance = 2;
+      }
+    }
+  }
+});
+var bridgeReducer = bridgeSlice.reducer;
+var bridgeActions = bridgeSlice.actions;
+
+// src/features/store/slices/inventorySlice.ts
+import { createSlice as createSlice12 } from "@reduxjs/toolkit";
+var initialState10 = {
+  byOwner: {
+    player: ["coin-pouch"],
+    miller: ["medkit"]
+  }
+};
+var inventorySlice = createSlice12({
+  name: "inventory",
+  initialState: initialState10,
+  reducers: {
+    setOwnerInventory: (state, action) => {
+      state.byOwner[action.payload.ownerId] = action.payload.items;
+    }
+  }
+});
+var inventoryReducer = inventorySlice.reducer;
+var inventoryActions = inventorySlice.actions;
+
+// src/features/autoplay/slices/scenarioSlice.ts
+import { createSlice as createSlice13 } from "@reduxjs/toolkit";
+var steps = [
+  {
+    id: "stealth-door-open",
+    title: "Spatial Strategy & Stealth",
+    description: "Armory door is left open. Doomguard patrol processes observation and stores memory.",
+    eventType: "stealth",
+    commands: [
+      { group: "status", command: "forbocai status", expectedRoutes: ["GET /status"] },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc state doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc update doomguard faction Doomguards",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "The armory door is open"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_store",
+        command: 'forbocai memory store doomguard "Armory door found open at x:5, y:12"',
+        expectedRoutes: ["POST /npcs/{id}/memory"]
+      },
+      {
+        group: "memory_list",
+        command: "forbocai memory list doomguard",
+        expectedRoutes: ["GET /npcs/{id}/memory"]
+      },
+      {
+        group: "bridge_rules",
+        command: "forbocai bridge rules",
+        expectedRoutes: ["GET /bridge/rules"]
+      }
+    ]
+  },
+  {
+    id: "social-miller-encounter",
+    title: "Social Simulation",
+    description: "Miller encounter triggers recall, dialogue, and trade offer.",
+    eventType: "social",
+    commands: [
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create miller",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc chat miller --text "I come in peace"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_recall",
+        command: 'forbocai memory recall miller "player interaction"',
+        expectedRoutes: ["POST /npcs/{id}/memory/recall"]
+      },
+      {
+        group: "bridge_preset",
+        command: "forbocai bridge preset social",
+        expectedRoutes: ["POST /rules/presets/{id}"]
+      },
+      {
+        group: "soul_export",
+        command: "forbocai soul export miller",
+        expectedRoutes: ["POST /npcs/{id}/soul/export"]
+      },
+      {
+        group: "soul_list",
+        command: "forbocai soul list",
+        expectedRoutes: ["GET /souls"]
+      }
+    ]
+  },
+  {
+    id: "escape-realtime-pursuit",
+    title: "Real-Time Escape",
+    description: "Harness loop fires process commands and validates jump force via bridge rules.",
+    eventType: "escape",
+    commands: [
+      {
+        group: "bridge_validate",
+        command: "forbocai bridge validate doomguard-jump",
+        expectedRoutes: ["POST /bridge/validate", "POST /bridge/validate/{id}"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player is escaping"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player jumped the gap"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player reached the gate"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost run smoke",
+        expectedRoutes: ["POST /ghost/run"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost status ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/status"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost results ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/results"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost stop ghost-001",
+        expectedRoutes: ["POST /ghost/{id}/stop"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost history",
+        expectedRoutes: ["GET /ghost/history"]
+      }
+    ]
+  },
+  {
+    id: "persistence-recovery",
+    title: "Persistence & Recovery",
+    description: "Exercises memory export/clear and soul import/chat continuity.",
+    eventType: "persistence",
+    commands: [
+      {
+        group: "memory_export",
+        command: "forbocai memory export doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "memory_clear",
+        command: "forbocai memory clear doomguard",
+        expectedRoutes: ["DELETE /npcs/{id}/memory/clear"]
+      },
+      {
+        group: "soul_import",
+        command: "forbocai soul import tx-demo-001",
+        expectedRoutes: ["GET /souls/{txId}", "POST /npcs/import"]
+      },
+      {
+        group: "soul_chat",
+        command: 'forbocai soul chat doomguard --text "What do you remember?"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "cortex_init",
+        command: "forbocai cortex init --remote",
+        expectedRoutes: ["POST /cortex/init"]
+      }
+    ]
+  }
+];
+var scenarioSlice = createSlice13({
+  name: "scenario",
+  initialState: {
+    steps
+  },
+  reducers: {}
+});
+var scenarioReducer = scenarioSlice.reducer;
+
+// src/listeners.ts
+import { createListenerMiddleware, isAnyOf } from "@reduxjs/toolkit";
+var listenerMiddleware = createListenerMiddleware();
+listenerMiddleware.startListening({
+  matcher: isAnyOf(npcsActions.moveNPC, npcsActions.patchNPC, npcsActions.applyNpcVerdict),
+  effect: (action, listenerApi) => {
+    const state = listenerApi.getState();
+    if (npcsActions.moveNPC.match(action)) {
+      const npc = state.npcs.entities[action.payload.id];
+      if (npc) {
+        listenerApi.dispatch(uiActions.addMessage(`${npc.name} moved to ${action.payload.position.x},${action.payload.position.y}`));
+      }
+    }
+  }
+});
+
+// src/store.ts
+var createTestGameStore = () => configureStore({
+  reducer: {
+    npcs: npcsReducer,
+    player: playerReducer,
+    grid: gridReducer,
+    stealth: stealthReducer,
+    social: socialReducer,
+    bridge: bridgeReducer,
+    memory: memoryReducer,
+    inventory: inventoryReducer,
+    soul: soulReducer,
+    ui: uiReducer,
+    transcript: transcriptReducer,
+    scenario: scenarioReducer,
+    harness: harnessReducer
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().prepend(listenerMiddleware.middleware)
+});
+
+// src/game.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var tryParseVerdict = (output2) => {
+  try {
+    const match = output2.match(/\{[\s\S]*\}/);
+    if (match) return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+  return null;
+};
+var applyScenarioInitialState = (step, store) => {
+  if (step.eventType === "stealth") {
+    store.dispatch(stealthActions.setDoorOpen(true));
+    store.dispatch(stealthActions.bumpAlert(25));
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "doomguard",
+        name: "Doomguard Patrol",
+        faction: "Doomguards",
+        hp: 100,
+        suspicion: 40,
+        inventory: [],
+        knownSecrets: [],
+        position: { x: 5, y: 10 }
+      })
+    );
+    store.dispatch(
+      memoryActions.storeMemory({
+        id: "mem-door-001",
+        npcId: "doomguard",
+        text: "Armory door found open at x:5, y:12",
+        importance: 0.9
+      })
+    );
+  }
+  if (step.eventType === "social") {
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "miller",
+        name: "Miller",
+        faction: "Neutral",
+        hp: 100,
+        suspicion: 50,
+        inventory: ["medkit"],
+        knownSecrets: ["player_stole_rations"],
+        position: { x: 5, y: 12 }
+      })
+    );
+    store.dispatch(socialActions.setDialogue("I know you took those rations..."));
+    store.dispatch(socialActions.setTradeOffer({ npcId: "miller", item: "medkit", price: 100 }));
+    store.dispatch(npcsActions.patchNPC({ id: "miller", patch: { suspicion: 75 } }));
+  }
+  if (step.eventType === "escape") {
+    store.dispatch(playerActions.setHidden(false));
+  }
+  if (step.eventType === "persistence") {
+    store.dispatch(soulActions.markSoulExported({ npcId: "doomguard", txId: "tx-demo-001" }));
+    store.dispatch(soulActions.markSoulImported("tx-demo-001"));
+    store.dispatch(memoryActions.clearMemoryForNpc("doomguard"));
+  }
+};
+var runGame = async ({
+  mode
+}) => {
+  console.log("\n[VOID::WATCHER] Echoes session booting...");
+  console.log(`NEURAL_LINK_ESTABLISHED :: mode=${mode}
+`);
+  const store = createTestGameStore();
+  store.dispatch(uiActions.setMode(mode));
+  store.dispatch(
+    npcsActions.upsertNPC({
+      id: "scout",
+      name: "Scout",
+      faction: "Player",
+      hp: 100,
+      suspicion: 0,
+      inventory: ["coin-pouch"],
+      knownSecrets: [],
+      position: { x: 1, y: 1 }
+    })
+  );
+  const rl = mode === "manual" ? createInterface({ input, output }) : null;
+  console.log(renderLegend());
+  for (const step of store.getState().scenario.steps) {
+    if (mode === "manual") {
+      console.log(`
+\u256D\u2500 ${step.title} \u2500\u256E`);
+      console.log(step.description);
+      console.log("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F\n");
+      console.log(renderGrid(store.getState()));
+      await rl?.question("> Press Enter to execute this trace segment...");
+    } else {
+      console.log(`
+:: ${step.title}`);
+      console.log(step.description);
+    }
+    applyScenarioInitialState(step, store);
+    for (const command of step.commands) {
+      const result = await runCommand(command);
+      store.dispatch(harnessActions.markCovered(command.group));
+      store.dispatch(
+        transcriptActions.recordTranscript({
+          scenarioId: step.id,
+          commandGroup: command.group,
+          command: command.command,
+          expectedRoutes: command.expectedRoutes,
+          status: result.status,
+          output: result.output
+        })
+      );
+      if (command.group === "npc_process_chat") {
+        const verdict = tryParseVerdict(result.output);
+        if (verdict && verdict.action) {
+          const npcIdMatch = command.command.match(/npc (?:process|chat) (\w+)/);
+          const npcId = npcIdMatch ? npcIdMatch[1] : null;
+          if (npcId) {
+            store.dispatch(npcsActions.applyNpcVerdict({ id: npcId, verdict }));
+          }
+        }
+      }
+      if (command.group === "bridge_validate") {
+        const validation = tryParseVerdict(result.output);
+        if (validation && !validation.valid) {
+          store.dispatch(uiActions.addMessage(`System Bridge Blocked Action: ${validation.reason}`));
+        }
+      }
+      console.log(`[${result.status}] ${command.command}`);
+      if (result.status === "error") {
+        console.log("LOG_ERR_CRITICAL :: command execution fault recorded");
+      }
+    }
+    if (mode === "autoplay") {
+      await delay(500);
+    }
+  }
+  rl?.close();
+  const state = store.getState();
+  const missingGroups = selectMissingGroups(state.harness.covered);
+  const complete = missingGroups.length === 0;
+  const summary = complete ? `Run complete: all ${Object.keys(state.harness.covered).length} command groups were exercised.` : `Run incomplete: missing command groups -> ${missingGroups.join(", ")}`;
+  console.log("\n=== Transcript Summary // chrome rain ledger ===");
+  for (const entry of state.transcript.entries) {
+    console.log(
+      `${entry.at} | ${entry.commandGroup} | ${entry.status} | ${entry.command} | routes: ${entry.expectedRoutes.join(", ")}`
+    );
+  }
+  console.log("\n\u16A0 \u16A2 \u16A6 \u16A8 \u16B1 \u16B2 \u16B7 \u16B9");
+  console.log(summary);
+  return {
+    complete,
+    missingGroups,
+    transcript: state.transcript.entries,
+    summary
+  };
+};
 
 // src/cli.ts
 var usage = () => {