pi-daddy 0.28.0 → 0.32.1

package/dist/executors/executor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Which executor runs a governed child — ADR-0031.
+ *
+ * `PI_DADDY_HERDR` is three-state, and **absent means probe**. That reverses ADR-0016 point 6's opt-in, and
+ * the reversal is narrower than it sounds: nothing is detected from `herdr` being on `PATH` (option C, rejected
+ * by name), only from a server that *answered*. The grant, the depth bound, the gate and `--tools` enforcement
+ * are identical either way — `planSpawn` produces one plan and both executors enforce it.
+ *
+ * **Pure on purpose.** The probe is I/O and lives in `herdr-cli.ts`; the DECISION is a table, and a table that
+ * fits on one screen is the only reason a reversal like this is reviewable at all.
+ *
+ * The disclosure string is part of the return value rather than composed at the call site, because ADR-0031's
+ * defence against "this relocates silently" is that every outcome says what it chose AND what to set instead.
+ * Two call sites composing that separately is how one of them comes to omit it (R-28).
+ */
+import type { HerdrProbe } from "./herdr-cli.ts";
+export { EXECUTOR_KINDS, type ExecutorKind } from "../kernel/delegate-types.ts";
+import type { ExecutorKind } from "../kernel/delegate-types.ts";
+export { ENV_HERDR } from "../kernel/env-names.ts";
+export interface ExecutorChoice {
+    kind: ExecutorKind;
+    /** The operator named it: `PI_DADDY_HERDR` was exactly `0` or `1`. */
+    forced: boolean;
+    /** Whether a probe was needed at all — false only for `0`. */
+    probed: boolean;
+    /**
+     * Set ONLY when herdr was demanded and is unreachable. Every delegation must refuse with this.
+     *
+     * Note that `kind` stays `"herdr"` in that case, deliberately: nothing downstream may mistake a refusing
+     * session for a working process-executor one.
+     */
+    refusal?: string;
+    /** One line for the session banner and `/grants`. Always present. */
+    disclosure: string;
+}
+/** `0` is the one value that needs no probe: the operator ruled herdr out, so asking is pure cost. */
+export declare function needsProbe(raw: string | undefined): boolean;
+export declare function chooseExecutor(raw: string | undefined, probe: HerdrProbe | null): ExecutorChoice;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executors/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/executors/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,sGAAsG;AACtG,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE3D;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,cAAc,CA6EhG"}

package/dist/executors/executor.js

