tickmarkr 2.6.4 → 2.6.6

package/dist/run/git.js

@@ -9,6 +9,7 @@ import { StringDecoder } from "node:string_decoder";
 import { shq } from "../adapters/types.js";
 import { tickmarkrDir } from "../graph/graph.js";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
+import { titleEnvironment } from "./title-environment.js";
 export { ROUTING_ENV_SEAMS };
 // OBS-110: gate/baseline/tip-verify children are vitest suites; without a fork cap, concurrent
 // full-suite gate runs fork a worker-per-core pool per worktree and saturate the operator box.
@@ -324,6 +325,14 @@ function executeShell(cmd, cwd, timeoutMs, login, options, observation) {
     // OBS-854: descendants can leave the checkout (nested fixture suites do), so cwd alone cannot
     // attribute them. Every daemon shell exports the daemon pid as their durable parentage marker.
     env[SUITE_PARENT_ENV] = String(process.pid);
+    // A2: on Darwin a Node child's title writes stay in JavaScript (title-environment.ts); runnerInputsHash
+    // hashes this same effective NODE_OPTIONS, so a verdict is only reused under the identical mode. Native
+    // mode is applied too: it drops a preload a nested shell inherited from its parent (unset when that was all).
+    const { nodeOptions } = titleEnvironment(env);
+    if (nodeOptions === undefined)
+        delete env.NODE_OPTIONS;
+    else
+        env.NODE_OPTIONS = nodeOptions;
     // T7: the capacity every result of this shell carries, read HERE — off the environment the child
     // is about to receive, after the precedence above has settled. An operator export is already in
     // `env`, so what gets recorded is the operator's number, which is the case a release was re-taken

package/dist/run/journal.d.ts

@@ -650,7 +650,9 @@ export declare const rangePatch: (cwd: string, base: string, head: string) => st
  * these and is refused as ambiguous; containment never counts.
  * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
  */
-export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown): boolean;
+export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown, memo?: OwedProofMemo): boolean;
+/** I2: a caller-scoped set of completed integration re-proofs (see integrationMapped); absent, every fold re-proves. */
+export type OwedProofMemo = Set<string>;
 /**
  * Lifetime patch authors of base..head, read from the run: the daemon's subjectAuthors fold
  * (daemon.ts, not exported and not this task's to edit) restated synchronously so the waive row is
@@ -687,6 +689,8 @@ export type ChannelFact = {
  * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
  * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
  * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ * `memo` (I2, optional): a store-scoped table reusing the immutable git re-proof of an integration mapping
+ * across folds; every artifact, hash, criteria and reviewer condition is still re-read on every fold.
  */
-export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string): OwedFold;
+export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string, memo?: OwedProofMemo): OwedFold;
 export {};

package/dist/run/journal.js

@@ -2425,11 +2425,24 @@ const COMMIT_ID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
  * these and is refused as ambiguous; containment never counts.
  * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
  */
