@basein/runner 0.3.16 → 0.3.17

package/dist/control/server.js

@@ -31,7 +31,7 @@ import { BIR_CALL_ID, fingerprint, newCallId, parseQualifiedName, qualifyToolNam
 import { StepIndexAllocator } from "./ordering.js";
 import { pidAlive } from "./discovery.js";
 import { pinCompatible } from "./pin-guard.js";
-import { contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, thinkingForToolUse, usageSince, } from "./transcript.js";
+import { contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, settledTextAfterToolUse, thinkingForToolUse, usageSince, } from "./transcript.js";
 import { isHousekeepingCall } from "../record/housekeeping.js";
 import { asSent, userText } from "../record/prompt-text.js";
 import { redact, redactText } from "../record/redact.js";
@@ -2294,7 +2294,7 @@ export class ControlServer {
         // A matched turn records nothing, but it still owes the ledger a number —
         // including when it declined to steer, which is a *baseline* sample and is
         // what every saving is measured against (docs/calculatedReplay.md §11).
-        this.reportExecution(session, run, durationMs, cost, cutShort);
+        this.reportExecution(session, run, durationMs, cost, cutShort, reason);
         // The plan's calls kept for a redo went into the repeat when it opened
         // (AC2); nothing reads them after the turn, and they can run to megabytes
         // on a sealed run the session keeps as its previous one.
@@ -2335,8 +2335,10 @@ export class ControlServer {
             // Resolve the answer *outside* the queue: the wait below is up to two
             // seconds, and the queue is serial — blocking it here would delay the
             // first step of the user's next turn by that much. Kept on the run, so a
-            // drain of this run waits for this seal and for nobody else's.
-            run.sealing = answerText
+            // drain of this run waits for this seal and for nobody else's — beside a
+            // plan's report that waits for the answer too (AC11), never in its place.
+            const before = run.sealing;
+            const finishing = answerText
                 .then((answer) => {
                 run.finishQueued = true;
                 this.queue.push(() => {
@@ -2359,6 +2361,7 @@ export class ControlServer {
                     });
                 });
             });
+            run.sealing = before ? Promise.all([before, finishing]).then(() => undefined) : finishing;
         }
         logLine("run.finish", {
             run: run.runId,
@@ -2451,7 +2454,9 @@ export class ControlServer {
     }
     reportExecution(session, run, durationMs, cost, 
     /** The run was closed before its task ended for the caller (another host only). */
-    cutShort = false) {
+    cutShort = false, 
+    /** Why the turn was sealed: only an ordinary `stop` ends with an answer (AC11). */
+    sealedBy = "stop") {
         if (!isScenarioReporter(this.recorder))
             return;
         const states = run.replays.length > 0 ? run.replays : run.replay ? [run.replay] : [];
@@ -2515,6 +2520,30 @@ export class ControlServer {
                     billedTo: state.retiredMark !== undefined ? "its own retire" : "the next arm or the turn",
                 });
             }
+            // The plan ran to its end, and no redo of the model's own was recorded:
+            // the model only answered. Its answer goes with the report, so that the
+            // service can tell whether it took the plan's result (the service's
+            // autocorrect.md AC11). Read off the queue, as a recording's answer is —
+            // the wait is up to two seconds, and the queue is serial — and kept on
+            // the run, so a drain of this run waits for it. Only after an ordinary
+            // stop, and only the text written after the turn's last call: a turn cut
+            // short has no answer, and an older text is none. Claude Code only: the
+            // service corrects no other host's plan.
+            if (state === prompt &&
+                state.ranToEnd === true &&
+                !redoneBy &&
+                report.outcome === "steered_full" &&
+                sealedBy === "stop" &&
+                run.lastToolUseId !== undefined &&
+                !otherHost(session)) {
+                const sent = settledTextAfterToolUse(session.transcriptPath, run.lastToolUseId)
+                    .catch(() => "")
+                    .then((answer) => {
+                    this.queue.push(() => recorder.reportExecution(answer ? { ...report, answer } : report));
+                });
+                run.sealing = run.sealing ? Promise.all([run.sealing, sent]).then(() => undefined) : sent;
+                return;
+            }
             this.queue.push(() => recorder.reportExecution(report));
         });
         // The prompt match that landed too late (see `noteLateMatch`). Not when a