@@ -0,0 +1,95 @@
+/**
+ * Which executor runs a governed child — ADR-0031.
+ *
+ * `PI_DADDY_HERDR` is three-state, and **absent means probe**. That reverses ADR-0016 point 6's opt-in, and
+ * the reversal is narrower than it sounds: nothing is detected from `herdr` being on `PATH` (option C, rejected
+ * by name), only from a server that *answered*. The grant, the depth bound, the gate and `--tools` enforcement
+ * are identical either way — `planSpawn` produces one plan and both executors enforce it.
+ *
+ * **Pure on purpose.** The probe is I/O and lives in `herdr-cli.ts`; the DECISION is a table, and a table that
+ * fits on one screen is the only reason a reversal like this is reviewable at all.
+ *
+ * The disclosure string is part of the return value rather than composed at the call site, because ADR-0031's
+ * defence against "this relocates silently" is that every outcome says what it chose AND what to set instead.
+ * Two call sites composing that separately is how one of them comes to omit it (R-28).
+ */
+export { EXECUTOR_KINDS } from "../kernel/delegate-types.js";
+import { ENV_HERDR } from "../kernel/env-names.js";
+export { ENV_HERDR } from "../kernel/env-names.js";
+/** `0` is the one value that needs no probe: the operator ruled herdr out, so asking is pure cost. */
+export function needsProbe(raw) {
+    return raw === undefined || raw === "1";
+}
+export function chooseExecutor(raw, probe) {
+    if (raw === "0") {
+        return {
+            kind: "process",
+            forced: true,
+            probed: false,
+            disclosure: "captured subprocess (PI_DADDY_HERDR=0) — children have no terminal",
+        };
+    }
+    if (raw === "1") {
+        if (probe?.ok) {
+            return { kind: "herdr", forced: true, probed: true, disclosure: "herdr panes (PI_DADDY_HERDR=1)" };
+        }
+        // Refusal, not fallback — the operator's decision of 2026-08-17, against the alternative of falling back
+        // loudly. A fallback nobody reads is R-25's shape; refusing keeps the ledger unable to name a child that
+        // ran somewhere nobody chose. A `null` probe lands here too: if the probe failed so badly it produced no
+        // result, herdr was still demanded, and failing closed means refusing.
+        const why = probe?.error ?? "the herdr probe did not succeed";
+        return {
+            kind: "herdr",
+            forced: true,
+            probed: true,
+            refusal: `PI_DADDY_HERDR=1 demands the herdr executor and herdr is not answering (${why}). ` +
+                `Delegation is refused rather than quietly relocated to a captured subprocess, so this session's ` +
+                `ledger can never contain a child that ran somewhere nobody chose. Start herdr, or unset ` +
+                `PI_DADDY_HERDR to let this session probe, or set PI_DADDY_HERDR=0 to choose subprocesses.`,
+            disclosure: `herdr panes DEMANDED but unreachable (${why}) — every delegation will refuse`,
+        };
+    }
+    if (raw !== undefined) {
+        // Rule 8: fail closed and be loud. An unrecognised value must not relocate a run, and must not break
+        // delegation either — the operator meant *something*, and the dependency-free executor is the safe read.
+        // The empty string lands here rather than with `undefined`, which keeps absent-versus-empty
+        // distinguishable exactly as `PI_DADDY_GATED` does.
+        return {
+            kind: "process",
+            forced: false,
+            probed: probe !== null,
+            disclosure: `captured subprocess — PI_DADDY_HERDR is set to an unrecognised value and was ignored. ` +
+                `Use 1 (demand herdr panes), 0 (demand subprocesses), or unset it to probe.`,
+        };
+    }
+    if (probe?.ok) {
+        return { kind: "herdr", forced: false, probed: true, disclosure: "herdr panes (probed — herdr is answering)" };
+    }
+    if (probe === null) {
+        // **The pre-probe seed, and it must not claim a probe happened.** `createGrantsSession` builds a choice
+        // synchronously with `probe: null` because S-5 forces the factory to run before any hook; `resolveExecutor`
+        // replaces it during `session_start`. This branch previously fell through to the one below and reported
+        // `probed: true` with the word "(probed)" in its disclosure — a fabricated observation, indistinguishable
+        // from a real negative probe.
+        //
+        // Unreachable in practice today (pi awaits the `session_start` emit before the first prompt, verified by a
+        // reviewer against real pi), which is exactly why it is worth making honest rather than leaving to be
+        // discovered: if a throw ever strands a session on this reading, the disclosure should say so.
+        return {
+            kind: "process",
+            forced: false,
+            probed: false,
+            disclosure: "not yet probed — settling at session start",
+        };
+    }
+    return {
+        kind: "process",
+        forced: false,
+        probed: true,
+        // Names the remedy on the same line as the state. The gap that produced ADR-0031 was not that the
+        // operator could not see which executor ran — it was that seeing it would not have told them what to do.
+        disclosure: `captured subprocess (probed — no herdr answering${probe?.error ? `: ${probe.error}` : ""}). ` +
+            `Set PI_DADDY_HERDR=1 to demand panes.`,
+    };
+}
+//# sourceMappingURL=executor.js.map