-export function integrationMapped(cwd, events, o, mergeBase, head) {
+export function integrationMapped(cwd, events, o, mergeBase, head, memo) {
     if (typeof mergeBase !== "string" || typeof head !== "string" || !COMMIT_ID.test(mergeBase) || !COMMIT_ID.test(head))
         return false;
     if (!events.some((e) => e.event === "merge" && e.taskId === o.taskId && e.data.commit === head))
         return false;
+    // Only the git component is memoised, and only a completed proof: commit ids name immutable history,
+    // so the key is the obligation's id and recorded range facts plus the claimed mergeBase..head. A refusal
+    // or git failure (a shallow or partial object store can refuse a range it later proves) is never cached
+    // and is re-proved next fold. The merge-row eligibility above is rechecked on every fold.
+    const key = JSON.stringify([o.id, mergeBase, head, o.base, o.head, o.patch, o.patches]);
+    if (memo?.has(key))
+        return true;
+    const proved = integrationProved(cwd, o, mergeBase, head);
+    if (proved)
+        memo?.add(key);
+    return proved;
+}
+function integrationProved(cwd, o, mergeBase, head) {
     try {
         const parents = owedGit(cwd, ["show", "-s", "--format=%P", head]).trim().split(" ");
         if (parents.length !== 2 || parents[0] !== mergeBase)
@@ -2609,7 +2622,7 @@ const declaredVendors = (o) => {
     return vendors;
 };
 /** Why a discharge row no longer proves its obligation, re-read from its artifact; undefined when it does. */
-function dischargeProblem(row, o, events, cwd) {
+function dischargeProblem(row, o, events, cwd, memo) {
     const d = row.data;
     if (row.taskId !== o.taskId)
         return "discharge names another task";
@@ -2617,7 +2630,7 @@ function dischargeProblem(row, o, events, cwd) {
         return "discharge proved other criteria";
     const exact = d.mapping === "exact" && d.mergeBase === o.base && d.head === o.head;
     // The integration mapping is re-proved from git on every fold, never taken from the row's claims.
-    const integration = d.mapping === "integration" && integrationMapped(cwd, events, o, d.mergeBase, d.head);
+    const integration = d.mapping === "integration" && integrationMapped(cwd, events, o, d.mergeBase, d.head, memo);
     if (!exact && !integration)
         return "discharge range does not bind the obligation";
     let artifact;
@@ -2675,16 +2688,18 @@ function dischargeProblem(row, o, events, cwd) {
  * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
  * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
  * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ * `memo` (I2, optional): a store-scoped table reusing the immutable git re-proof of an integration mapping
+ * across folds; every artifact, hash, criteria and reviewer condition is still re-read on every fold.
  */
-export function foldOwedChecks(events, cwd) {
+export function foldOwedChecks(events, cwd, memo) {
     try {
-        return foldOwedChecksOrThrow(events, cwd);
+        return foldOwedChecksOrThrow(events, cwd, memo);
     }
     catch (error) {
         return { known: false, debt: "unknown", outstanding: [], acceptedRisk: [], discharged: [], unknown: [{ reason: `owed-check fold failed: ${String(error).split("\n")[0]}` }] };
     }
 }
-function foldOwedChecksOrThrow(events, cwd) {
+function foldOwedChecksOrThrow(events, cwd, memo) {
     const accepted = new Map();
     const discharged = new Set();
     const unknown = [];
@@ -2703,7 +2718,7 @@ function foldOwedChecksOrThrow(events, cwd) {
             const ids = Array.isArray(e.data.ids) ? e.data.ids : [];
             const problems = ids.map((id) => {
                 const o = accepted.get(String(id));
-                return o ? dischargeProblem(e, o, events, cwd) : "discharge names no recorded obligation";
+                return o ? dischargeProblem(e, o, events, cwd, memo) : "discharge names no recorded obligation";
             });
             const problem = ids.length ? problems.find((p) => p !== undefined) : "discharge names no obligation";
             if (problem)

package/dist/run/launchservices-check.d.ts

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import type { AuthHealth, LaunchServicesRecord } from "../adapters/types.js";
+/**
+ * v2.6.5 T10 (A1, D-787/D-789): did launchservicesd restart since tickmarkr last looked?
+ *
+ * On 2026-09-30 a heavy local suite exhausted launchservicesd's Mach port space (0x1000600b); the daemon
+ * crashed, respawned with an empty app registry, and every GUI app launched before it read "not open
+ * anymore". The tell is the daemon's own identity: a young pid/start beside an old Dock and Finder.
+ * doctor and standalone verify read that identity with one bounded /bin/ps call, compare it with the
+ * one the FIRST doctor.json record holds (registry order — no new state file or adapter row), and
+ * persist one advisory on a change. Unreadable evidence is unknown: the prior identity is kept, never
+ * replaced by a guess. Advisory only — verdicts, retries and routing never read it.
+ */
+export declare const LAUNCHSERVICES_PROBE_CEILING_MS = 5000;
+export interface LaunchServicesIdentity {
+    pid: number;
+    start: string;
+}
+export type LaunchServicesObservation = {
+    status: "non-darwin";
+} | {
+    status: "read";
+    identity: LaunchServicesIdentity;
+} | {
+    status: "unreadable";
+    detail: string;
+};
+/** The closed identity table; "first" is the baseline row when no prior identity is held. */
+export type LaunchServicesStatus = "first" | "unchanged" | "changed-pid" | "changed-start" | "unreadable" | "non-darwin" | "skipped";
+/** Exactly one launchservicesd row, or null (absent, ambiguous or malformed output is unknown). */
+export declare function parsePsIdentity(stdout: string): LaunchServicesIdentity | null;
+export type ProbeTimer = (fire: () => void, ms: number) => () => void;
+interface ProbeSeam {
+    platform: NodeJS.Platform;
+    spawn: typeof spawn;
+    setTimer: ProbeTimer;
+    signal?: AbortSignal;
+}
+export declare const setLaunchServicesProbeForTests: (s: Partial<ProbeSeam>) => void;
+export declare const resetLaunchServicesProbeForTests: () => void;
+export declare function observeLaunchServices(s?: ProbeSeam): Promise<LaunchServicesObservation>;
+export declare function launchServicesAdvisory(prior: LaunchServicesIdentity, now: LaunchServicesIdentity): string;
+/** Pure: the table row for one observation against the held record, and the record to hold next. */
+export declare function classifyLaunchServices(prior: Partial<LaunchServicesRecord> | undefined, observed: LaunchServicesObservation): {
+    status: LaunchServicesStatus;
+    next?: LaunchServicesRecord;
+    line?: string;
+};
+/** Observe, classify against the first record of `prior`, and hold the result on the first record of `health`.
+ *  Returns `health` itself when nothing changed, else a copy — the argument is never mutated. */
+export declare function recordLaunchServices(prior: Record<string, AuthHealth> | null, health: Record<string, AuthHealth>): Promise<{
+    status: LaunchServicesStatus;
+    health: Record<string, AuthHealth>;
+    line?: string;
+}>;
+export {};

package/dist/run/launchservices-check.js

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+/**
+ * v2.6.5 T10 (A1, D-787/D-789): did launchservicesd restart since tickmarkr last looked?
+ *
+ * On 2026-09-30 a heavy local suite exhausted launchservicesd's Mach port space (0x1000600b); the daemon
+ * crashed, respawned with an empty app registry, and every GUI app launched before it read "not open
+ * anymore". The tell is the daemon's own identity: a young pid/start beside an old Dock and Finder.
+ * doctor and standalone verify read that identity with one bounded /bin/ps call, compare it with the
+ * one the FIRST doctor.json record holds (registry order — no new state file or adapter row), and
+ * persist one advisory on a change. Unreadable evidence is unknown: the prior identity is kept, never
+ * replaced by a guess. Advisory only — verdicts, retries and routing never read it.
+ */
+export const LAUNCHSERVICES_PROBE_CEILING_MS = 5_000;
+// lstart in the C locale: "Wed Sep 30 21:54:33 2026"; comm is the executable path on Darwin.
+const PS_ARGS = ["-A", "-o", "pid=,lstart=,comm="];
+const PS_LINE = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(.+?)\s*$/;
+const MAX_PS_BYTES = 4 * 1024 * 1024;
+/** Exactly one launchservicesd row, or null (absent, ambiguous or malformed output is unknown). */
+export function parsePsIdentity(stdout) {
+    const rows = stdout.split("\n").flatMap((line) => {
+        const m = PS_LINE.exec(line);
+        return m && basename(m[3]) === "launchservicesd" ? [{ pid: Number(m[1]), start: m[2].replace(/\s+/g, " ") }] : [];
+    });
+    return rows.length === 1 ? rows[0] : null;
+}
+const production = () => ({
+    platform: process.platform,
+    spawn,
+    setTimer: (fire, ms) => { const t = setTimeout(fire, ms); return () => clearTimeout(t); },
+});
+// ponytail: default-off under the test runner (the catalogRefreshAllowed precedent) so an unowned doctor
+// test never takes a real host reading or changes its doctor.json bytes; tests opt in through the seam.
+let seam;
+export const setLaunchServicesProbeForTests = (s) => { seam = { ...production(), ...s }; };
+export const resetLaunchServicesProbeForTests = () => { seam = undefined; };
+const activeSeam = () => seam ?? (process.env.VITEST === "true" ? undefined : production());
+/** One /bin/ps call that owns only its child, killed at the ceiling or on cancellation and reaped before it resolves. */
+function readIdentity(s) {
+    return new Promise((resolve) => {
+        const unknown = (detail) => resolve({ status: "unreadable", detail });
+        if (s.signal?.aborted) {
+            unknown("probe cancelled");
+            return;
+        }
+        let child;
+        try {
+            child = s.spawn("/bin/ps", PS_ARGS, { stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, LC_ALL: "C" } });
+        }
+        catch (e) {
+            unknown(`/bin/ps did not start (${e instanceof Error ? e.message : String(e)})`);
+            return;
+        }
+        let out = "";
+        let why;
+        const retire = (reason) => { why ??= reason; child.kill("SIGKILL"); };
+        const clear = s.setTimer(() => retire(`/bin/ps exceeded the ${LAUNCHSERVICES_PROBE_CEILING_MS} ms kill ceiling`), LAUNCHSERVICES_PROBE_CEILING_MS);
+        const cancel = () => retire("probe cancelled");
+        s.signal?.addEventListener("abort", cancel, { once: true });
+        child.stdout?.on("data", (chunk) => {
+            out += chunk.toString("utf8");
+            if (out.length > MAX_PS_BYTES)
+                retire("/bin/ps output exceeded its bound");
+        });
+        child.once("error", (e) => { why ??= `/bin/ps failed (${e.message})`; });
+        child.once("close", (code) => {
+            clear();
+            s.signal?.removeEventListener("abort", cancel);
+            if (why)
+                return unknown(why);
+            if (code !== 0)
+                return unknown(`/bin/ps exited ${code}`);
+            const identity = parsePsIdentity(out);
+            return identity ? resolve({ status: "read", identity }) : unknown("no single launchservicesd row in /bin/ps output");
+        });
+    });
+}
+export function observeLaunchServices(s = production()) {
+    return s.platform === "darwin" ? readIdentity(s) : Promise.resolve({ status: "non-darwin" });
+}
+// doctor.json is never schema-validated: a malformed held record is no identity at all.
+const knownPrior = (prior) => typeof prior?.pid === "number" && typeof prior.start === "string";
+export function launchServicesAdvisory(prior, now) {
+    return `launchservicesd restarted: pid ${prior.pid} → ${now.pid}, started ${prior.start} → ${now.start}. `
+        + `GUI apps launched before ${now.start} may read "not open anymore" (D-787: the daemon crashed and respawned with an empty app registry). `
+        + `Remedy: quit and relaunch each affected app, or log out / restart the Mac (a restart ends agent sessions and wipes /private/tmp); `
+        + `confirm with /usr/bin/log show (launchservicesd 0x1000600b near ${now.start}) and ~/Library/Logs/DiagnosticReports/ExcUserFault_node-*.ips (advisory — verdicts unchanged)`;
+}
+/** Pure: the table row for one observation against the held record, and the record to hold next. */
+export function classifyLaunchServices(prior, observed) {
+    const kept = knownPrior(prior) ? prior : undefined;
+    if (observed.status === "non-darwin")
+        return { status: "non-darwin", next: kept };
+    if (observed.status === "unreadable") {
+        const held = kept ? `pid ${kept.pid} started ${kept.start}` : "none";
+        return { status: "unreadable", next: kept, line: `launchservicesd identity unknown — ${observed.detail}; prior identity (${held}) retained (advisory — verdicts unchanged)` };
+    }
+    const now = observed.identity;
+    if (!knownPrior(prior))
+        return { status: "first", next: now };
+    const status = prior.pid !== now.pid ? "changed-pid" : prior.start !== now.start ? "changed-start" : "unchanged";
+    if (status === "unchanged")
+        return { status, next: prior };
+    const advisory = launchServicesAdvisory(prior, now);
+    return { status, next: { ...now, advisory }, line: advisory };
+}
+/** Observe, classify against the first record of `prior`, and hold the result on the first record of `health`.
+ *  Returns `health` itself when nothing changed, else a copy — the argument is never mutated. */
+export async function recordLaunchServices(prior, health) {
+    const held = prior ? Object.values(prior)[0]?.launchServices : undefined;
+    const s = activeSeam();
+    const r = s ? classifyLaunchServices(held, await observeLaunchServices(s)) : { status: "skipped", next: knownPrior(held) ? held : undefined };
+    const holder = Object.keys(health)[0];
+    if (!holder || !r.next || JSON.stringify(health[holder].launchServices) === JSON.stringify(r.next))
+        return { ...r, health };
+    return { ...r, health: { ...health, [holder]: { ...health[holder], launchServices: r.next } } };
+}

package/dist/run/operator-state.d.ts

@@ -1,5 +1,5 @@
 import { type RunGraph } from "../graph/schema.js";
-import { type JournalEvent } from "./journal.js";
+import { type JournalEvent, type OwedFold } from "./journal.js";
 /** An evidence identity is a physical journal line, never a filtered row ordinal. */
 export interface EvidenceIdentity {
     source: string;
@@ -74,6 +74,15 @@ export interface OperatorSnapshot {
     };
     latestRunEnd?: EvidenceIdentity;
     approvedResumeRequired: boolean;
+    /** I2: CURRENT owed-check debt from the authority this observation supplied; "unknown" when absent or stale. */
+    debt: number | "unknown";
+    outstanding: readonly string[];
+}
+/** I2: foldOwedChecks over the complete effective journal, tagged with the journal basis it read. A result
+ * whose basis is not the observation's own is stale and counts as unknown debt, never as zero. */
+export interface OwedAuthority {
+    basis: string;
+    fold: OwedFold;
 }
 /** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
  * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
@@ -99,12 +108,20 @@ export declare class OperatorStateFold {
     private total;
     apply(record: OperatorRecord): void;
     private task;
-    snapshot({ graph, sequence, observedAt, readable, graphAvailability }?: {
+    /** A run-end is the latest lifecycle boundary: the only state whose headline consults owed-check debt. */
+    get ended(): boolean;
+    /** `daemonDead`: this run's lock holder was observed provably dead (lock.ts liveness). It is an observation,
+     * not a journal row, so it settles the projection only and the fold keeps no trace of it.
+     * `owed`/`basis` (I2): COMPLETE needs a known-empty debt computed over this very journal basis. */
+    snapshot({ graph, sequence, observedAt, readable, graphAvailability, daemonDead, owed, basis }?: {
         graph?: RunGraph;
         sequence?: number;
         observedAt?: number;
         readable?: boolean;
         graphAvailability?: OperatorSnapshot["graphAvailability"];
+        daemonDead?: boolean;
+        owed?: OwedAuthority;
+        basis?: string;
     }): OperatorSnapshot;
     private comparableTo;
 }
@@ -116,4 +133,7 @@ export declare function readOperatorState({ events, source, ...options }: {
     sequence?: number;
     observedAt?: number;
     readable?: boolean;
+    daemonDead?: boolean;
+    owed?: OwedAuthority;
+    basis?: string;
 }): OperatorSnapshot;

package/dist/run/operator-state.js

@@ -5,6 +5,9 @@ const bucketNames = ["failed", "human", "blocked", "pending"];
 const strings = (value) => Array.isArray(value) && value.every(v => typeof v === "string") ? [...value] : undefined;
 const identity = ({ source, line, id, generation }) => ({ source, line, id, generation });
 const emptyGates = () => Object.fromEntries(GATE_NAMES.map(g => [g, { state: "not-run" }]));
+/** I1: at a terminal boundary nothing will finish a queued or running cell, so it reads unknown (keeping the
+ * row that started it); a measured passed/failed cell is never touched. Returns copies. */
+const settled = (gates, settle = true) => Object.fromEntries(Object.entries(gates).map(([g, cell]) => [g, settle && (cell.state === "queued" || cell.state === "running") ? { ...cell, state: "unknown" } : { ...cell }]));
 /** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
  * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
 export const doneAuthors = (data) => strings(data.authors);
@@ -60,6 +63,10 @@ export class OperatorStateFold {
             };
             this.active = false;
             this.approved = false;
+            for (const t of this.tasks.values()) {
+                t.gates = settled(t.gates);
+                t.gateActivity = undefined;
+            }
             for (const key of bucketNames)
                 for (const id of this.end.buckets[key] ?? []) {
                     const task = this.task(id);
@@ -132,6 +139,8 @@ export class OperatorStateFold {
             t.gateActivity = undefined;
         if (["task-done", "merge", "task-failed", "task-human", "task-blocked"].includes(e.event))
             t.gateActivity = undefined;
+        if (["task-failed", "task-human", "task-blocked"].includes(e.event))
+            t.gates = settled(t.gates);
         const phaseGate = e.event === "phase-start" && typeof e.data.phase === "string"
             ? e.data.phase.startsWith("gate:") ? e.data.phase.slice(5) : e.data.phase === "judge" ? "acceptance" : e.data.phase === "review" ? "review" : undefined
             : undefined;
@@ -162,13 +171,18 @@ export class OperatorStateFold {
         }
         return t;
     }
-    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true, graphAvailability } = {}) {
+    /** A run-end is the latest lifecycle boundary: the only state whose headline consults owed-check debt. */
+    get ended() { return !!this.end && !this.active; }
+    /** `daemonDead`: this run's lock holder was observed provably dead (lock.ts liveness). It is an observation,
+     * not a journal row, so it settles the projection only and the fold keeps no trace of it.
+     * `owed`/`basis` (I2): COMPLETE needs a known-empty debt computed over this very journal basis. */
+    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true, graphAvailability, daemonDead = false, owed, basis } = {}) {
         const hash = graph && graphDefinitionHash(graph);
         const comparable = this.comparableTo(hash);
         const ids = comparable ? [...graph.tasks.map(t => t.id), ...[...this.tasks.keys()].filter(id => !graph.tasks.some(t => t.id === id))] : [...this.tasks.keys()];
         const tasks = ids.map(id => {
             const t = this.tasks.get(id) ?? { id, state: "unknown", merged: false, dispatches: 0, reviewRounds: 0, parks: 0, gates: emptyGates() };
-            return { ...t, title: comparable ? graph.tasks.find(g => g.id === id)?.title : undefined, gates: Object.fromEntries(Object.entries(t.gates).map(([g, cell]) => [g, { ...cell }])) };
+            return { ...t, title: comparable ? graph.tasks.find(g => g.id === id)?.title : undefined, gates: settled(t.gates, daemonDead), ...(daemonDead ? { gateActivity: undefined } : {}) };
         });
         const buckets = Object.fromEntries(bucketNames.map(k => [k, this.end?.buckets[k] === undefined ? undefined : [...this.end.buckets[k]]]));
         // A matching graph contributes planned tasks even when the journal has never named them.
@@ -179,9 +193,11 @@ export class OperatorStateFold {
         const unresolved = tasks.some(t => ["unknown", "failed", "human", "blocked", "pending", "running"].includes(t.state));
         const allPlannedMerged = comparable && merged === planned;
         const currentTip = this.active ? "pending" : this.tipFailed ? "failed" : this.end?.tip ?? "unknown";
+        const current = owed !== undefined && basis !== undefined && owed.basis === basis && owed.fold.known && typeof owed.fold.debt === "number";
+        const debt = current ? owed.fold.debt : "unknown";
         const green = readable && comparable && allPlannedMerged && !!this.start && !!this.end && !this.approved && !unresolved
             && (currentTip === "passed" || currentTip === "not required")
-            && bucketNames.every(k => buckets[k]?.length === 0);
+            && bucketNames.every(k => buckets[k]?.length === 0) && debt === 0;
         const lifecycle = !readable || !this.start ? "UNKNOWN" : this.active ? "RUNNING" : this.approved ? "APPROVED" : green ? "COMPLETE" : this.end ? "PARTIAL" : "PENDING";
         return {
             sequence, observedAt, lastEventAt: this.lastEventAt, firstEventAt: this.firstEventAt, resumes: this.resumes, escalations: this.escalations, lifecycle,
@@ -191,6 +207,7 @@ export class OperatorStateFold {
             planned, tasks, buckets,
             gatesRan: { passed: this.passed, total: this.total }, latestRunEnd: this.end?.evidence,
             approvedResumeRequired: this.approved,
+            debt, outstanding: current ? owed.fold.outstanding.map(o => `${o.taskId} ${o.gate}`) : [],
         };
     }
     comparableTo(hash) {

package/dist/run/title-environment.d.ts

@@ -0,0 +1,45 @@
+import { spawnSync } from "node:child_process";
+/**
+ * A2 (D-787): the process-title mode every shell child receives. On Darwin, children get one
+ * `--require` of the shipped title-preload.cjs appended to their NODE_OPTIONS, so a Node child's
+ * process.title writes stay in JavaScript instead of each checking in with LaunchServices (npm's own
+ * entry keeps its native, secret-hiding title — see title-preload.cts). Everything here fails OPEN to
+ * the native mode, which is exactly what children received before A2: another platform, the operator's
+ * opt-out, a missing artifact, inherited options the preflight cannot vouch for, or a preflight the
+ * runner's own node refused.
+ *
+ * `shell` (git.ts) applies this to the child it spawns and `runnerInputsHash` (cache.ts) hashes the same
+ * value, so a cached verdict or baseline is only ever answered by one produced under the identical mode
+ * and preload content.
+ */
+export declare const NATIVE_PROCESS_TITLE_ENV = "TICKMARKR_NATIVE_PROCESS_TITLE";
+/** The preflight's kill ceiling, never a predicted duration: one `node -e ""` start. */
+export declare const TITLE_PREFLIGHT_TIMEOUT_MS = 10000;
+export type TitleMode = "native" | "preload";
+export interface TitleEnvironment {
+    mode: TitleMode;
+    /** Content identity of the preload a child loads; null in native mode. */
+    identity: string | null;
+    /** The NODE_OPTIONS the child receives: the inherited value less any managed preload in native mode;
+     *  undefined when nothing is left, so the child's NODE_OPTIONS is unset rather than empty. */
+    nodeOptions: string | undefined;
+}
+interface TitleSeams {
+    platform: NodeJS.Platform;
+    preloadPath: string;
+    /** Undefined until a test sets it: the standard library binding is read at CALL time, so a suite that
+     *  mocks `node:child_process` without `spawnSync` still imports this module. */
+    probe?: typeof spawnSync;
+}
+export declare const setTitleEnvironmentForTests: (overrides: Partial<TitleSeams>) => void;
+export declare const resetTitleEnvironmentForTests: () => void;
+/** NODE_OPTIONS splits on spaces outside double quotes; inside them a backslash escapes `"` and `\`. */
+export declare const quoteNodeOption: (value: string) => string;
+/**
+ * The title mode a child spawned from `env` receives, and the NODE_OPTIONS that carries it. A nested shell
+ * inherits its parent's preload, so every mode first removes it: native gets none (the opt-out, options the
+ * probe cannot vouch for, a refusal or a missing artifact must hold in a nested shell too) and preload mode
+ * exactly one, this one.
+ */
+export declare function titleEnvironment(env: NodeJS.ProcessEnv): TitleEnvironment;
+export {};

package/dist/run/title-environment.js

@@ -0,0 +1,127 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * A2 (D-787): the process-title mode every shell child receives. On Darwin, children get one
+ * `--require` of the shipped title-preload.cjs appended to their NODE_OPTIONS, so a Node child's
+ * process.title writes stay in JavaScript instead of each checking in with LaunchServices (npm's own
+ * entry keeps its native, secret-hiding title — see title-preload.cts). Everything here fails OPEN to
+ * the native mode, which is exactly what children received before A2: another platform, the operator's
+ * opt-out, a missing artifact, inherited options the preflight cannot vouch for, or a preflight the
+ * runner's own node refused.
+ *
+ * `shell` (git.ts) applies this to the child it spawns and `runnerInputsHash` (cache.ts) hashes the same
+ * value, so a cached verdict or baseline is only ever answered by one produced under the identical mode
+ * and preload content.
+ */
+export const NATIVE_PROCESS_TITLE_ENV = "TICKMARKR_NATIVE_PROCESS_TITLE";
+/** The preflight's kill ceiling, never a predicted duration: one `node -e ""` start. */
+export const TITLE_PREFLIGHT_TIMEOUT_MS = 10_000;
+const shipped = () => ({
+    platform: process.platform,
+    preloadPath: fileURLToPath(new URL("./title-preload.cjs", import.meta.url)),
+});
+let seams = shipped();
+const preflights = new Map();
+export const setTitleEnvironmentForTests = (overrides) => {
+    seams = { ...seams, ...overrides };
+    preflights.clear();
+};
+export const resetTitleEnvironmentForTests = () => {
+    seams = shipped();
+    preflights.clear();
+};
+/** NODE_OPTIONS splits on spaces outside double quotes; inside them a backslash escapes `"` and `\`. */
+export const quoteNodeOption = (value) => `"${value.replace(/[\\"]/g, "\\$&")}"`;
+/** The one option this install adds: its preload, at an absolute path. */
+const preloadOption = () => `--require ${quoteNodeOption(seams.preloadPath)}`;
+/**
+ * D-827: does the runner's own node load this preload? Probed at most once per process per (node execPath,
+ * preload content identity, mode) — neither the operator's options nor a payload's cwd key it — so a
+ * refusal is sticky for that triple. The probe certifies only the context it reproduces: the preload alone,
+ * at its absolute path, run in the preload's own directory. `certifiable` sends every payload whose own
+ * options could change how that loads — the permission model, other code loaders, a policy or config file,
+ * any cwd-relative path — to native before any probe, so what reaches a payload loads the same from the
+ * probe's cwd and from the payload's (D-835: an absolute preload with none of those certifies every cwd).
+ * A bounded synchronous probe that never goes through `shell` or its spawn seam, so payload start timing,
+ * recorded spawn commands and the lease census see payloads only. A refusal — nonzero exit, signal, the ceiling, or a spawn error — selects native payloads without
+ * re-probing; a payload is never started twice to find out.
+ */
+function preflight(env, identity) {
+    const key = [process.execPath, identity, "preload"].join("\0");
+    let accepted = preflights.get(key);
+    if (accepted === undefined) {
+        try {
+            const probe = (seams.probe ?? spawnSync)(process.execPath, ["-e", ""], {
+                cwd: dirname(seams.preloadPath), env: { ...env, NODE_OPTIONS: preloadOption() },
+                stdio: "ignore", timeout: TITLE_PREFLIGHT_TIMEOUT_MS, killSignal: "SIGKILL",
+            });
+            accepted = probe.status === 0 && !probe.error;
+        }
+        catch {
+            accepted = false;
+        }
+        preflights.set(key, accepted);
+    }
+    return accepted;
+}
+/** NODE_OPTIONS as Node splits it: on spaces outside double quotes, each quoted segment unescaped. */
+const optionTokens = (options) => (options.match(/(?:[^\s"]|"(?:[^"\\]|\\.)*")+/g) ?? [])
+    .map((token) => token.replace(/"((?:[^"\\]|\\.)*)"/g, (_, quoted) => quoted.replace(/\\(.)/g, "$1")));
+/** Node accepts `_` for `-` in an option's name (`--experimental_permission` is Node 20's permission flag), so
+ * a name is classified in its hyphen spelling; the value after `=` is left as written. */
+const hyphenated = (token) => token.replace(/^--[^=]*/, (name) => name.replace(/_/g, "-"));
+/** Options that gate file access, load other code, or read a policy or config file. */
+const LOADING_OPTION = /^(?:-r|--(?:require|import|(?:experimental-)?loader|(?:experimental-)?permission[\w-]*|allow-[\w-]+|(?:experimental-)?policy[\w-]*|experimental-(?:default-)?config-file))(?:=|$)/;
+/** A path a cwd resolves: not absolute, and a directory step or a leading `.` or `~` (Node expands neither). */
+const cwdRelative = (value) => !value.startsWith("/") && /^[.~]|\//.test(value);
+/** Can the one canonical probe vouch for a payload under the operator's own options? No when any token
+ * loads, permits or resolves against the cwd — a separate value token or an `=` value alike. */
+const certifiable = (own) => optionTokens(own ?? "").every((token) => !LOADING_OPTION.test(hyphenated(token)) && !cwdRelative(/^-[^=]*=/.test(token) ? token.slice(token.indexOf("=") + 1) : token));
+/** One `--require "<path>"` option in the quoted form quoteNodeOption writes. */
+const QUOTED_REQUIRE = /(?:^|\s+)--require "((?:[^"\\]|\\.)*)"(?=\s|$)/g;
+/** A tickmarkr-managed preload, positively identified: this install's, or another install's shipped
+ * `dist/run/title-preload.cjs` whose package.json names it tickmarkr (a nested shell under another install).
+ * A user's own file of the same name is never one, so their hook keeps running in every mode. */
+const managed = (path) => {
+    if (path === seams.preloadPath)
+        return true;
+    if (!/[\\/]dist[\\/]run[\\/]title-preload\.cjs$/.test(path))
+        return false;
+    try {
+        return JSON.parse(readFileSync(join(dirname(path), "../../package.json"), "utf8")).name === "tickmarkr";
+    }
+    catch {
+        return false;
+    }
+};
+/** The operator's own options: every inherited managed preload removed; every other option byte-identical,
+ * and the value untouched without one. */
+const withoutManaged = (options) => {
+    const stripped = options?.replace(QUOTED_REQUIRE, (whole, quoted) => managed(quoted.replace(/\\(.)/g, "$1")) ? "" : whole);
+    return stripped === options ? options : stripped.trim() || undefined;
+};
+/**
+ * The title mode a child spawned from `env` receives, and the NODE_OPTIONS that carries it. A nested shell
+ * inherits its parent's preload, so every mode first removes it: native gets none (the opt-out, options the
+ * probe cannot vouch for, a refusal or a missing artifact must hold in a nested shell too) and preload mode
+ * exactly one, this one.
+ */
+export function titleEnvironment(env) {
+    const own = withoutManaged(env.NODE_OPTIONS);
+    const native = { mode: "native", identity: null, nodeOptions: own };
+    if (seams.platform !== "darwin" || env[NATIVE_PROCESS_TITLE_ENV] === "1" || !certifiable(own))
+        return native;
+    let identity;
+    try {
+        identity = createHash("sha256").update(readFileSync(seams.preloadPath)).digest("hex").slice(0, 16);
+    }
+    catch {
+        return native; // a missing or unreadable artifact keeps the native setter
+    }
+    if (!preflight(env, identity))
+        return native;
+    return { mode: "preload", identity, nodeOptions: [own?.trim(), preloadOption()].filter(Boolean).join(" ") };
+}

package/dist/run/title-preload.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// A2 (D-787): loaded through NODE_OPTIONS into Darwin shell children (title-environment.ts decides
+// when). Node's native process.title setter checks in with LaunchServices on every write, and test
+// runners write it per worker; a burst of those check-ins has restarted launchservicesd. Here a title
+// write stays in JavaScript, so `ps` keeps the original command line.
+//
+// npm is the exception: its entry sets the native title first thing so `ps` never shows secrets given
+// on its command line, and that hiding must survive. The entry is recognised by the script it runs —
+// `bin/npm-cli.js` / `bin/npx-cli.js` in every npm major's package layout, or corepack's npm/npx shim —
+// resolved through symlinks, since the `npm` command on PATH is a link to it.
+//
+// CommonJS (.cts → .cjs) so `--require` loads it in every supported Node, ESM package or not. It never
+// throws: a preload that throws kills the payload it was meant to protect.
+const node_fs_1 = require("node:fs");
+const NPM_ENTRY = /[\\/](?:bin[\\/]np[mx]-cli|corepack[\\/]dist[\\/]np[mx])\.js$/;
+// The script node was asked to run; an unresolvable one (`node -e`, a deleted file) is simply not npm.
+const entry = () => {
+    try {
+        return (0, node_fs_1.realpathSync)(process.argv[1]);
+    }
+    catch {
+        return process.argv[1] ?? "";
+    }
+};
+try {
+    const native = Object.getOwnPropertyDescriptor(process, "title");
+    if (native?.configurable && !NPM_ENTRY.test(entry())) {
+        let title = process.title;
+        Object.defineProperty(process, "title", {
+            configurable: true,
+            enumerable: native.enumerable,
+            get: () => title,
+            set: (value) => { title = String(value); },
+        });
+    }
+}
+catch { /* fail open: the native setter stays */ }

package/dist/run/title-preload.d.cts

@@ -0,0 +1 @@
+export {};