@forbocai/test-game 0.6.0

package/dist/index.js

@@ -0,0 +1,774 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  REQUIRED_GROUPS: () => REQUIRED_GROUPS,
+  runGame: () => runGame
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/game.ts
+var import_promises = require("readline/promises");
+var import_node_process = require("process");
+
+// src/features/autoplay/slices/harnessSlice.ts
+var import_toolkit = require("@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 = (0, import_toolkit.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
+var import_toolkit2 = require("@reduxjs/toolkit");
+var initialState2 = {};
+var socialSlice = (0, import_toolkit2.createSlice)({
+  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
+var import_toolkit3 = require("@reduxjs/toolkit");
+var initialState3 = {
+  doorOpen: false,
+  alertLevel: 0
+};
+var stealthSlice = (0, import_toolkit3.createSlice)({
+  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
+var import_toolkit4 = require("@reduxjs/toolkit");
+var npcsAdapter = (0, import_toolkit4.createEntityAdapter)();
+var npcsSlice = (0, import_toolkit4.createSlice)({
+  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
+var import_toolkit5 = require("@reduxjs/toolkit");
+var initialState4 = {
+  name: "Scout",
+  hp: 100,
+  hidden: true,
+  position: { x: 1, y: 1 },
+  inventory: ["coin-pouch"]
+};
+var playerSlice = (0, import_toolkit5.createSlice)({
+  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
+var import_toolkit6 = require("@reduxjs/toolkit");
+var memoryAdapter = (0, import_toolkit6.createEntityAdapter)();
+var memorySlice = (0, import_toolkit6.createSlice)({
+  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
+var import_toolkit7 = require("@reduxjs/toolkit");
+var initialState5 = {
+  exportsByNpc: {},
+  importedSoulTxIds: []
+};
+var soulSlice = (0, import_toolkit7.createSlice)({
+  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
+var import_toolkit8 = require("@reduxjs/toolkit");
+var initialState6 = {
+  entries: []
+};
+var transcriptSlice = (0, import_toolkit8.createSlice)({
+  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
+var import_toolkit9 = require("@reduxjs/toolkit");
+var initialState7 = {
+  mode: "autoplay",
+  messages: ["SYSTEM_OVERRIDE :: terminal HUD online"]
+};
+var uiSlice = (0, import_toolkit9.createSlice)({
+  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
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.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
+var import_toolkit15 = require("@reduxjs/toolkit");
+
+// src/features/mechanics/slices/gridSlice.ts
+var import_toolkit10 = require("@reduxjs/toolkit");
+var initialState8 = {
+  width: 8,
+  height: 8,
+  blocked: [{ x: 4, y: 4 }, { x: 4, y: 5 }, { x: 6, y: 2 }]
+};
+var gridSlice = (0, import_toolkit10.createSlice)({
+  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
+var import_toolkit11 = require("@reduxjs/toolkit");
+var initialState9 = {
+  maxJumpForce: 500,
+  maxMoveDistance: 2,
+  activePreset: "default"
+};
+var bridgeSlice = (0, import_toolkit11.createSlice)({
+  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
+var import_toolkit12 = require("@reduxjs/toolkit");
+var initialState10 = {
+  byOwner: {
+    player: ["coin-pouch"],
+    miller: ["medkit"]
+  }
+};
+var inventorySlice = (0, import_toolkit12.createSlice)({
+  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
+var import_toolkit13 = require("@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 = (0, import_toolkit13.createSlice)({
+  name: "scenario",
+  initialState: {
+    steps
+  },
+  reducers: {}
+});
+var scenarioReducer = scenarioSlice.reducer;
+
+// src/listeners.ts
+var import_toolkit14 = require("@reduxjs/toolkit");
+var listenerMiddleware = (0, import_toolkit14.createListenerMiddleware)();
+listenerMiddleware.startListening({
+  matcher: (0, import_toolkit14.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 = () => (0, import_toolkit15.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" ? (0, import_promises.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout }) : 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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REQUIRED_GROUPS,
+  runGame
+});