@coreplane/switchboard 1.223.0 → 1.224.0

package/dist/cli.js

@@ -31681,7 +31681,7 @@ var init_bridge2 = __esm({
         return this.answerText ?? this.heldAnswer;
       }
       observe(event) {
-        const out = { replies: [], settled: false, turnEnded: false };
+        const out = { replies: [], settled: false };
         const disposition = PI_EVENT_DISPOSITION[event.type];
         if (disposition === void 0) {
           this.note("harness_error", `pi emitted an event kind this build does not know: ${redactAndCap(event.type, 80)}`);
@@ -31698,9 +31698,6 @@ var init_bridge2 = __esm({
           case "agent_settled":
             out.settled = true;
             break;
-          case "turn_end":
-            out.turnEnded = true;
-            break;
           case "message_start":
             if (isRecord3(event.message) && event.message.role === "assistant") this.assistantStartedAt = this.deps.clock();
             break;
@@ -31893,6 +31890,7 @@ var init_bridge2 = __esm({
 });
 
 // ../../src/core/harness/pi/mirror.ts
+import { isDeepStrictEqual } from "node:util";
 function partsOf2(content) {
   if (typeof content === "string") return [{ type: "text", text: content }];
   if (!Array.isArray(content)) return [];
@@ -32042,11 +32040,14 @@ var init_mirror = __esm({
       constructor(deps) {
         this.deps = deps;
         this.idx = deps.seedLength;
+        this.mirroredTail = deps.mirroredTail;
       }
       deps;
       idx;
       pendingUser = [];
-      seedEchoed = false;
+      /** pi is about to echo the seed's prompt as a user message (see `expectSeedEcho`). */
+      seedEchoPending = false;
+      mirroredTail;
       iteration = 0;
       /** The highest ledger inbox seq folded in so far (run-history item 40). */
       inboxConsumedSeq = 0;
@@ -32054,19 +32055,43 @@ var init_mirror = __esm({
       get wired() {
         return this.deps.onStep !== void 0;
       }
+      /** pi answered the seed's prompt: the first user message without results
+       *  that follows is its echo — the seed, on the ledger already — and is not
+       *  written twice. A continue prompt (harness-pi item 8) expects none: its
+       *  echo is a turn the model was told, folded in like a steer's text. */
+      expectSeedEcho() {
+        this.seedEchoPending = true;
+      }
+      /** The row about to be written, against the transcript's tail — compared
+       *  once, with the first row the mirror meets: equal means the ledger holds
+       *  it already (read again, harness-pi item 8), together with the results
+       *  pending before it, which were its step's user turn. */
+      alreadyHeld(row) {
+        const tail = this.mirroredTail;
+        if (tail === void 0) return false;
+        this.mirroredTail = void 0;
+        if (!isDeepStrictEqual(row, tail)) return false;
+        this.pendingUser = [];
+        return true;
+      }
+      /** Feeds one finished message; answers whether the ledger now holds
+       *  everything up to it — a step written, or an assistant turn found already
+       *  there — so the harness can move the row's offset past it. A result or a
+       *  steer's text waits in memory for the next step, and the answer is no. */
       async onMessage(message3, turn) {
-        if (!this.deps.onStep) return;
+        if (!this.deps.onStep) return false;
         const chat = chatMessageOf(message3);
-        if (!chat) return;
-        if (chat.content.length === 0) return;
+        if (!chat) return false;
+        if (chat.content.length === 0) return false;
         if (chat.role === "user") {
-          if (!this.seedEchoed && !chat.content.some((p) => p.type === "tool_result")) {
-            this.seedEchoed = true;
-            return;
+          if (this.seedEchoPending && !chat.content.some((p) => p.type === "tool_result")) {
+            this.seedEchoPending = false;
+            return false;
           }
           this.pendingUser.push(...chat.content);
-          return;
+          return false;
         }
+        if (this.alreadyHeld({ turn: chat })) return true;
         const turns = [];
         if (this.pendingUser.length > 0) turns.push({ role: "user", content: this.pendingUser });
         this.pendingUser = [];
@@ -32083,13 +32108,16 @@ var init_mirror = __esm({
         };
         this.idx += turns.length;
         await this.deps.onStep(report2);
+        return true;
       }
       /** pi compacted (session-log item 6): the results pending since the last
        *  assistant turn go as the user turn they would have been, the entry as the
        *  row after them — its own step with nothing in flight, so the log holds
-       *  the summary where pi wrote it and the index moves past it. */
+       *  the summary where pi wrote it and the index moves past it. Answers as
+       *  `onMessage` does: the ledger holds everything up to the entry. */
       async onCompaction(entry, turn) {
-        if (!this.deps.onStep) return;
+        if (!this.deps.onStep) return false;
+        if (this.alreadyHeld({ compaction: entry })) return true;
         const turns = [];
         if (this.pendingUser.length > 0) turns.push({ role: "user", content: this.pendingUser });
         this.pendingUser = [];
@@ -32105,6 +32133,7 @@ var init_mirror = __esm({
         };
         this.idx += turns.length + 1;
         await this.deps.onStep(report2);
+        return true;
       }
     };
   }
@@ -32121,11 +32150,16 @@ var init_transport = __esm({
       constructor(deps) {
         this.deps = deps;
         this.offset = deps.offset ?? 0;
+        this.consumedOffset = this.offset;
         this.lines = this.read();
       }
       deps;
-      /** The byte the next read starts at — the re-attach fact. */
+      /** The byte the next read starts at: the read position, moved by whole chunks. */
       offset;
+      /** The boundary after the record last handed out, moved by records: where a
+       *  reader that has seen everything so far continues from — the harness's
+       *  re-attach fact, taken when nothing handed out is left unwritten. */
+      consumedOffset;
       /** pi was found dead while the harness still listened. */
       exited = false;
       closed = false;
@@ -32178,11 +32212,15 @@ var init_transport = __esm({
       /** Complete lines out of the buffered bytes; the partial tail waits for more. */
       *split(chunk) {
         this.buffer = Buffer.concat([this.buffer, Buffer.from(chunk)]);
+        const base = this.offset - this.buffer.length;
         let start3 = 0;
         for (let i = this.buffer.indexOf(NEWLINE, start3); i >= 0; i = this.buffer.indexOf(NEWLINE, start3)) {
           let line3 = this.buffer.subarray(start3, i).toString("utf8");
           if (line3.endsWith("\r")) line3 = line3.slice(0, -1);
-          if (line3.length > 0) yield line3;
+          if (line3.length > 0) {
+            this.consumedOffset = base + i + 1;
+            yield line3;
+          }
           start3 = i + 1;
         }
         this.buffer = this.buffer.subarray(start3);
@@ -32192,6 +32230,7 @@ var init_transport = __esm({
 });
 
 // ../../src/core/harness/pi/harness.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 function piHarnessFactsOf(value) {
   if (typeof value !== "object" || value === null) return void 0;
   const v = value;
@@ -32252,6 +32291,13 @@ function settlementResults(settlements) {
     }))
   };
 }
+function ledgerTailOf(resume) {
+  if (!resume) return void 0;
+  const closing = resume.compactions?.filter((c) => c.before === resume.messages.length).at(-1);
+  if (closing) return { compaction: closing.entry };
+  const last = resume.messages.at(-1);
+  return last?.role === "assistant" ? { turn: last } : void 0;
+}
 function settlementAnswer(s) {
   return { content: [{ type: "text", text: settlementText(s) }], isError: true };
 }
@@ -32296,10 +32342,12 @@ async function runPiHarness(deps, run2) {
     };
   }
   bridge.turns = run2.resume?.turn ?? 0;
+  const tail = ledgerTailOf(run2.resume);
   const mirror = new PiMirror({
     onStep: run2.onStep,
-    seedLength: run2.resume?.messages.length ?? run2.messages.length,
-    remainingMs: () => deadline - now()
+    seedLength: run2.resume ? run2.resume.messages.length + (run2.resume.compactions?.length ?? 0) : run2.messages.length,
+    remainingMs: () => deadline - now(),
+    ...tail ? { mirroredTail: tail } : {}
   });
   mirror.inboxConsumedSeq = run2.resume?.inboxConsumedSeq ?? 0;
   let writeUp;
@@ -32336,12 +32384,17 @@ async function runPiHarness(deps, run2) {
   let pid;
   let transport;
   let facts2;
+  let mirrored = 0;
   const save = () => {
     if (facts2) {
-      if (transport) facts2 = { ...facts2, logOffset: transport.offset };
+      facts2 = { ...facts2, logOffset: mirrored };
       run2.saveFacts?.(facts2);
     }
   };
+  const held = () => {
+    if (transport) mirrored = transport.consumedOffset;
+    save();
+  };
   let catchingUp = false;
   try {
     const recorded = run2.resume?.facts;
@@ -32368,13 +32421,14 @@ async function runPiHarness(deps, run2) {
     if (reattached && recorded && paths !== void 0) {
       pid = recorded.pid;
       facts2 = { ...recorded, ...recorded.container === void 0 && here !== void 0 ? { container: here } : {} };
+      mirrored = recorded.logOffset;
       transport = new PiRpcTransport({
         container,
         paths,
         pid,
         pollMs: deps.pollMs ?? 750,
         sleep: deps.sleep,
-        offset: recorded.logOffset
+        offset: mirrored
       });
       catchingUp = true;
       const inFlight = run2.resume?.settlements.length ?? 0;
@@ -32452,12 +32506,15 @@ async function runPiHarness(deps, run2) {
       save();
       transport = new PiRpcTransport({ container, paths, pid, pollMs: deps.pollMs ?? 750, sleep: deps.sleep });
     }
-    transport.send({ id: "retry", type: "set_auto_retry", enabled: false });
-    transport.send({ id: "state", type: "get_state" });
+    const stamp = `${now()}-${randomUUID2().slice(0, 8)}`;
+    const ids = { retry: `retry:${stamp}`, state: `state:${stamp}`, prompt: `prompt:${stamp}` };
+    const continuing = reattached || run2.resume !== void 0;
+    transport.send({ id: ids.retry, type: "set_auto_retry", enabled: false });
+    transport.send({ id: ids.state, type: "get_state" });
     if (reattached)
-      transport.send({ id: "prompt", type: "prompt", message: CONTINUE_PROMPT, streamingBehavior: "steer" });
-    else if (run2.resume) transport.send({ id: "prompt", type: "prompt", message: CONTINUE_PROMPT });
-    else transport.send({ id: "prompt", type: "prompt", ...promptOf(run2.messages) });
+      transport.send({ id: ids.prompt, type: "prompt", message: CONTINUE_PROMPT, streamingBehavior: "steer" });
+    else if (run2.resume) transport.send({ id: ids.prompt, type: "prompt", message: CONTINUE_PROMPT });
+    else transport.send({ id: ids.prompt, type: "prompt", ...promptOf(run2.messages) });
     let warned = false;
     let settled = false;
     let stopMode;
@@ -32575,19 +32632,20 @@ ${stagedLine}` : prompt,
       }
       if (obs.response) {
         const r = obs.response;
-        if (r.id === "state" && r.success === true && typeof r.data?.sessionFile === "string") {
+        if (r.id === ids.state && r.success === true && typeof r.data?.sessionFile === "string") {
           const data = r.data;
           facts2 = { ...facts2 ?? { pid, logOffset: 0, root: paths.dir }, sessionFile: String(data.sessionFile) };
           save();
         }
-        if (r.id === "prompt") {
+        if (r.id === ids.prompt) {
           catchingUp = false;
           if (r.success === false) throw new PromptRefused(String(r.error ?? "no reason"));
+          if (!continuing) mirror.expectSeedEcho();
         }
       }
-      if (obs.message) await mirror.onMessage(obs.message, bridge.turns);
+      if (obs.message && await mirror.onMessage(obs.message, bridge.turns)) held();
       if (obs.compaction) {
-        await mirror.onCompaction(obs.compaction, bridge.turns);
+        if (await mirror.onCompaction(obs.compaction, bridge.turns)) held();
         if (!writeUp && !hardStopped && !catchingUp) {
           let notepad;
           let unavailable = false;
@@ -32608,7 +32666,6 @@ ${stagedLine}` : prompt,
           note("harness_error", `a model call failed while the bot was away (${obs.providerError}); continuing`);
         else providerError = obs.providerError;
       }
-      if (obs.turnEnded) save();
       if (obs.settled && !catchingUp) {
         settled = true;
         break;
@@ -32622,8 +32679,8 @@ ${stagedLine}` : prompt,
     }
     if (bypass) throw bypass;
     if (!settled) {
-      const tail = await container.tail(paths.errLog, 2e3);
-      throw new Error(`pi exited before the run settled${tail.trim() ? `: ${redactAndCap(tail.trim(), 400)}` : ""}`);
+      const tail2 = await container.tail(paths.errLog, 2e3);
+      throw new Error(`pi exited before the run settled${tail2.trim() ? `: ${redactAndCap(tail2.trim(), 400)}` : ""}`);
     }
     if (providerError !== void 0) throw new Error(`the model call failed: ${providerError}`);
     const text = bridge.answer() ?? "";
@@ -36787,8 +36844,8 @@ var init_types5 = __esm({
 });
 
 // ../../src/core/runLedger/writeThrough.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-function mintGeneration(now = Date.now, random = randomUUID2) {
+import { randomUUID as randomUUID3 } from "node:crypto";
+function mintGeneration(now = Date.now, random = randomUUID3) {
   const stamp = new Date(now()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
   const gen = `${stamp}-${random().replace(/-/g, "").slice(0, 8)}`;
   if (!GEN_PATTERN.test(gen)) throw new Error(`minted generation ${gen} does not match GEN_PATTERN`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreplane/switchboard",
-  "version": "1.223.0",
+  "version": "1.224.0",
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",
   "homepage": "https://openswitchboard.dev",