package/dist/executors/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../src/executors/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAE,cAAc,EAAqB,MAAM,6BAA6B,CAAC;AAEhF,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAmBnD,sGAAsG;AACtG,MAAM,UAAU,UAAU,CAAC,GAAuB;IAChD,OAAO,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,GAAuB,EAAE,KAAwB;IAC9E,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QAChB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,oEAAoE;SACjF,CAAC;IACJ,CAAC;IAED,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QAChB,IAAI,KAAK,EAAE,EAAE,EAAE,CAAC;YACd,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,gCAAgC,EAAE,CAAC;QACrG,CAAC;QACD,yGAAyG;QACzG,yGAAyG;QACzG,yGAAyG;QACzG,uEAAuE;QACvE,MAAM,GAAG,GAAG,KAAK,EAAE,KAAK,IAAI,iCAAiC,CAAC;QAC9D,OAAO;YACL,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,IAAI;YACZ,OAAO,EACL,2EAA2E,GAAG,KAAK;gBACnF,kGAAkG;gBAClG,0FAA0F;gBAC1F,2FAA2F;YAC7F,UAAU,EAAE,yCAAyC,GAAG,kCAAkC;SAC3F,CAAC;IACJ,CAAC;IAED,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,qGAAqG;QACrG,yGAAyG;QACzG,4FAA4F;QAC5F,oDAAoD;QACpD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,KAAK,KAAK,IAAI;YACtB,UAAU,EACR,wFAAwF;gBACxF,4EAA4E;SAC/E,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,EAAE,EAAE,EAAE,CAAC;QACd,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,2CAA2C,EAAE,CAAC;IACjH,CAAC;IACD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,wGAAwG;QACxG,4GAA4G;QAC5G,wGAAwG;QACxG,0GAA0G;QAC1G,8BAA8B;QAC9B,EAAE;QACF,2GAA2G;QAC3G,sGAAsG;QACtG,+FAA+F;QAC/F,OAAO;YACL,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,4CAA4C;SACzD,CAAC;IACJ,CAAC;IACD,OAAO;QACL,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,IAAI;QACZ,kGAAkG;QAClG,yGAAyG;QACzG,UAAU,EACR,mDAAmD,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK;YAC9F,uCAAuC;KAC1C,CAAC;AACJ,CAAC"}

package/dist/executors/herdr-cli.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Talking to herdr: one command, one JSON envelope, plus the two questions ADR-0031 needs answered.
+ *
+ * Lifted out of `src/executors/run-herdr.ts`, which was at 357 of the 400-line ceiling and gains output polling under
+ * ADR-0032. But the split is not only about lines: **the probe is not an executor concern**. It runs at session
+ * start, before any delegation exists, to decide *which* executor a session will use — so leaving it inside the
+ * herdr executor would mean the session imported the thing it was deciding whether to use.
+ *
+ * Every rule here is tested against an injected `exec`, so the suite stays fast, pi-free and herdr-free. The
+ * facts the fakes reproduce were measured against real herdr 0.7.5 (probe `g16-herdr`).
+ */
+export { ENV_HERDR_WORKSPACE } from "../kernel/env-names.ts";
+/** One herdr CLI invocation. Injectable so every rule below is testable without herdr installed. */
+export type HerdrExec = (args: string[]) => Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
+export declare const defaultExec: HerdrExec;
+/**
+ * Parse herdr's JSON envelope. Every command replies `{id, result}` or `{id, error:{code,message}}`.
+ *
+ * `stderr` is folded into the message because the first end-to-end run failed with an EMPTY stdout and the
+ * real reason on stderr, producing the useless diagnostic "unparseable herdr reply: ". A wrapper that
+ * hides the substrate's own error message costs more time than it saves.
+ */
+export declare function parseReply(reply: {
+    stdout: string;
+    stderr: string;
+}): {
+    result?: Record<string, unknown>;
+    error?: string;
+};
+/** Bound on the session-start probe. Short: it sits in front of the operator's first prompt. */
+export declare const PROBE_TIMEOUT_MS = 2000;
+export interface HerdrProbe {
+    ok: boolean;
+    /** herdr's own words when it is not reachable. Carried so the disclosure line can name the reason. */
+    error?: string;
+}
+/**
+ * Is there a herdr server that will answer right now? — ADR-0031's selection input.
+ *
+ * **`tab list`, not `which herdr`.** ADR-0031 rejects `PATH` detection as option C by name: a binary on `PATH`
+ * with no server behind it would make every delegation fail at `tab create`, on a path the operator never
+ * chose, and the diagnostic would arrive at the first delegation rather than at startup. Only a parsed
+ * `result` envelope counts as reachable; an `error` envelope, a non-JSON reply, a timeout and a throwing
+ * `exec` are all "not reachable" with the reason preserved.
+ *
+ * **Zero tabs is a successful answer**, deliberately: a fresh herdr with nothing open is reachable.
+ *
+ * Never throws. A probe that threw out of `session_start` would cancel every control after it, which is
+ * R-60's shape exactly — and this one runs *before* the line that discloses what it decided.
+ */
+export declare function probeHerdr(options?: {
+    exec?: HerdrExec;
+    timeoutMs?: number;
+}): Promise<HerdrProbe>;
+/** herdr's own variable, set in every pane it creates. Measured 2026-08-17; documented nowhere. */
+export declare const ENV_PARENT_WORKSPACE = "HERDR_WORKSPACE_ID";
+/** The operator's explicit override. Defined here because this is the only module that reads it. */
+/**
+ * Which herdr workspace a governed child's pane belongs in.
+ *
+ * **Defaults to the parent's own workspace.** herdr tells a pane which workspace it is in
+ * (`HERDR_WORKSPACE_ID`, alongside `HERDR_TAB_ID` and `HERDR_PANE_ID`), and a child placed in a *different*
+ * workspace from the pi session that spawned it turns "switch between them" into a workspace hop — which is
+ * the entire feature ADR-0032 exists to deliver. The previous behaviour was "omitted lets herdr choose",
+ * which is that failure by default on any machine with more than one workspace.
+ *
+ * `PI_DADDY_HERDR_WORKSPACE` still wins: it is the operator saying so explicitly, and an explicit answer
+ * beating an inference is this package's standing rule (ADR-0030 says it about the grant itself).
+ *
+ * Blank is treated as absent rather than passed through — `--workspace ""` is not a workspace, and it would
+ * fail `tab create` on a path nobody chose.
+ */
+export declare function resolveWorkspace(env: NodeJS.ProcessEnv): string | undefined;
+//# sourceMappingURL=herdr-cli.d.ts.map

