@basein/runner 0.3.25 → 0.3.26

package/dist/control/daemon.js

@@ -1117,6 +1117,12 @@ export function clearPortProblem(cwd) {
     }
 }
 // ── the background recorder's own log ──────────────────────────────────────
+/** The longest a log's last lines may hold an exit back ({@link exitLogged}). */
+const LOG_CLOSE_MS = 1_000;
+/** The log this process pointed `console` at: the one an exit waits for. */
+let processLog;
+/** Set by the first {@link exitLogged}. */
+let exiting = false;
 function silentConsole() {
     const sink = new Writable({
         write(_chunk, _encoding, callback) {
@@ -1166,6 +1172,7 @@ export class DaemonLog {
     }
     /** Open the file and point `console` (every `logLine`) at it. Never throws. */
     open() {
+        processLog = this;
         try {
             ensureDir(dirname(this.current));
         }
@@ -1303,6 +1310,61 @@ export class DaemonLog {
     close() {
         this.stream?.end();
     }
+    /**
+     * End the log for good, before an exit. `done` is called once: when every
+     * line already logged is in the file, or when it cannot be — there is no
+     * stream, it failed, or the file did not take them within
+     * {@link LOG_CLOSE_MS}.
+     *
+     * Lines logged after this call are dropped. Written to the stream, one of
+     * them would be a write after its end, which destroys the stream and the
+     * lines it still held: a send failing in the background during a shutdown
+     * would cost the log the very lines this waits for.
+     */
+    end(done) {
+        const stream = this.stream;
+        this.stream = undefined;
+        this.fd = undefined;
+        globalThis.console = silentConsole();
+        if (!stream) {
+            done();
+            return;
+        }
+        let called = false;
+        const once = () => {
+            if (called)
+                return;
+            called = true;
+            clearTimeout(late);
+            done();
+        };
+        // Not unref'd: `done` is an exit, and it must happen even when the write
+        // it waits for never returns (a disk that hangs).
+        const late = setTimeout(once, LOG_CLOSE_MS);
+        stream.end(once);
+    }
+}
+/**
+ * `process.exit(code)`, once the lines already logged are in the log file.
+ *
+ * A background recorder's log is a stream that writes in the background, and
+ * a `process.exit()` right after a `logLine()` lost what the stream had not
+ * written yet: a line logged right behind another, and every line while the
+ * file was still being opened. Those are the lines that say why the recorder
+ * is not running — its port is taken, and by whom; this project's recorder
+ * already serves it; it was asked to stop. So the stream is ended first, and
+ * the exit waits for it ({@link DaemonLog.end}, at most {@link LOG_CLOSE_MS}).
+ * Without a log file of its own — `bir-hooks` in a terminal — the exit is at
+ * once, as before; so is a second call, which means "now".
+ *
+ * It returns: whoever calls it must do nothing more.
+ */
+export function exitLogged(code) {
+    const log = processLog;
+    if (!log || exiting)
+        process.exit(code);
+    exiting = true;
+    log.end(() => process.exit(code));
 }
 // ── the start lock ─────────────────────────────────────────────────────────
 function lockPath(cwd) {

package/dist/control/paths.d.ts

@@ -7,8 +7,26 @@
  * assumption is made about `$HOME` being set — Windows sets `USERPROFILE`
  * instead, and `os.homedir()` already knows the difference.
  */
-/** Root of BaseInstRunner's state. `BIR_HOME` overrides it (tests, sandboxes). */
+/**
+ * Root of BaseInstRunner's state. `BIR_HOME` overrides it (tests, sandboxes).
+ *
+ * An empty `BIR_HOME` counts as unset (`||`, not `??`). Taken as a path it is
+ * the current directory: the sign-in, installed.json and the logs then land in
+ * whichever folder a command happens to run in, one copy per folder.
+ */
 export declare function configDir(): string;
+/**
+ * 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.
+ *
+ * Here rather than in control/server.ts so that `bir` can name it without
+ * loading the control server: that module and what it imports cost every
+ * `bir` command about 50 ms, and the `bir` MCP server starts one per call.
+ */
+export declare const DEFAULT_CONTROL_PORT = 53411;
 /** Where control servers advertise themselves, one file per project cwd. */
 export declare function controlDir(): string;
 /** The sidecar holding original MCP entries so `bir uninstall` can restore them. */

package/dist/control/paths.js

@@ -11,10 +11,28 @@ import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-/** Root of BaseInstRunner's state. `BIR_HOME` overrides it (tests, sandboxes). */
+/**
+ * Root of BaseInstRunner's state. `BIR_HOME` overrides it (tests, sandboxes).
+ *
+ * An empty `BIR_HOME` counts as unset (`||`, not `??`). Taken as a path it is
+ * the current directory: the sign-in, installed.json and the logs then land in
+ * whichever folder a command happens to run in, one copy per folder.
+ */
 export function configDir() {
-    return process.env.BIR_HOME ?? join(homedir(), ".baseinstrunner");
+    return process.env.BIR_HOME || join(homedir(), ".baseinstrunner");
 }
+/**
+ * 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.
+ *
+ * Here rather than in control/server.ts so that `bir` can name it without
+ * loading the control server: that module and what it imports cost every
+ * `bir` command about 50 ms, and the `bir` MCP server starts one per call.
+ */
+export const DEFAULT_CONTROL_PORT = 53411;
 /** Where control servers advertise themselves, one file per project cwd. */
 export function controlDir() {
     return join(configDir(), "control");

package/dist/control/pin-guard.js

@@ -352,7 +352,11 @@ function commandVerdict(mine, theirs, powershell = false) {
     // No command at all: the model left it to the directive.
     if (!mine)
         return { ok: true };
-    if (mine.replace(/\s+/g, " ") === theirs.replace(/\s+/g, " "))
+    // The same command, however its words are spaced. Spaces and tabs only: a
+    // new line chains (see the file comment), and with `\s` the step `ls` + new
+    // line + `rm -rf x` was "the same" as a call of `ls rm -rf x` — one command
+    // shown, two run — before the chains below were ever compared.
+    if (mine.replace(/[ \t]+/g, " ") === theirs.replace(/[ \t]+/g, " "))
         return { ok: true };
     // What a substitution runs is not in any head: only an exact copy is the step.
     if ((powershell ? PS_SUBSTITUTION : SUBSTITUTION).test(theirs)) {
@@ -469,7 +473,9 @@ function statementVerdict(model, step) {
         const mine = model[key];
         if (typeof mine !== "string")
             return { ok: false, why: `it does not supply the step's ${key}` };
-        if (mine.replace(/\s+/g, " ").trim() === theirs.replace(/\s+/g, " ").trim())
+        // Spaces and tabs only, as in commandVerdict: a new line may chain here
+        // too. A query laid out on other lines still passes, by its verbs, below.
+        if (mine.replace(/[ \t]+/g, " ").trim() === theirs.replace(/[ \t]+/g, " ").trim())
             continue;
         // A shell command's substitution runs what no head shows (backticks are
         // only an identifier quote in SQL, so SQL is not held to this).

package/dist/control/recorder-main.js

@@ -23,7 +23,7 @@
 import { hostname } from "node:os";
 import { ControlServer, DEFAULT_CONTROL_PORT } from "./server.js";
 import { DISCOVERY_CHECK_MS, HEARTBEAT_MS, pidAlive, readDiscovery, removeDiscoveryIfOwned, removeSupersededRecord, sweepStaleDiscovery, writeDiscovery, writeSupersededRecord, } from "./discovery.js";
-import { DAEMON_CWD_ENV, DAEMON_ENV, DAEMON_LOG_ENV, DERIVE_KEY_ENV, DaemonLog, USE_API_KEY_ENV, clearPortProblem, compareVersions, probeHealth, projectEndpoint, rediscover, validPort, writePortProblem, } from "./daemon.js";
+import { DAEMON_CWD_ENV, DAEMON_ENV, DAEMON_LOG_ENV, DERIVE_KEY_ENV, DaemonLog, USE_API_KEY_ENV, clearPortProblem, compareVersions, exitLogged, probeHealth, projectEndpoint, rediscover, validPort, writePortProblem, } from "./daemon.js";
 import { configDir, normalizePath, supersededLogPath } from "./paths.js";
 import { RecorderKeeper } from "./recorder-keeper.js";
 import { FILE_BUILTINS, parseBashAllow, parseBuiltinTools, parsePathAllow } from "../replay/builtins.js";
@@ -34,6 +34,7 @@ import { resolveServers } from "../config/resolve.js";
 import { isRecorderHealthReporter } from "../record/recorder.js";
 import { errText, logLine, logOnce } from "../util/log.js";
 import { openJournal } from "../util/journal.js";
+import { MAX_TIMER_MS } from "../util/service-health.js";
 import { packageVersion } from "../util/version.js";
 /** How long `close()` may take on the way out: it flushes unfinished runs to the service. */
 const SHUTDOWN_CLOSE_MS = 3_000;
@@ -57,9 +58,14 @@ const SWEEP_EVERY_MS = 24 * 60 * 60 * 1000;
  * that had exited would turn every one of them into a hook error.
  */
 const SUPERSEDED_EXIT_MS = 24 * 60 * 60 * 1000;
+/**
+ * A positive whole number, held to what a timer takes ({@link MAX_TIMER_MS}):
+ * most of these become a delay, and `BIR_RECORDER_TICK_MS=3000000000` would
+ * otherwise run the minute check every millisecond.
+ */
 function positiveInt(value, fallback) {
     const n = Number(value);
-    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+    return Number.isFinite(n) && n > 0 ? Math.min(Math.floor(n), MAX_TIMER_MS) : fallback;
 }
 /** Like {@link positiveInt}, but 0 is a meaningful setting rather than unset. */
 function nonNegativeInt(value, fallback) {
@@ -454,7 +460,8 @@ export async function runRecorder() {
         removeDiscoveryIfOwned(cwd, process.pid);
         removeSupersededRecord(cwd, process.pid);
         logLine(event, {});
-        process.exit(exitCode);
+        // Not `process.exit()`: the line above is not in the log file yet.
+        exitLogged(exitCode);
     };
     const shutdown = async () => {
         if (closing)
@@ -478,7 +485,7 @@ export async function runRecorder() {
         // A second signal while stopping means "now": on POSIX it used to be
         // swallowed, and a recorder stuck in its shutdown could not be stopped.
         if (closing)
-            finish("control.stop_forced", 1);
+            return finish("control.stop_forced", 1);
         void shutdown();
     };
     const options = {
@@ -529,7 +536,12 @@ export async function runRecorder() {
                 await sleep(500);
                 continue;
             }
-            process.exit(verdict === "ours" ? 0 : 1);
+            // `portBusy` has just logged why — who holds the port, or that this
+            // project's recorder already serves it. The log writes in the background,
+            // so a `process.exit()` here could lose that line, and the start-up lines
+            // before it with it.
+            exitLogged(verdict === "ours" ? 0 : 1);
+            return;
         }
     }
     clearPortProblem(cwd);

package/dist/control/server.d.ts

@@ -282,6 +282,12 @@ export interface ControlServerOptions {
      * failing. Unset or `BIR_INTENT_ARM=0` is off.
      */
     intentArm?: boolean;
+    /**
+     * How long a turn's books wait after `Stop` for the turn's last message to
+     * reach the transcript, in ms (`sealRun`). Overrides `BIR_COST_SETTLE_MS`;
+     * 0 reads the cost at `Stop`, as every runner up to 0.3.25 did.
+     */
+    costSettleMs?: number;
     /**
      * Whether the model's first call after a plan handed over asks the service
      * for the plan of the work recorded after an earlier hand-over at that step,
@@ -351,6 +357,15 @@ export declare class ControlServer {
     private readonly attention;
     /** Plans a `/scenario/run` is executing right now: one run per plan. */
     private readonly runningPlans;
+    /**
+     * 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.
+     */
+    private readonly cancelledScenarios;
     /**
      * 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
@@ -698,6 +713,34 @@ export declare class ControlServer {
      * the service's own answer, not the one a hook may have been given at once.
      */
     private noteDisabledMatch;
+    /**
+     * 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.
+     */
+    private declineAfterCancel;
+    /** Mark `state`'s scenario held after its caller cancelled it ({@link declineAfterCancel}). */
+    private holdAfterCancel;
     /**
      * 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
@@ -896,6 +939,19 @@ export declare class ControlServer {
      * session of another host (see {@link CloseReason}).
      */
     private sealRun;
+    /** How long a turn's books wait for its last message: `BIR_COST_SETTLE_MS`, 0 for no wait. */
+    private costSettleMs;
+    /**
+     * `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.
+     */
+    private holdSeal;
+    /**
+     * 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.
+     */
+    private closeBooks;
     /**
      * Report what a matched turn cost (docs/calculatedReplay.md §11).
      *
@@ -925,7 +981,12 @@ export declare class ControlServer {
      * one `run.unmeasured` line says which.
      */
     private hostCost;
-    /** Transcript cost since `mark`; unmeasured (and zero) without one, or with a model that has no price. */
+    /**
+     * 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.
+     */
     private costSince;
     private reportExecution;
     /**
@@ -1566,12 +1627,5 @@ export declare class ControlServer {
      */
     private record;
 }
-/**
- * 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 declare const DEFAULT_CONTROL_PORT = 53411;
+export { DEFAULT_CONTROL_PORT } from "./paths.js";
 //# sourceMappingURL=server.d.ts.map