@basein/runner 0.3.24 → 0.3.26

package/dist/control/server.js

@@ -31,16 +31,16 @@ 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 { agentDayOf, contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, settledTextAfterToolUse, thinkingForToolUse, usageSince, } from "./transcript.js";
+import { agentDayOf, answerBeforePrompt, contextForToolUse, intentForToolUse, markTranscriptUsage, promptCount, recentToolResults, sessionTranscriptPath, settledLastAssistantText, settledTextAfterToolUse, settledTurnEnd, thinkingForToolUse, usageBetween, 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";
 import { DEFAULT_MAX_STRING_BYTES, serializeCapped, truncateString, truncateStrings, } from "../record/truncate.js";
 import { StepQueue } from "../record/queue.js";
 import { NullRecorder, isAttentionReader, isIntentMatcher, isMatchAware, isRecorderHealthReporter, isRunCreationAware, isScenarioDisputer, isScenarioReporter, isServiceProber, isToolListReporter, } from "../record/recorder.js";
-import { ReplayController, POLL_HOLD_MS, REPORT_TOOL_NAME, } from "../replay/controller.js";
+import { ReplayController, POLL_HOLD_MS, REPORT_TOOL_NAME, sentACall, } from "../replay/controller.js";
 import { localDay } from "../replay/derive.js";
-import { calculateCostUsd, hasModelPricing } from "../replay/pricing.js";
+import { calculateCostUsd, hasModelPricing, requestRates } from "../replay/pricing.js";
 import { logDetail, logLine, logOnce, errText } from "../util/log.js";
 import { journal } from "../util/journal.js";
 import { packageVersion } from "../util/version.js";
@@ -106,6 +106,19 @@ const INTENT_ARM_PROBE_MS = 500;
 const INTENT_ARM_DERIVE_MS = 1_500;
 /** How long a fragment's `PreToolUse` waits to learn whether its run was created. */
 const FRAGMENT_CREATE_MS = 300;
+/**
+ * How long after its caller cancelled it a plan is not armed again (when some
+ * of its steps had run): long enough for the person to look at what the cancel
+ * left and ask again, short enough that a plan asked for tomorrow runs.
+ */
+const AFTER_CANCEL_MS = 10 * 60_000;
+/**
+ * How long a turn's books wait, after `Stop`, for Claude Code to write the
+ * turn's last message — whose tokens are the turn's too (`sealRun`). The wait
+ * the answer's text always had. `BIR_COST_SETTLE_MS` changes it; 0 is no wait.
+ */
+const COST_SETTLE_MS = 2_000;
+const COST_SETTLE_MAX_MS = 10_000;
 /**
  * How long the model's first call after a hand-over waits for the service to
  * say whether the work recorded after an earlier hand-over at that step has a
@@ -619,6 +632,14 @@ function hostSinksOf(payload) {
  * Claude's own names, the ones a transcript line carries, and they are mapped
  * here as the transcript's are folded: a missing count is 0. Undefined when
  * the payload carries no usable list — which is "no usage", never zero.
+ *
+ * A host sends one total per model, never one per request, and a model with a
+ * long-prompt price (Haiku 5.5: over 100,000 tokens, five times the rates) is
+ * priced by each request's own length. Under the threshold no request in the
+ * total was over it, and the short rates are right. Over it, which ones were
+ * cannot be told: the total is `rateUnknown`, and the run unmeasured — priced
+ * at the short rates, 150,000 tokens of one request came to a fifth of their
+ * cost, booked as measured.
  */
 function hostUsageOf(payload) {
     if (!Array.isArray(payload.usage))
@@ -629,12 +650,25 @@ function hostUsageOf(payload) {
         if (!item || typeof item !== "object")
             continue;
         const u = item;
+        const written = count(u.cache_creation_input_tokens);
+        // Claude's own split of the cache writes, when the host passes it on: a
+        // 1-hour write bills at 2x input, a 5-minute one at 1.25x.
+        const split = u.cache_creation;
+        const written1h = Math.min(written, count(split?.ephemeral_1h_input_tokens));
+        const model = typeof u.model === "string" && u.model ? u.model.slice(0, 200) : "unknown";
+        const inputTokens = count(u.input_tokens);
+        const cacheReadTokens = count(u.cache_read_input_tokens);
+        // The whole total as if it were one request's prompt: over the model's
+        // long-prompt threshold, one of its requests may have been.
+        const longMaybe = requestRates(model, { promptTokens: inputTokens + cacheReadTokens + written }).longPrompt === true;
         out.push({
-            model: typeof u.model === "string" && u.model ? u.model.slice(0, 200) : "unknown",
-            inputTokens: count(u.input_tokens),
+            model,
+            inputTokens,
             outputTokens: count(u.output_tokens),
-            cacheReadTokens: count(u.cache_read_input_tokens),
-            cacheCreationTokens: count(u.cache_creation_input_tokens),
+            cacheReadTokens,
+            cacheCreationTokens: written,
+            ...(written1h > 0 ? { cacheCreation1hTokens: written1h } : {}),
+            ...(longMaybe ? { rateUnknown: true } : {}),
         });
     }
     return out;
@@ -642,12 +676,19 @@ function hostUsageOf(payload) {
 /**
  * Price a turn's token usage. Measured only when tokens were used and every
  * model that used them has a price: a model outside the table costs "$0",
- * and a zero called measured is booked as a saving nobody made.
+ * and a zero called measured is booked as a saving nobody made. Nor is a
+ * total whose rates cannot be told ({@link HostUsage.rateUnknown}).
  */
 function priceUsage(usage) {
     const usd = usage.reduce((sum, u) => sum + calculateCostUsd(u.model, u), 0);
     const unpriced = [...new Set(usage.filter((u) => !hasModelPricing(u.model)).map((u) => u.model))];
-    return { usd, measured: usage.length > 0 && unpriced.length === 0, unpriced };
+    const rateUnknown = [...new Set(usage.filter((u) => u.rateUnknown).map((u) => u.model))];
+    return {
+        usd,
+        measured: usage.length > 0 && unpriced.length === 0 && rateUnknown.length === 0,
+        unpriced,
+        ...(rateUnknown.length > 0 ? { rateUnknown } : {}),
+    };
 }
 /**
  * What `/health` answers as `hostFields`: how much of another host's protocol
@@ -698,6 +739,15 @@ export class ControlServer {
     attention = new Map();
     /** Plans a `/scenario/run` is executing right now: one run per plan. */
     runningPlans = new Set();
+    /**
+     * Plans whose direct run its caller cancelled, by scenario id, and when
+     * ({@link declineAfterCancel}): the same plan is not armed again for
+     * {@link AFTER_CANCEL_MS} when the run sent a call, so its steps do not run
+     * twice. Here, not on the session: after `/clear` — a new session — or in a
+     * second window the same request armed the plan again, and ran every step
+     * a second time.
+     */
+    cancelledScenarios = new Map();
     /**
      * Steer plans whose last pin the guard declined (control/pin-guard.ts): the
      * model made the step's call its own way, so the plan is a step behind the
@@ -1565,7 +1615,9 @@ export class ControlServer {
                 const stashed = this.claimStashedNote(payload.session_id);
                 // The guard answering first means no directive went out: a plan that
                 // arms after that must never steer a model that was not told of it.
+                let answeredLate = false;
                 onLate(() => {
+                    answeredLate = true;
                     const run = this.sessions.get(payload.session_id ?? "unknown-session")?.run;
                     if (run) {
                         run.matchExpired = true;
@@ -1574,7 +1626,11 @@ export class ControlServer {
                     return stashed ? this.withContext({}, "UserPromptSubmit", stashed) : {};
                 });
                 const out = await this.onPrompt(payload);
-                return stashed ? this.withContext(out, "UserPromptSubmit", stashed) : out;
+                // Or the note this prompt's own match brought here: the plan was held
+                // back after a cancel in another session (`declineAfterCancel`). Not
+                // once the deadline has answered — it then waits for the next hook.
+                const note = stashed ?? (answeredLate ? undefined : this.claimStashedNote(payload.session_id));
+                return note ? this.withContext(out, "UserPromptSubmit", note) : out;
             }
             case "/tool/pre":
                 return await this.onToolPre(payload, onLate);
@@ -1635,7 +1691,22 @@ export class ControlServer {
     send(res, status, body) {
         if (res.headersSent || res.writableEnded)
             return;
-        const text = JSON.stringify(body ?? {});
+        // An answer that cannot be written as JSON (a BigInt or a cycle in a tool's
+        // arguments that came back as `updatedInput`) threw here, past the route's
+        // own handler, and the host's hook request was left with no answer at all
+        // until its own timeout, 15 s later. A hook that answers nothing lets the
+        // call go ahead as the model wrote it: said, and answered so at once.
+        let text;
+        try {
+            text = JSON.stringify(body ?? {});
+        }
+        catch (err) {
+            logLine("hook.unserialisable_answer", {
+                error: errText(err),
+                why: "the answer could not be written as JSON — answered with none, so the call goes ahead as written",
+            });
+            text = "{}";
+        }
         res.writeHead(status, {
             "content-type": "application/json",
             "content-length": Buffer.byteLength(text),
@@ -1699,8 +1770,10 @@ export class ControlServer {
             this.sessions.set(sessionId, session);
         }
         session.lastSeenAt = Date.now();
+        // Always the session's own transcript: a hook of a sub-agent that named
+        // the sub-agent's file would have the turn's marks read from two files.
         if (payload.transcript_path)
-            session.transcriptPath = payload.transcript_path;
+            session.transcriptPath = sessionTranscriptPath(payload.transcript_path);
         if (payload.cwd)
             session.cwd = payload.cwd;
         // The first host a session names is the one it keeps. Any route may carry
@@ -1880,6 +1953,10 @@ export class ControlServer {
             // every run of another host would then only record.
             hostReplay: asked.replay === true ? true : undefined,
         };
+        // The turn before this one ends where this one starts (`RunState.endMark`).
+        const before = session.run ?? session.previous;
+        if (before && before.finished && before.endMark === undefined)
+            before.endMark = run.usageMark;
         session.run = run;
         logLine("run.start", {
             run: runId,
@@ -2113,6 +2190,7 @@ export class ControlServer {
         if (!otherHost(session))
             state.reportTool = () => this.reportToolServed();
         this.declineWithoutDeliveryTool(state);
+        this.declineAfterCancel(session, state);
         // A steer plan with a shell or file-write step can only be followed if the
         // directive shows its computed arguments (the pin guard holds those steps
         // to their exact shape), so give its parameters a moment to settle —
@@ -2259,6 +2337,74 @@ export class ControlServer {
         run.replays.push(state);
         return undefined;
     }
+    /**
+     * A plan whose caller cancelled it (Esc on `run_scenario`, or a timeout) a
+     * few minutes ago, after at least one of its steps had run, is not armed
+     * again when the same plan matches: the steps' side effects are in place
+     * already, and the model is told so by the note kept for it
+     * ({@link stashCancelledNote}). Armed, the plan would have run them a second
+     * time — a row added twice, a mail sent twice — and the model would have had
+     * the note and the instruction to run the plan in the same message.
+     *
+     * The mark is spent by the first match it is asked about, whichever way that
+     * goes: it holds back one arming, never a stream of them, and never on a
+     * plan that sent no call (there is nothing to repeat: a step left out, one
+     * whose logic broke, one that could not be sent), nor one that is long
+     * cancelled ({@link AFTER_CANCEL_MS}). A person who wants the plan again asks
+     * again. Except while the cancelled run is still going — Esc does not stop a
+     * step in flight, and the run ends after it: every match until then is held,
+     * and the first one after spends the mark.
+     *
+     * The mark is the recorder's, not the session's: after `/clear` or in a
+     * second window the same request arrives in another session. The note the
+     * cancelled run left goes with the decline, to the session it is declined
+     * in, when that note is still unread.
+     *
+     * Returns true when it declined.
+     */
+    declineAfterCancel(session, state) {
+        const id = state.scenarioId;
+        if (!state.plan || typeof id !== "string")
+            return false;
+        const mark = this.cancelledScenarios.get(id);
+        if (!mark)
+            return false;
+        const running = this.runningPlans.has(mark.state);
+        if (!running)
+            this.cancelledScenarios.delete(id);
+        if (Date.now() - mark.at > AFTER_CANCEL_MS && !running)
+            return false;
+        if (!running && !sentACall(mark.state))
+            return false;
+        logLine("replay.decision", {
+            verdict: "no-steer",
+            code: "after_cancel",
+            scenario: id,
+            sess: session.sessionId,
+            why: running
+                ? "the same plan was cancelled a moment ago and its run is still finishing the step it was on — not armed again, so that step does not run twice; the agent does the task"
+                : "the same plan was cancelled a moment ago after some of its steps had run — not armed again, so those steps do not run twice; the agent does the task, told what ran",
+        });
+        // Its note, for the model that is about to do the task by hand.
+        if (!session.stashedNote && this.replay.hasUndeliveredNote(mark.state))
+            session.stashedNote = mark.state;
+        state.plan = undefined;
+        state.mode = "none";
+        state.stepsPlanned = 0;
+        state.pinned.clear();
+        state.declined = "after_cancel";
+        return true;
+    }
+    /** Mark `state`'s scenario held after its caller cancelled it ({@link declineAfterCancel}). */
+    holdAfterCancel(scenarioId, state) {
+        const now = Date.now();
+        // Marks long past their time, and not running, are dropped as new ones come.
+        for (const [id, mark] of this.cancelledScenarios) {
+            if (now - mark.at > AFTER_CANCEL_MS && !this.runningPlans.has(mark.state))
+                this.cancelledScenarios.delete(id);
+        }
+        this.cancelledScenarios.set(scenarioId, { state, at: now });
+    }
     /**
      * A `direct` plan is announced as "call mcp__bir__run_scenario". In a project
      * with no `bir` server that is a tool the model does not have: it would say
@@ -2797,7 +2943,7 @@ export class ControlServer {
      * `reason` says why the run is closed. It decides something only in a
      * session of another host (see {@link CloseReason}).
      */
-    sealRun(session, reason = "stop") {
+    sealRun(session, reason = "stop", settle = false) {
         const run = session.run;
         if (!run || run.finished)
             return;
@@ -2811,7 +2957,16 @@ export class ControlServer {
         // handed over first, before the report is built, so the report says what
         // happened: `fell_back` when a step ran, `failed` when none did, and not
         // `not_steered`, as if no plan had started.
-        let cutShort = early;
+        //
+        // A turn of a Claude Code session closed by anything but its own `Stop`
+        // ended before its work did too: an API error (`StopFailure`), the
+        // person's next prompt on a turn still open (Esc), a session that went
+        // quiet, ended or was switched off, a recorder that stopped. What it cost
+        // is no measure of the task. Its plan's report is unmeasured, and the turn
+        // is no sample of the usual cost: one $0.01 beside a $2.00 recording made
+        // the usual cost about $1.00, and every later saving about $1.00 too small
+        // (the service's imp.md B2). The recording itself is left as it was.
+        let cutShort = early || (!other && reason !== "stop");
         if (other) {
             const live = this.livePlan(run);
             if (live && this.replay.hostHandOver(live, "closed"))
@@ -2832,15 +2987,91 @@ export class ControlServer {
             this.shelveUnannounced(unannounced);
         // A `run_scenario` still waiting for this run's plan will never get it.
         this.directCalls = this.directCalls.filter((c) => c.run !== run);
-        const durationMs = Date.now() - run.startedAtMs;
+        // The turn ends now, whenever its books are closed below.
+        const sealedAtMs = Date.now();
+        const durationMs = sealedAtMs - run.startedAtMs;
+        // A fragment is recorded from the hand-over on (fallbk.md D7), so its cost
+        // and duration are the model's own work, not the steps the scenario did.
+        // So is a repeat opened after the plan ran to its end (newestRun.md N7). Another host
+        // hands over one number for the whole run, and it is the fragment's: the
+        // plan's own steps made no model call, so all of it was spent after the
+        // hand-over.
+        const fragment = run.fragment?.state === "open" ? run.fragment : undefined;
+        const repeatAfterPlan = !fragment && run.repeat?.state === "open" && run.repeat.startedAtMs !== undefined ? run.repeat : undefined;
+        const ownWork = fragment ?? repeatAfterPlan;
+        const recordedMs = ownWork?.startedAtMs ? sealedAtMs - ownWork.startedAtMs : durationMs;
+        // How many prompts the transcript holds now: the turn's answer is what
+        // stood before the next one (`turnAnswer`).
+        const promptsAtSeal = other ? undefined : promptCount(session.transcriptPath);
+        const closeBooks = () => this.closeBooks(session, run, {
+            reason,
+            early,
+            cutShort,
+            durationMs,
+            recordedMs,
+            sealedAtMs,
+            ownWork,
+            promptsAtSeal,
+        });
+        // THE COST IS READ ONCE THE TURN'S LAST MESSAGE IS WRITTEN. `Stop` comes
+        // before Claude Code writes it, and it carries tokens of its own: read at
+        // `Stop`, every turn was one model call short, and on a replay that call
+        // is most of the turn (control/transcript.ts, `settledTurnEnd`). Only an
+        // ordinary stop waits — an interrupted turn, a session that ended and a
+        // recorder closing have no last message coming — and never on the hook's
+        // path: the seal is done, and its drain waits for the books.
+        const settleMs = settle && !other && run.usageMark !== undefined ? this.costSettleMs() : 0;
+        if (settleMs > 0 && session.transcriptPath) {
+            this.holdSeal(run, settledTurnEnd(session.transcriptPath, { timeoutMs: settleMs })
+                .catch(() => false)
+                .then(() => {
+                try {
+                    closeBooks();
+                }
+                catch (err) {
+                    logLine("run.books_failed", { run: run.runId, error: errText(err) });
+                }
+            }));
+        }
+        else {
+            closeBooks();
+        }
+    }
+    /** How long a turn's books wait for its last message: `BIR_COST_SETTLE_MS`, 0 for no wait. */
+    costSettleMs() {
+        if (this.opts.costSettleMs !== undefined)
+            return Math.max(0, this.opts.costSettleMs);
+        const raw = process.env.BIR_COST_SETTLE_MS;
+        const n = raw === undefined || raw.trim() === "" ? Number.NaN : Number(raw);
+        return Number.isFinite(n) && n >= 0 ? Math.min(n, COST_SETTLE_MAX_MS) : COST_SETTLE_MS;
+    }
+    /**
+     * `work` joins what a drain of `run` waits for ({@link drainRun}). Never
+     * rejects: a seal's waits are best effort, and say so in the log themselves.
+     */
+    holdSeal(run, work) {
+        const done = work.then(() => undefined, () => undefined);
+        run.sealing = run.sealing ? Promise.all([run.sealing, done]).then(() => undefined) : done;
+    }
+    /**
+     * The second half of {@link sealRun}: what the turn cost, its execution
+     * reports, and the finish of its recording. Run at the seal, or a moment
+     * after it, once the turn's last message is in the transcript.
+     */
+    closeBooks(session, run, sealed) {
+        const { reason, early, cutShort, durationMs, recordedMs, sealedAtMs, ownWork, promptsAtSeal } = sealed;
+        const other = otherHost(session);
+        // A prompt that came while the books waited opened the session's next run:
+        // this turn's tokens end at that run's mark, and what follows is its own.
+        const until = run.endMark;
         // What this turn cost the model. Computed once, used twice: it is this run's
         // `originalCostUsd` when recorded, and the `sessionCostUsd` of a matched
         // turn's execution report.
-        const cost = this.runCost(session, run);
+        const cost = this.runCost(session, run, until);
         // 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, reason);
+        this.reportExecution(session, run, durationMs, cost, cutShort, reason, { sealedAtMs, until });
         // 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.
@@ -2848,27 +3079,22 @@ export class ControlServer {
             s.turnCalls = undefined;
             s.turnCallChars = 0;
         }
-        // A fragment is recorded from the hand-over on (fallbk.md D7), so its cost
-        // and duration are the model's own work, not the steps the scenario did.
-        // So is a repeat opened after the plan ran to its end (newestRun.md N7). Another host
-        // hands over one number for the whole run, and it is the fragment's: the
-        // plan's own steps made no model call, so all of it was spent after the
-        // hand-over.
-        const fragment = run.fragment?.state === "open" ? run.fragment : undefined;
-        const repeatAfterPlan = !fragment && run.repeat?.state === "open" && run.repeat.startedAtMs !== undefined ? run.repeat : undefined;
-        const ownWork = fragment ?? repeatAfterPlan;
-        const recordedCost = ownWork && !other ? this.costSince(session, ownWork.usageMark) : cost;
-        const recordedMs = ownWork?.startedAtMs ? Date.now() - ownWork.startedAtMs : durationMs;
+        const recordedCost = ownWork && !other ? this.costSince(session, ownWork.usageMark, until) : cost;
         if (run.recording) {
             const transcriptPath = session.transcriptPath;
             // The answer is the host's when it handed one over, and the
             // transcript's otherwise — never both. A run that ended early has none:
             // whatever text there is, it is not the answer to the prompt.
+            // A prompt written since the seal opened the next turn: the answer is
+            // what stood before it, never what that turn has written meanwhile.
+            const beforeNext = promptsAtSeal === undefined ? undefined : answerBeforePrompt(transcriptPath, promptsAtSeal + 1);
             const answerText = early
                 ? Promise.resolve("")
                 : run.hostAnswer !== undefined
                     ? Promise.resolve(run.hostAnswer)
-                    : settledLastAssistantText(transcriptPath).catch(() => "");
+                    : beforeNext !== undefined
+                        ? Promise.resolve(beforeNext)
+                        : settledLastAssistantText(transcriptPath).catch(() => "");
             // What the finish of another host's run says beside its answer and its
             // cost: why it ended early, when it did, and whether it is whole. A
             // run with either is never calculated and stops catching its prompt.
@@ -2883,7 +3109,6 @@ export class ControlServer {
             // 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 — 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;
@@ -2913,7 +3138,7 @@ export class ControlServer {
                     });
                 });
             });
-            run.sealing = before ? Promise.all([before, finishing]).then(() => undefined) : finishing;
+            this.holdSeal(run, finishing);
         }
         logLine("run.finish", {
             run: run.runId,
@@ -2949,7 +3174,7 @@ export class ControlServer {
      * No watermark means the delta is unknowable, so this reports `measured:
      * false` and zero rather than a number that is confidently wrong.
      */
-    runCost(session, run) {
+    runCost(session, run, until) {
         // Another host has no transcript: its numbers are the ones it handed
         // over with its stop, and they are looked at before any watermark — a
         // run of such a host never has one.
@@ -2963,7 +3188,7 @@ export class ControlServer {
             });
             return { usd: 0, measured: false };
         }
-        const cost = this.costSince(session, run.usageMark);
+        const cost = this.costSince(session, run.usageMark, until);
         if (cost.unpriced?.length) {
             logLine("run.unmeasured", {
                 run: run.runId,
@@ -2993,22 +3218,37 @@ export class ControlServer {
             run: run.runId,
             why: cost.unpriced?.length
                 ? "the runner has no price for a model of this run"
-                : "the host's usage holds no tokens — the run made no model call",
-            models: cost.unpriced?.length ? cost.unpriced.join(",") : undefined,
+                : cost.rateUnknown?.length
+                    ? "the host sent one total for a model that prices a long prompt at other rates, and the total is over that length — which of its requests were long cannot be told"
+                    : "the host's usage holds no tokens — the run made no model call",
+            models: cost.unpriced?.length
+                ? cost.unpriced.join(",")
+                : cost.rateUnknown?.length
+                    ? cost.rateUnknown.join(",")
+                    : undefined,
         });
         return { ...cost, measured: false };
     }
-    /** Transcript cost since `mark`; unmeasured (and zero) without one, or with a model that has no price. */
-    costSince(session, mark) {
+    /**
+     * Transcript cost since `mark`; unmeasured (and zero) without one, or with a
+     * model that has no price. Up to `until` — the mark of the session's next
+     * run — when the turn's books are closed after that run has opened, and up
+     * to now otherwise.
+     */
+    costSince(session, mark, until) {
         if (mark === undefined)
             return { usd: 0, measured: false };
-        return priceUsage(usageSince(session.transcriptPath, mark));
+        return priceUsage(until ? usageBetween(mark, until) : usageSince(session.transcriptPath, mark));
     }
     reportExecution(session, run, durationMs, cost, 
     /** The run was closed before its task ended for the caller (another host only). */
     cutShort = false, 
     /** Why the turn was sealed: only an ordinary `stop` ends with an answer (AC11). */
-    sealedBy = "stop") {
+    sealedBy = "stop", 
+    /** When the turn was sealed, and where its tokens end ({@link closeBooks}). */
+    at = {}) {
+        const sealedAtMs = at.sealedAtMs ?? Date.now();
+        const until = at.until;
         if (!isScenarioReporter(this.recorder))
             return;
         const states = run.replays.length > 0 ? run.replays : run.replay ? [run.replay] : [];
@@ -3071,27 +3311,34 @@ export class ControlServer {
             // did afterwards, and its saving would read as a loss.
             let end = nextMark;
             if (state.armedBy === "intent") {
-                windowCost = this.costSince(session, state.usageMark);
-                windowMs = (state.retiredAt ?? next?.armedAt ?? Date.now()) - state.armedAt;
+                windowCost = this.costSince(session, state.usageMark, until);
+                windowMs = (state.retiredAt ?? next?.armedAt ?? sealedAtMs) - state.armedAt;
                 end = state.retiredMark ?? nextMark;
             }
             else if (next) {
                 windowMs = next.armedAt - run.startedAtMs;
             }
             if (end !== undefined) {
-                const later = this.costSince(session, end);
+                const later = this.costSince(session, end, until);
                 windowCost = { usd: Math.max(0, windowCost.usd - later.usd), measured: windowCost.measured };
             }
             const report = this.replay.buildReport(state, {
                 sessionCostUsd: windowCost.usd,
                 // A direct run the user cancelled cut its turn short: its cost is no
-                // baseline, and no saving is measured against it.
-                measured: windowCost.measured && !this.cancelledPlans.has(state) && !unsplit,
+                // baseline, and no saving is measured against it. The parent's report
+                // bills the whole turn, its continuations' part included, so a
+                // continuation the user cancelled makes the parent's unmeasured too.
+                measured: windowCost.measured &&
+                    !this.cancelledPlans.has(state) &&
+                    !chain.some((continuation) => this.cancelledPlans.has(continuation)) &&
+                    !unsplit,
                 durationMs: Math.max(0, windowMs),
                 prompt: run.input || undefined,
                 siblings: states,
                 runId: run.runId,
-                cutShort: cutShort || undefined,
+                // Not for a plan whose own window had closed before the turn was cut
+                // short (an intent plan that ran to its end): what it cost is known.
+                cutShort: (cutShort && end === undefined) || undefined,
                 redoneBy: state === prompt && state.ranToEnd === true ? redoneBy : undefined,
                 chainDeriveUsd,
                 booksOwnSaving: booksOwn(state),
@@ -3131,7 +3378,7 @@ export class ControlServer {
                     const calls = answer ? this.answerCallsOf(state.scenarioId, kept) : [];
                     this.queue.push(() => recorder.reportExecution(answer ? { ...report, answer, ...(calls.length > 0 ? { answerCalls: calls } : {}) } : report));
                 });
-                run.sealing = run.sealing ? Promise.all([run.sealing, sent]).then(() => undefined) : sent;
+                this.holdSeal(run, sent);
                 return;
             }
             this.queue.push(() => recorder.reportExecution(report));
@@ -3230,7 +3477,7 @@ export class ControlServer {
         const run = session.run;
         if (!run)
             return;
-        this.sealRun(session, opts.reason);
+        this.sealRun(session, opts.reason, opts.settle === true);
         if (opts.detach && session.run === run) {
             session.run = undefined;
             session.previous = run;
@@ -3255,7 +3502,14 @@ export class ControlServer {
      */
     async drainRun(run, flushMs) {
         try {
-            await run.sealing;
+            // The seal adds to what it waits for while it settles — the books wait
+            // for the turn's last message, and then for the answer's text — so this
+            // waits until nothing more was added.
+            for (let sealing = run.sealing;; sealing = run.sealing) {
+                await sealing;
+                if (run.sealing === sealing)
+                    break;
+            }
             await this.queue.flush();
             // Bounded, so an outage cannot pin every sealed turn in memory until the
             // service returns; the recorder keeps sending on its own either way.
@@ -3414,6 +3668,10 @@ export class ControlServer {
             open.promptSeen = true;
             open.input = input;
             open.promptDay = localDay();
+            // A prompt all the same: the next one is a turn of its own. Not counted,
+            // the session still looked as if it had had none, so the next prompt took
+            // this branch again and was recorded into this run too.
+            session.prompts += 1;
             // This hook announces nothing, so no plan of this run may steer.
             open.matchExpired = true;
             this.retireUnannounced(session, open);
@@ -4538,6 +4796,7 @@ export class ControlServer {
         // session's own cwd from the hook payloads, never the daemon's.
         state.sessionCwd = session.cwd ?? this.opts.cwd;
         this.declineWithoutDeliveryTool(state);
+        this.declineAfterCancel(session, state);
         if (!state.plan) {
             // A declined intent hit reports nothing: the turn's cost is not a
             // measurement of that scenario's task, so it is no baseline sample either.
@@ -4660,6 +4919,7 @@ export class ControlServer {
             scenarioId: f.scenarioId,
             stepIndex: f.stepIndex,
             ...(f.kind ? { kind: f.kind } : {}),
+            ...(f.stop ? { stop: f.stop } : {}),
             ...(f.handoverId ? { id: f.handoverId } : {}),
         };
         // Whether this hand-over is still the turn's: its fragment due, nothing
@@ -4996,6 +5256,7 @@ export class ControlServer {
             // Which half the model's work after it is (the service's fallbk.md
             // Part 3), and the id that makes the hand-over one hit.
             kind: h.kind,
+            ...(h.stop ? { stop: h.stop } : {}),
             handoverId: `ho_${randomUUID()}`,
         };
     }
@@ -5023,6 +5284,7 @@ export class ControlServer {
         const sent = {
             ...fallbackOf,
             ...(f.kind ? { kind: f.kind } : {}),
+            ...(f.stop ? { stop: f.stop } : {}),
             ...(f.handoverId ? { handoverId: f.handoverId } : {}),
             ...(f.counted ? { counted: true } : {}),
         };
@@ -5484,7 +5746,21 @@ export class ControlServer {
             correlation.fallback.unref?.();
             return { pending: true };
         }
-        const builtIn = run.builtIns.get(toolUseId) ?? run.builtIns.get(`anon_${toolName}`);
+        // The step this answer completes. A host that sends no `tool_use_id` is
+        // paired by the tool's name, oldest call first: the pre stored its call
+        // under its step index (`anon_<index>`) and this looked it up under
+        // `anon_<tool name>`, which never matched, so every answer of such a host
+        // was recorded at an index of its own and the pairs shifted.
+        let builtInKey = toolUseId && run.builtIns.has(toolUseId) ? toolUseId : undefined;
+        if (builtInKey === undefined) {
+            for (const [key, candidate] of run.builtIns) {
+                if (key.startsWith("anon_") && candidate.toolName === toolName) {
+                    builtInKey = key;
+                    break;
+                }
+            }
+        }
+        const builtIn = builtInKey !== undefined ? run.builtIns.get(builtInKey) : undefined;
         const responseIndex = builtIn ? builtIn.responseIndex : run.ordering.allocate();
         if (run.recording) {
             const output = serializeCapped(redact(payload.tool_response ?? {}));
@@ -5500,7 +5776,8 @@ export class ControlServer {
                 });
             });
         }
-        run.builtIns.delete(toolUseId);
+        if (builtInKey !== undefined)
+            run.builtIns.delete(builtInKey);
         logDetail("tool.post", { run: run.runId, tool: toolName, step: responseIndex, failed });
         return { stepIndex: responseIndex };
     }
@@ -5562,8 +5839,18 @@ export class ControlServer {
         // Another host hands the run's answer and its tokens over here — it has
         // no transcript to read them from — and says when the run failed or its
         // recording is not whole.
-        const reason = otherHost(session) ? this.noteHostStop(run, payload) : "stop";
-        this.closeRun(session, { detach: false, reason });
+        // `StopFailure` arrives on this route too: the turn ended on an API error,
+        // with no answer to check and no last message to wait for. Sealed as the
+        // ordinary stop it was taken for, its cut answer went to the answer check
+        // and its cost was reported as a whole turn's.
+        const reason = otherHost(session)
+            ? this.noteHostStop(run, payload)
+            : payload.hook_event_name === "StopFailure"
+                ? "stop_failure"
+                : "stop";
+        // Claude Code writes the turn's last message after this hook: the turn's
+        // cost is read once it is there (`sealRun`).
+        this.closeRun(session, { detach: false, reason, settle: reason === "stop" });
         return {};
     }
     /**
@@ -5836,6 +6123,10 @@ export class ControlServer {
         // prompt may seal the turn before the step in flight has finished.
         const onCancel = () => {
             this.cancelledPlans.add(state);
+            // And the same plan is not run again at once, in any session, when its
+            // run sent a call ({@link declineAfterCancel}).
+            if (state.scenarioId)
+                this.holdAfterCancel(state.scenarioId, state);
         };
         if (signal?.aborted)
             onCancel();
@@ -5864,8 +6155,9 @@ export class ControlServer {
      * run those steps a second time.
      */
     stashCancelledNote(sessionId, state) {
-        const h = state.handover;
-        if (!h || h.delivered)
+        // A hand-over's note, or — when every step ran with nobody to read the
+        // results — the note about those.
+        if (!this.replay.hasUndeliveredNote(state))
             return;
         const session = this.sessions.get(sessionId);
         if (!session)
@@ -6316,12 +6608,8 @@ export class ControlServer {
         });
     }
 }
-/**
- * The port `bir install` writes into the hook URLs, and the one `bir-hooks`
- * prefers. Claude Code's `settings.json` needs a *static* URL, so the control
- * server cannot be purely ephemeral: it asks for this port and falls back to an
- * ephemeral one only if it is taken — in which case the installed hooks point at
- * a port nobody is listening on, and both `bir-hooks` and `bir doctor` say so.
- */
-export const DEFAULT_CONTROL_PORT = 53411;
+// The port `bir install` writes into the hook URLs now lives in control/paths.ts:
+// `bir` needed this one number, and loading this whole file for it added some
+// 50 ms to every command. Re-exported, so the server's own importers still find it.
+export { DEFAULT_CONTROL_PORT } from "./paths.js";
 //# sourceMappingURL=server.js.map