package/dist/executors/herdr-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-cli.d.ts","sourceRoot":"","sources":["../../src/executors/herdr-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,oGAAoG;AACpG,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE7G,eAAO,MAAM,WAAW,EAAE,SAatB,CAAC;AAEL;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAcA;AAED,gGAAgG;AAChG,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,sGAAsG;IACtG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAsB5G;AAED,mGAAmG;AACnG,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AAEzD,oGAAoG;AAEpG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,SAAS,CAI3E"}

package/dist/executors/herdr-cli.js

@@ -0,0 +1,114 @@
+/**
+ * Talking to herdr: one command, one JSON envelope, plus the two questions ADR-0031 needs answered.
+ *
+ * Lifted out of `src/executors/run-herdr.ts`, which was at 357 of the 400-line ceiling and gains output polling under
+ * ADR-0032. But the split is not only about lines: **the probe is not an executor concern**. It runs at session
+ * start, before any delegation exists, to decide *which* executor a session will use — so leaving it inside the
+ * herdr executor would mean the session imported the thing it was deciding whether to use.
+ *
+ * Every rule here is tested against an injected `exec`, so the suite stays fast, pi-free and herdr-free. The
+ * facts the fakes reproduce were measured against real herdr 0.7.5 (probe `g16-herdr`).
+ */
+import { execFile } from "node:child_process";
+import { ENV_HERDR_WORKSPACE } from "../kernel/env-names.js";
+export { ENV_HERDR_WORKSPACE } from "../kernel/env-names.js";
+export const defaultExec = (args) => new Promise((settle) => {
+    execFile("herdr", args, { maxBuffer: 32 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const raw = error?.code;
+        const code = typeof raw === "number" ? raw : error ? 1 : 0;
+        // **A string `code` is a spawn failure, and it used to be thrown away.** `ENOENT` — herdr not installed —
+        // arrives as `code: "ENOENT"`, so the numeric test failed, the message was dropped, and an operator with
+        // `PI_DADDY_HERDR=1` on a machine without herdr was told *"herdr is not answering (unparseable herdr
+        // reply: (no output))"* rather than that the binary is missing. Rule 8 wants the loud version, and this is
+        // the first diagnostic such an operator meets.
+        const spawnFailure = typeof raw === "string" ? `herdr could not be run (${raw}): ${error?.message ?? ""}` : "";
+        settle({ code, stdout: String(stdout), stderr: spawnFailure || String(stderr) });
+    });
+});
+/**
+ * Parse herdr's JSON envelope. Every command replies `{id, result}` or `{id, error:{code,message}}`.
+ *
+ * `stderr` is folded into the message because the first end-to-end run failed with an EMPTY stdout and the
+ * real reason on stderr, producing the useless diagnostic "unparseable herdr reply: ". A wrapper that
+ * hides the substrate's own error message costs more time than it saves.
+ */
+export function parseReply(reply) {
+    try {
+        const parsed = JSON.parse(reply.stdout);
+        if (parsed.error)
+            return { error: parsed.error.message ?? parsed.error.code ?? "herdr reported an error" };
+        return { result: parsed.result };
+    }
+    catch {
+        // A non-JSON reply is a herdr-version or PATH problem, not a governance decision. Surfaced as a spawn
+        // error so the caller reports "could not start" rather than "the child produced nothing".
+        const detail = [reply.stdout.trim(), reply.stderr.trim()].filter((t) => t.length > 0).join(" | ");
+        return { error: `unparseable herdr reply: ${detail.slice(0, 300) || "(no output)"}` };
+    }
+}
+/** Bound on the session-start probe. Short: it sits in front of the operator's first prompt. */
+export const PROBE_TIMEOUT_MS = 2000;
+/**
+ * Is there a herdr server that will answer right now? — ADR-0031's selection input.
+ *
+ * **`tab list`, not `which herdr`.** ADR-0031 rejects `PATH` detection as option C by name: a binary on `PATH`
+ * with no server behind it would make every delegation fail at `tab create`, on a path the operator never
+ * chose, and the diagnostic would arrive at the first delegation rather than at startup. Only a parsed
+ * `result` envelope counts as reachable; an `error` envelope, a non-JSON reply, a timeout and a throwing
+ * `exec` are all "not reachable" with the reason preserved.
+ *
+ * **Zero tabs is a successful answer**, deliberately: a fresh herdr with nothing open is reachable.
+ *
+ * Never throws. A probe that threw out of `session_start` would cancel every control after it, which is
+ * R-60's shape exactly — and this one runs *before* the line that discloses what it decided.
+ */
+export async function probeHerdr(options = {}) {
+    const exec = options.exec ?? defaultExec;
+    const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
+    let timer;
+    try {
+        return await Promise.race([
+            exec(["tab", "list"]).then((reply) => {
+                const parsed = parseReply(reply);
+                return parsed.error ? { ok: false, error: parsed.error } : { ok: true };
+            }),
+            new Promise((settle) => {
+                timer = setTimeout(() => settle({ ok: false, error: `probe timed out after ${timeoutMs}ms` }), timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        return { ok: false, error: String(error) };
+    }
+    finally {
+        // Cleared whichever branch won, so a fast probe does not hold the event loop open for the timeout's
+        // remainder — which would add up to two seconds to every `node --test` run of this file.
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+/** herdr's own variable, set in every pane it creates. Measured 2026-08-17; documented nowhere. */
+export const ENV_PARENT_WORKSPACE = "HERDR_WORKSPACE_ID";
+/** The operator's explicit override. Defined here because this is the only module that reads it. */
+/**
+ * Which herdr workspace a governed child's pane belongs in.
+ *
+ * **Defaults to the parent's own workspace.** herdr tells a pane which workspace it is in
+ * (`HERDR_WORKSPACE_ID`, alongside `HERDR_TAB_ID` and `HERDR_PANE_ID`), and a child placed in a *different*
+ * workspace from the pi session that spawned it turns "switch between them" into a workspace hop — which is
+ * the entire feature ADR-0032 exists to deliver. The previous behaviour was "omitted lets herdr choose",
+ * which is that failure by default on any machine with more than one workspace.
+ *
+ * `PI_DADDY_HERDR_WORKSPACE` still wins: it is the operator saying so explicitly, and an explicit answer
+ * beating an inference is this package's standing rule (ADR-0030 says it about the grant itself).
+ *
+ * Blank is treated as absent rather than passed through — `--workspace ""` is not a workspace, and it would
+ * fail `tab create` on a path nobody chose.
+ */
+export function resolveWorkspace(env) {
+    const explicit = env[ENV_HERDR_WORKSPACE]?.trim();
+    if (explicit)
+        return explicit;
+    return env[ENV_PARENT_WORKSPACE]?.trim() || undefined;
+}
+//# sourceMappingURL=herdr-cli.js.map

package/dist/executors/herdr-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-cli.js","sourceRoot":"","sources":["../../src/executors/herdr-cli.ts"],"names":[],"mappings":"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"}

package/dist/executors/herdr-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-name.d.ts","sourceRoot":"","sources":["../../src/executors/herdr-name.ts"],"names":[],"mappings":"AASA,uFAAuF;AACvF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUpD"}

package/dist/executors/herdr-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-name.js","sourceRoot":"","sources":["../../src/executors/herdr-name.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,cAAc,GAAG,EAAE,CAAC;AAE1B,uFAAuF;AACvF,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,MAAM,GAAG,GAAG,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACrD,MAAM,OAAO,GAAG,IAAI;SACjB,WAAW,EAAE;SACb,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC;SAC7B,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC;SACtB,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAC3B,MAAM,IAAI,GAAG,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC;IAC5C,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,OAAO,CAAC;IACrE,OAAO,IAAI,GAAG,MAAM,CAAC;AACvB,CAAC"}

package/dist/executors/herdr-pi-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-pi-lifecycle.d.ts","sourceRoot":"","sources":["../../src/executors/herdr-pi-lifecycle.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,gCAAgC,IAAI,MAAM,CAUzD"}

package/dist/executors/herdr-pi-lifecycle.js

@@ -0,0 +1,22 @@
+/** Locate the pinned, lifecycle-only Herdr Pi integration shipped with this package. */
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * Explicit `-e` survives Pi's `--no-extensions`; only this audited source is loaded for a Herdr child.
+ *
+ * Source-loaded tests resolve the adjacent vendor file. Installed builds resolve the packed `src/` copy,
+ * deliberately rather than discovering an operator's extension directory.
+ */
+export function bundledHerdrPiLifecycleExtension() {
+    const candidates = [
+        new URL("./vendor/herdr-pi-lifecycle.ts", import.meta.url),
+        new URL("../../src/executors/vendor/herdr-pi-lifecycle.ts", import.meta.url),
+    ];
+    for (const candidate of candidates) {
+        const path = fileURLToPath(candidate);
+        if (existsSync(path))
+            return path;
+    }
+    throw new Error("the bundled Herdr Pi lifecycle integration is missing from this package");
+}
+//# sourceMappingURL=herdr-pi-lifecycle.js.map

package/dist/executors/herdr-pi-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-pi-lifecycle.js","sourceRoot":"","sources":["../../src/executors/herdr-pi-lifecycle.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC;IAC9C,MAAM,UAAU,GAAG;QACjB,IAAI,GAAG,CAAC,gCAAgC,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;QAC1D,IAAI,GAAG,CAAC,kDAAkD,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;KAC7E,CAAC;IACF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,MAAM,IAAI,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;IACpC,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;AAC7F,CAAC"}

package/dist/executors/herdr-poll.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Waiting for a herdr agent to settle, and reading what it printed on the way.
+ *
+ * Split out of `src/executors/run-herdr.ts` when that file hit **404 of the 400-line ceiling** adding ADR-0032's output
+ * polling. The seam was named in the plan before it was needed, and it is a real one: this module is about
+ * *observing* an agent, `run-herdr.ts` is about *starting and cleaning up after* one. Nothing here creates or
+ * destroys anything.
+ *
+ * The two facts it is built on were measured against real herdr 0.7.5 (probe `g16-herdr`) and both are
+ * counter-intuitive enough to be worth the module comment: `agent wait --until idle` matches the state the
+ * agent was **already** in, and `agent read` is the one command that does **not** return a JSON envelope.
+ */
+import { type HerdrExec } from "./herdr-cli.ts";
+import { herdrSessionReference } from "../governance/native-session.ts";
+/**
+ * What `waitForSettled` needs from a run request.
+ *
+ * Declared here rather than importing `HerdrRunRequest`, which would make the two modules mutually dependent
+ * for no benefit. `HerdrRunRequest` satisfies it structurally, so the call site needs no adapter.
+ */
+export interface PollTarget {
+    /** herdr agent name. */
+    name: string;
+    nativePaneId?: string;
+    onSessionReference?: (reference: NonNullable<ReturnType<typeof herdrSessionReference>>) => void;
+    signal?: AbortSignal;
+    /**
+     * The pane's last few lines, re-reported on every poll — a SNAPSHOT, not a stream (ADR-0032).
+     *
+     * The consumer must **replace** what it holds rather than append. `agent read` returns a snapshot of a
+     * bounded terminal, and treating it as append-only is what produced an 89,000× amplification; see
+     * `tailLines`.
+     */
+    onSnapshot?: (lines: string[]) => void;
+    /** Reuses already-requested pane bytes; never adds an observation-only RPC. */
+    onObservation?: (bytes: Uint8Array) => void;
+    /** How many lines the display wants. Bounds the per-poll cost regardless of how big the pane is. */
+    snapshotLines?: number;
+    /** Poll cadence override. Exists so tests do not wait `POLL_INTERVAL_MS` per state transition. */
+    pollIntervalMs?: number;
+    /**
+     * Inactivity bound (PR 3e). Activity on this executor is a change in the pane's text or in what `activityProbe`
+     * returns (the child's pi session file). Undefined means the wall-clock deadline alone applies.
+     */
+    idleTimeoutMs?: number;
+    activityProbe?: () => Promise<string | number | undefined> | string | number | undefined;
+}
+/** The pre-prompt sequence from the native start reply; absent is unknown, never zero. */
+export declare function observeHerdrSession(agent: unknown, pane: string | undefined, sink: PollTarget["onSessionReference"]): void;
+export declare function seqOf(result: Record<string, unknown> | undefined): number;
+/** How often to poll `agent get` while waiting for the child to settle. */
+export declare const POLL_INTERVAL_MS = 750;
+/**
+ * A prompt accepted from a terminal state must produce an observable lifecycle change promptly.
+ *
+ * Herdr 0.8's `agent prompt --wait` documents this same five-second bound. We retain polling because it
+ * supplies the bounded live pane snapshots, but refuse rather than holding a parent for the whole child timeout when
+ * the only reported state remains the pre-prompt terminal state. That is a detector/integration failure, not
+ * evidence that a child settled.
+ */
+export declare const FRESH_LIFECYCLE_TIMEOUT_MS = 5000;
+/** Lines of pane tail reported per poll. Matches the status block's own tail, so nothing is fetched unused. */
+export declare const DEFAULT_SNAPSHOT_LINES = 3;
+/**
+ * Wait for the child to settle, without accepting the state it was already in.
+ *
+ * **R-33, measured.** `herdr agent wait --until idle` called right after `agent prompt` returned
+ * *immediately*, matching the agent's **pre-existing** idle state with `state_change_seq` unchanged — a
+ * reply indistinguishable from a completed run. For fan-out that is not an inconvenience but a
+ * correctness bug: an orchestrator would "collect" N children that never ran and merge N empty results
+ * into a confident summary (R-03 with a new cause).
+ *
+ * So this polls `agent get` and requires **both** that the status is terminal **and** that
+ * `state_change_seq` has advanced past the value observed before prompting. `agent wait` is deliberately
+ * not used at all: its contract cannot express "settled *after* this point".
+ */
+/**
+ * Establish the bundled Pi lifecycle reporter's idle baseline before prompt dispatch.
+ *
+ * `screen_detection_skipped` is Herdr's reported fact that a full lifecycle authority owns this pane.
+ * Waiting for it prevents the reporter's asynchronously queued initial idle report from becoming a
+ * post-prompt sequence advance. This is not completion: no prompt has been sent at this point.
+ */
+export declare function waitForLifecycleBaseline(exec: HerdrExec, request: PollTarget, deadline: number): Promise<{
+    before?: number;
+    aborted?: boolean;
+    spawnError?: string;
+}>;
+export declare function waitForSettled(exec: HerdrExec, request: PollTarget, before: number, deadline: number, maxOutputBytes: number): Promise<{
+    status?: string;
+    timedOut?: boolean;
+    idle?: true;
+    aborted?: boolean;
+    spawnError?: string;
+}>;
+/**
+ * The last `keep` non-blank lines of a pane snapshot — what the display actually needs.
+ *
+ * **This replaces a `newSuffix` diff, and the replacement is a correction rather than a tune-up.** The old
+ * design treated `agent read` as a *stream* and tried to report only what was new, by testing whether the new
+ * text extended the old. That is wrong about the substrate: `agent read` returns a **snapshot of a bounded
+ * terminal**, and a snapshot is not an append-only log. Two ordinary things break the prefix test forever —
+ * the pane **scrolling** (its top lines are gone, so the new text is not an extension of the old) and
+ * `readPane` **truncating to the tail** past `maxOutputBytes` (each read is a different window of a growing
+ * buffer). Once either happens, every poll reported the whole buffer.
+ *
+ * Measured before the fix: **51 MiB streamed for ~600 bytes of real output — 89,000× amplification** in 37
+ * seconds, per child, with a scrolling pane also delivering the same real lines three times each. The old
+ * docstring named that exact failure as the thing it prevented.
+ *
+ * So the herdr path now reports a **bounded snapshot** and the consumer *replaces* rather than appends. There
+ * is no diff to get wrong, the per-poll cost is `keep` lines regardless of buffer size, and a scrolling pane
+ * simply shows its current tail — which is what a human looking at that pane would see.
+ */
+export declare function tailLines(snapshot: string, keep: number): string[];
+/**
+ * Read the pane's contents.
+ *
+ * `agent read` is the ONE command that does not return herdr's JSON envelope — it writes the terminal's
+ * text straight to stdout. Running it through `parseReply` turned every successful read into
+ * "unparseable herdr reply", i.e. reported the child's actual answer as a failure to read it. Found by the
+ * end-to-end run; the unit fake had been written to the envelope shape and so agreed with the bug.
+ *
+ * A JSON envelope is still accepted first, because an `error` reply here IS JSON and must not be mistaken
+ * for terminal output.
+ *
+ * **`readFailed` is separate from `text`, and that separation is the fix for an R-03 defect.** A failed read
+ * used to return its own diagnostic *as* `text` — so `runHerdrPane` returned
+ * `[grants] could not read the agent pane: pane is gone` **as the child's answer, with `code: 0`**, and the
+ * orchestrator read a failure message as a completed sub-agent's report. Measured. It mattered little when this
+ * ran once per child; ADR-0032 made it run on every poll, up to 800 times for a ten-minute child, so a
+ * transient failure went from unlikely to expected. The caller must now decide, and it cannot do so by
+ * inspecting a string.
+ */
+export declare function readPane(exec: HerdrExec, name: string, maxOutputBytes: number): Promise<{
+    text: string;
+    truncated: boolean;
+    readFailed?: string;
+}>;
+//# sourceMappingURL=herdr-poll.d.ts.map

package/dist/executors/herdr-poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr-poll.d.ts","sourceRoot":"","sources":["../../src/executors/herdr-poll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,KAAK,IAAI,CAAC;IAChG,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACvC,+EAA+E;IAC/E,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,oGAAoG;IACpG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kGAAkG;IAClG,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC1F;AAKD,0FAA0F;AAC1F,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE,UAAU,CAAC,oBAAoB,CAAC,GACrC,IAAI,CAQN;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,MAAM,CAGzE;AAED,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAChD,+GAA+G;AAC/G,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAkBtE;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAkFvG;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBlE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuBpE"}