@@ -4282,6 +4311,9 @@ export class ControlServer {
             context.push(stashed);
         const run = this.sessions.get(payload.session_id ?? "unknown-session")?.run;
         if (run && !run.finished) {
+            // The answer, if one comes, is written after this call (AC11).
+            if (typeof payload.tool_use_id === "string" && payload.tool_use_id)
+                run.lastToolUseId = payload.tool_use_id;
             this.noteHandover(run);
             const note = this.replay.takeNote(run.replay);
             if (note)

package/dist/control/transcript.d.ts

@@ -34,6 +34,24 @@
  * birth time, mtime, and the bytes at its head and at the offset) and read
  * again from the start, which is exactly what the old code did every time.
  */
+/**
+ * The model's text after the message that made the tool call `toolUseId`: its
+ * answer, once that call's result came back (the service's autocorrect.md
+ * AC11). Empty while none has been written, and when the call is not in the
+ * transcript — never an older text, which `lastAssistantText` can be: the
+ * sentence before a call, or the turn before's answer.
+ */
+export declare function textAfterToolUse(transcriptPath: string | undefined, toolUseId: string | undefined): string;
+/**
+ * {@link textAfterToolUse}, waited for: up to `timeoutMs` for a text to appear,
+ * then until it stops changing for `confirmMs`. Empty when none came in time —
+ * a plan's report then goes without an answer, rather than with a wrong one.
+ */
+export declare function settledTextAfterToolUse(transcriptPath: string | undefined, toolUseId: string | undefined, opts?: {
+    timeoutMs?: number;
+    confirmMs?: number;
+    pollMs?: number;
+}): Promise<string>;
 /** Forget every cached index (tests; a caller that knows files were replaced). */
 export declare function forgetTranscripts(): void;
 /**

package/dist/control/transcript.js

@@ -397,6 +397,61 @@ function foldLine(idx, line) {
         }
     }
 }
+/**
+ * The model's text after the message that made the tool call `toolUseId`: its
+ * answer, once that call's result came back (the service's autocorrect.md
+ * AC11). Empty while none has been written, and when the call is not in the
+ * transcript — never an older text, which `lastAssistantText` can be: the
+ * sentence before a call, or the turn before's answer.
+ */
+export function textAfterToolUse(transcriptPath, toolUseId) {
+    if (!transcriptPath || !toolUseId)
+        return "";
+    const idx = indexFor(transcriptPath);
+    const at = idx?.toolUses.get(toolUseId)?.message;
+    if (!idx || at === undefined)
+        return "";
+    let after = false;
+    let text = "";
+    for (const [key, entry] of idx.messages) {
+        if (key === at) {
+            after = true;
+            continue;
+        }
+        if (after && entry.texts.length > 0)
+            text = entry.texts.join("");
+    }
+    return text.trim();
+}
+/**
+ * {@link textAfterToolUse}, waited for: up to `timeoutMs` for a text to appear,
+ * then until it stops changing for `confirmMs`. Empty when none came in time —
+ * a plan's report then goes without an answer, rather than with a wrong one.
+ */
+export async function settledTextAfterToolUse(transcriptPath, toolUseId, opts = {}) {
+    if (!transcriptPath || !toolUseId)
+        return "";
+    const pollMs = opts.pollMs ?? 150;
+    const confirmMs = opts.confirmMs ?? 400;
+    const deadline = Date.now() + (opts.timeoutMs ?? 2_000);
+    const sleep = () => new Promise((resolve) => {
+        const t = setTimeout(resolve, pollMs);
+        t.unref?.();
+    });
+    let latest = textAfterToolUse(transcriptPath, toolUseId);
+    let since = Date.now();
+    while (Date.now() < deadline) {
+        if (latest && Date.now() - since >= confirmMs)
+            return latest;
+        await sleep();
+        const now = textAfterToolUse(transcriptPath, toolUseId);
+        if (now !== latest) {
+            latest = now;
+            since = Date.now();
+        }
+    }
+    return latest;
+}
 /** Forget every cached index (tests; a caller that knows files were replaced). */
 export function forgetTranscripts() {
     indexes.clear();

package/dist/record/recorder.d.ts

@@ -452,6 +452,14 @@ export interface ExecutionReport {
         runId: string;
         ownCalls: number;
     };
+    /**
+     * The model's final answer, when the prompt's plan ran to its end and no
+     * redo of the model's own was recorded (the service's autocorrect.md AC11):
+     * the service checks whether the model took the plan's result, and holds and
+     * corrects the plan when it did not. Read from the transcript after the turn
+     * ends; an older service drops the field.
+     */
+    answer?: string;
 }
 /** Optional capability: reporting needs a service, and a NullRecorder has none. */
 export interface ScenarioReporter {

package/dist/record/remote-recorder.d.ts

@@ -70,6 +70,8 @@ export declare const TEXT_CAPS: {
     readonly toolError: number;
     /** An execution report's error lines, rendered in a web page. */
     readonly reportError: number;
+    /** The model's answer on a plan's report (AC11): the service keeps 4,000 characters of it. */
+    readonly reportAnswer: number;
 };
 /**
  * The most an execution report's request may weigh. The service reads this

package/dist/record/remote-recorder.js

@@ -75,6 +75,8 @@ export const TEXT_CAPS = {
     toolError: 8 * 1024,
     /** An execution report's error lines, rendered in a web page. */
     reportError: 2 * 1024,
+    /** The model's answer on a plan's report (AC11): the service keeps 4,000 characters of it. */
+    reportAnswer: 8 * 1024,
 };
 /**
  * The most an execution report's request may weigh. The service reads this
@@ -742,11 +744,12 @@ export class RemoteRecorder {
         const costUsd = report.deriveCostUsd + report.sessionCostUsd + report.fallbackCostUsd;
         const prompt = pend(report.prompt, TEXT_CAPS.prompt);
         const error = pend(report.error, TEXT_CAPS.reportError);
+        const answer = pend(report.answer, TEXT_CAPS.reportAnswer);
         const steps = report.steps?.map(pendStep);
         this.enqueue({
             lane: EXECUTIONS,
             kind: "report",
-            bytes: sizeOf(prompt, error, ...(steps ?? []).flatMap((s) => [s.toolInput, s.toolOutput])) + 1024,
+            bytes: sizeOf(prompt, error, answer, ...(steps ?? []).flatMap((s) => [s.toolInput, s.toolOutput])) + 1024,
             send: async () => {
                 // A redo whose run the service refused to create is no run of its:
                 // never named (the service's autocorrect.md AC1), even when the
@@ -789,6 +792,9 @@ export class RemoteRecorder {
                     // The plan ran to its end and the agent redid the task (the
                     // service's autocorrect.md AC1). Additive, like `declined`.
                     redoneBy,
+                    // ...or only answered: its answer, capped and redacted like any
+                    // text (AC11). Additive, like `redoneBy`.
+                    answer: out(answer),
                 }, steps), { retryTransient: Boolean(report.ticket) });
                 const r = (body ?? {});
                 const failed = report.steps?.filter((s) => s.status === "failed").length ?? 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "A recording MCP proxy: sits between any MCP client and its MCP servers, executes each call on the client's behalf, and records the run as a reusable BaseIn scenario.",
   "type": "module",
   "license": "MIT",