tickmarkr 2.6.2 → 2.6.4

package/dist/run/journal.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -6,9 +7,10 @@ import { z } from "zod";
 import { channelKey, shq, TokenUsageSchema } from "../adapters/types.js";
 import { graphDefinitionHash, stateDirName, taskContentDigest, taskDefinitionFingerprint, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES, TIERS } from "../graph/schema.js";
-import { channelRouteIdentity } from "../route/preference.js";
+import { channelRouteIdentity, modelProvider } from "../route/preference.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { DecisionEventSchema, trackJournalRows, } from "./protocol.js";
+import { PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER } from "./git.js";
 import { normalizeGateOutcome } from "./outcome.js";
 import { redactSecrets } from "./redact.js";
 export function phaseForGate(gate) {
@@ -713,21 +715,53 @@ export function normalizeGateFailure(details) {
 // operator approval is a new engagement, and nothing else resets the count. Resume re-measurements
 // are excluded because the interrupted attempt already bought the result they confirm.
 export const GATE_FINGERPRINT_CAP = 2;
+/** The invocation a gate row's receipt names — the identity of the execution that observed it. */
+export const receiptOrigin = (data) => {
+    const receipt = data.evidenceReceipt ?? (Array.isArray(data.evidenceReceipts) ? data.evidenceReceipts[0] : undefined);
+    const id = receipt && typeof receipt === "object" ? receipt.invocationId : undefined;
+    return typeof id === "string" && id ? `invocation:${id}` : undefined;
+};
+// OBS-1106 residual: occurrences are independent OBSERVATIONS, not rows. A journal replay
+// (`replayedFromAttempt`) and a verdict-cache hit (`reused`) re-state a measurement another row
+// already bought, so each resolves to that row's origin — its receipt's invocation when it carries
+// one, else the attempt (replay) or the newest observation on the same subject (cache) — and one
+// observation counts once however many copies the ledger holds, across resume. Only a fresh
+// execution mints a new origin.
 export function identicalGateFailures(events, taskId, gate, normalized) {
-    let n = 0;
-    for (const e of effectiveEvents(events)) { // OBS-1178: a refused or unsound approval is no new engagement
+    const counted = new Set();
+    const byAttempt = new Map();
+    const bySubject = new Map();
+    effectiveEvents(events).forEach((e, i) => {
         if (e.taskId !== taskId)
-            continue;
-        if (e.event === "task-approved")
-            n = 0;
-        else if (e.event === "gate-result" && e.data.gate === gate && e.data.pass === false
-            && e.data.replayMeasurement !== true
-            && typeof e.data.details === "string"
+            return;
+        if (e.event === "task-approved") {
+            counted.clear();
+            return;
+        }
+        if (e.event !== "gate-result" || e.data.gate !== gate)
+            return;
+        const commit = typeof e.data.commit === "string" ? e.data.commit : undefined;
+        const origin = typeof e.data.replayedFromAttempt === "number"
+            ? byAttempt.get(e.data.replayedFromAttempt) ?? receiptOrigin(e.data) ?? `attempt:${e.data.replayedFromAttempt}`
+            : e.data.reused === true
+                ? receiptOrigin(e.data) ?? (commit ? bySubject.get(commit) : undefined) ?? `reused:${commit ?? i}`
+                : receiptOrigin(e.data) ?? `row:${i}`;
+        if (typeof e.data.attempt === "number")
+            byAttempt.set(e.data.attempt, origin);
+        if (commit)
+            bySubject.set(commit, origin);
+        if (e.data.pass === false && e.data.replayMeasurement !== true && typeof e.data.details === "string"
             && normalizeGateFailure(e.data.details) === normalized)
-            n++;
-    }
-    return n;
-}
+            counted.add(origin);
+    });
+    return counted.size;
+}
+// OBS-1072 add.2: the controls a terminal would consume — OSC strings (ESC ] … BEL/ST), CSI sequences
+// (SGR included), other ESC sequences and stray C0 bytes but tab and newline. Applied only to the
+// human-facing excerpts a worker brief or a scope hint reads; the journal row, the receipt bytes and
+// the failure fingerprint keep the raw text.
+const TERMINAL_CONTROL_RE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[ -/]*[0-~]?|[\x00-\x08\x0b-\x1f\x7f]/g;
+export const readableExcerpt = (text) => text.replace(TERMINAL_CONTROL_RE, "");
 export function repairReachSinceApproval(events, taskId) {
     const repairs = [];
     for (const e of effectiveEvents(events)) { // OBS-1178: a refused or unsound approval resets no repair history
@@ -899,7 +933,7 @@ export function journaledFailureBrief(events, taskId) {
             rows = [];
         else if (e.event === "gate-result" && e.data.pass === false && e.data.skipped !== true
             && typeof e.data.details === "string")
-            rows.push(`${e.data.gate}: ${e.data.details}`);
+            rows.push(`${e.data.gate}: ${readableExcerpt(e.data.details)}`);
         else if (e.event === "delivery-readiness-failed" && typeof e.data.transcript === "string") {
             rows.push(`dispatch: delivery readiness failed after ${e.data.waitedMs}ms; pane transcript:\n${e.data.transcript}`);
         }
@@ -939,6 +973,17 @@ export function observedReviewFingerprints(finding) {
     return [...new Set([finding.fingerprint, ...observed])];
 }
 const reviewNoteIdentity = (note) => note.replace(LINE_REF_RE, "").replace(/\s+/g, " ").trim();
+/** OBS-1195: the anchor row a verdict's recorded settled comment spells, or undefined if malformed. */
+function settledAnchorRow(anchor) {
+    if (!anchor || typeof anchor !== "object")
+        return undefined;
+    const { path, line, body, disposition } = anchor;
+    if (typeof path !== "string" || !Number.isInteger(line) || typeof body !== "string")
+        return undefined;
+    if (disposition !== "deferred" && disposition !== "resolved")
+        return undefined;
+    return structuredFindings("review", `- ${path}:${line} — ${body}`).find((finding) => finding.class === "review:anchored");
+}
 function distinctReviewFinding(row) {
     const identity = JSON.stringify([reviewNoteIdentity(row.note), row.codeIdentity ?? null]);
     const symbol = `${row.symbol}#${createHash("sha256").update(identity).digest("hex").slice(0, 12)}`;
@@ -1042,6 +1087,23 @@ export function carryReviewFindings(priors, rows) {
  * after round re-seats ONE fingerprint, and a revised rationale replaces the prior rationale on that
  * row. N rounds of the same concern therefore carry the newest accepted explanation once, not N rows.
  */
+/** OBS-1151: this task's journaled judgments, newest first — subjects to compare a fresh ruling against,
+ * never verdicts to reuse. A row without a well-formed judgment (legacy, park, unparseable) is skipped. */
+export function priorJudgments(events, taskId) {
+    const out = [];
+    for (const e of events) {
+        const j = e.taskId === taskId && e.event === "gate-result" && e.data.gate === "acceptance" ? e.data.judgment : undefined;
+        if (!j || typeof j !== "object")
+            continue;
+        const { commit, judge, criteria } = j;
+        if (typeof commit !== "string" || !commit || !Array.isArray(criteria))
+            continue;
+        const rows = criteria.filter((c) => !!c && typeof c.id === "string" && typeof c.key === "string" && typeof c.met === "boolean"
+            && Array.isArray(c.paths) && c.paths.every((p) => typeof p === "string"));
+        out.unshift({ commit, ...(typeof judge === "string" ? { judge } : {}), criteria: rows });
+    }
+    return out;
+}
 export function outstandingReviewFindings(events, taskId) {
     let open = [];
     for (const e of effectiveEvents(events)) { // OBS-1178: only an effective review waive retires findings
@@ -1059,6 +1121,9 @@ export function outstandingReviewFindings(events, taskId) {
             continue;
         // A failed review can resolve one chain while re-raising another. Only observed, uniquely
         // matched spellings retire a chain; skipped/no-verdict rows were excluded above.
+        // OBS-1195: every parent chain this verdict resolved or explicitly deferred; an anchor bound to one
+        // retires whether it was carried in or restated by this same verdict.
+        const retiredParents = new Set();
         if (Array.isArray(e.data.resolved)) {
             const resolved = e.data.resolved;
             const settled = new Set(resolved.flatMap((id) => {
@@ -1066,8 +1131,45 @@ export function outstandingReviewFindings(events, taskId) {
                     && observedReviewFingerprints(finding).some((fp) => reviewFingerprintMatches(id, fp)));
                 return matches.length === 1 ? matches : [];
             }));
+            // OBS-1195: an anchor explicitly bound to a settled chain retires with it; unbound ones stay.
+            for (const id of [...settled].flatMap(observedReviewFingerprints))
+                retiredParents.add(id);
             open = open.filter((finding) => !settled.has(finding));
         }
+        // OBS-1195: a failed verdict that restates a bound anchor's parent ONLY as a deferral (its deferred
+        // entry echoes the prior's id and no material entry claims it) has explicitly deferred that parent,
+        // so the anchor retires. The parent chain itself keeps whatever the closure lists said of it.
+        // A material row's `reraisedFrom` is this verdict's claim only when its own reraised list names that
+        // id; a link an earlier verdict drew (carried metadata) is lineage and claims nothing here. Without a
+        // reraised list to check against, every link counts as a claim — fail closed.
+        const rows = findingRows(e, "review");
+        const reraisedHere = Array.isArray(e.data.reraised) ? e.data.reraised.filter((id) => typeof id === "string") : undefined;
+        const claimedByMaterial = new Set(rows.filter((row) => !isDeferredFinding(row) && row.reraisedFrom
+            && (reraisedHere === undefined || reraisedHere.some((id) => reviewFingerprintMatches(id, row.reraisedFrom)))).map((row) => row.reraisedFrom));
+        const deferredParents = rows.filter((row) => isDeferredFinding(row) && row.reraisedFrom && !claimedByMaterial.has(row.reraisedFrom))
+            .map((row) => row.reraisedFrom);
+        for (const finding of open) {
+            if (finding.class !== "review:material" || !observedReviewFingerprints(finding).some((fp) => deferredParents.includes(fp)))
+                continue;
+            for (const id of observedReviewFingerprints(finding))
+                retiredParents.add(id);
+        }
+        const boundToRetired = (finding) => finding.boundTo !== undefined && retiredParents.has(finding.boundTo);
+        open = open.filter((finding) => !boundToRetired(finding));
+        // OBS-1195: a later verdict that re-anchors a carried anchor to a deferred entry or a resolved prior
+        // settles that anchor explicitly. Only its own identity (path, symbol and note), uniquely matched,
+        // retires it; a bare path coincidence binds nothing.
+        if (Array.isArray(e.data.settledAnchors)) {
+            const retired = new Set(e.data.settledAnchors.flatMap((anchor) => {
+                const row = settledAnchorRow(anchor);
+                // Identity, not fingerprint: a collision-disambiguated anchor carries a `symbol#hash` spelling.
+                const matches = row ? open.filter((finding) => finding.class === "review:anchored" && finding.path === row.path
+                    && (finding.symbol === row.symbol || finding.symbol.startsWith(`${row.symbol}#`))
+                    && reviewNoteIdentity(finding.note) === reviewNoteIdentity(row.note)) : [];
+                return matches.length === 1 ? matches : [];
+            }));
+            open = open.filter((finding) => !retired.has(finding));
+        }
         if (e.data.pass !== false) {
             // a later review PASSED on this task: every finding it BLOCKED on is settled …
             open = open.filter(isDeferredFinding);
@@ -1077,11 +1179,39 @@ export function outstandingReviewFindings(events, taskId) {
             // the very next round — the same silent drop by a different door.
             open = carryReviewFindings(open, findingRows(e, "review").filter(isDeferredFinding));
         }
-        else
-            open = carryReviewFindings(open, findingRows(e, "review"));
+        else {
+            // OBS-1195: a repeated comment bound to a parent this verdict resolved or deferred is not re-seated.
+            open = carryReviewFindings(open, rows).filter((finding) => !boundToRetired(finding));
+        }
     }
     return open;
 }
+/**
+ * OBS-1019 add.2: each outstanding material chain with the number of valid review verdicts that
+ * re-raised it since the last review pass or review-gate waive. Only a chain's own observed spellings
+ * count, so an unrelated finding sharing a path never lengthens it.
+ */
+export function reraisedReviewChains(events, taskId) {
+    let verdicts = [];
+    for (const e of effectiveEvents(events)) {
+        if (e.taskId !== taskId)
+            continue;
+        if (e.event === "task-approved" && e.data.release === GATE_SATISFIED_RELEASE && e.data.gate === "review")
+            verdicts = [];
+        if (e.event !== "gate-result" || e.data.gate !== "review" || e.data.skipped === true)
+            continue;
+        if (e.data.unparseable === true || e.data.noVerdict === true || e.data.cause !== undefined)
+            continue;
+        verdicts = e.data.pass === false ? [...verdicts, e] : [];
+    }
+    return outstandingReviewFindings(events, taskId)
+        .filter((finding) => finding.class === "review:material")
+        .map((finding) => ({
+        finding,
+        reraises: verdicts.filter((e) => Array.isArray(e.data.reraised) && e.data.reraised
+            .some((id) => observedReviewFingerprints(finding).some((fp) => reviewFingerprintMatches(id, fp)))).length,
+    }));
+}
 /** The findings a funded repair must carry into the next dispatch, or undefined if none is pending. */
 export function pendingRepairFindings(events, taskId) {
     const e = decisionForNextDispatch(events, taskId, "repair-attempt");
@@ -1808,7 +1938,11 @@ export class Journal {
         const reducedData = event === "run-end"
             ? (() => {
                 const preservedRefs = [...preservedRefsByTask(priorEvents)].flatMap(([preservedTaskId, refs]) => refs.map(({ ref, diffCommand }) => ({ taskId: preservedTaskId, ref, diffCommand })));
-                return preservedRefs.length > 0 ? { ...inputData, preservedRefs } : inputData;
+                const reduced = preservedRefs.length > 0 ? { ...inputData, preservedRefs } : inputData;
+                // C1: the terminal record carries the owed-check fold as of this append, revalidated from
+                // each discharge's artifact — a reopened journal re-reduces, it never copies a prior total.
+                // Canonical (validated) rows are strict and keep their schema; the live producer is the tuple.
+                return decisionRow ? reduced : { ...reduced, owedChecks: foldOwedChecks(priorEvents, join(this.dir, "..", "..", "..")) };
             })()
             : event === "resume-restore" && rowTaskId && upheldFeedbackByTask(effectiveEvents(priorEvents)).has(rowTaskId)
                 ? {
@@ -2255,3 +2389,332 @@ export class Journal {
             .filter((row) => row && typeof row === "object" && "kind" in row && row.kind === "judge");
     }
 }
+// ── C1 (v2.6.4): owed checks ─────────────────────────────────────────────────────────────────────
+// A waiver accepts risk on ONE immutable subject. The same task-approved row that satisfies the gate
+// carries the obligation it leaves behind: run, task, gate, the exact base..head range and its
+// canonical subject, the acceptance criteria, the run-derived lifetime patch authors, the cause and
+// the evidence that would discharge it. The fold below is the only reader. It keeps every waiver as
+// accepted-risk history, subtracts a discharge only while its proof still revalidates, and answers
+// "unknown" — never zero — for a waiver without a well-formed obligation or a proof that no longer holds.
+export const OWED_CHECK_VERSION = 1;
+export const OWED_DISCHARGE_EVENT = "owed-check-discharged";
+const owedGit = (cwd, args, input) => execFileSync("git", args, {
+    cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, ...(input === undefined ? { stdio: ["ignore", "pipe", "pipe"] } : { input }),
+});
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+export const owedCriteria = (acceptance) => sha256(JSON.stringify(acceptance));
+/** The daemon's canonical gate subject for base..head (daemon.ts gateCommitSubject), byte for byte. */
+export const owedSubject = (cwd, base, head) => sha256(owedGit(cwd, ["log", "--reverse", "--format=%T%x00%an%x00%ae%x00%cn%x00%ce%x00%B%x1e", `${base}..${head}`]));
+// Ownership joins on --stable ids (whitespace-blind: a re-indented carry keeps its author, which only
+// widens exclusions). Range identity uses --verbatim: re-indented content is a different program.
+const patchIdOf = (cwd, diff, mode = "--stable") => owedGit(cwd, ["patch-id", mode], diff).trim().split(/\s+/)[0] || undefined;
+/** Ordered verbatim patch ids of the commits in base..head; an empty commit authored no patch. */
+export const rangePatches = (cwd, base, head) => owedGit(cwd, ["rev-list", "--reverse", `${base}..${head}`]).trim().split("\n").filter(Boolean)
+    .map((commit) => patchIdOf(cwd, owedGit(cwd, ["show", "--format=", "--binary", commit]), "--verbatim"))
+    .filter((id) => id !== undefined);
+/** Verbatim patch identity of the whole change base..head introduces. */
+export const rangePatch = (cwd, base, head) => patchIdOf(cwd, owedGit(cwd, ["diff", "--binary", base, head]), "--verbatim") ?? "empty";
+const COMMIT_ID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+/**
+ * `head` is the task's own recorded integration merge of the obligation's range — exactly. Its first
+ * parent is `mergeBase`; its second parent replays the waived history source tree for source tree from
+ * a base with the waived base's tree (a carry may mint new commit objects, never new content — and
+ * patch ids alone ignore where a hunk lands); its tree is git's own clean merge of the two (no
+ * resolution, no amend); and it introduced the same ordered verbatim patch series and total patch.
+ * Squashed, reordered, relocated, re-indented, reverted or conflict-resolved history fails one of
+ * 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) {
+    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;
+    try {
+        const parents = owedGit(cwd, ["show", "-s", "--format=%P", head]).trim().split(" ");
+        if (parents.length !== 2 || parents[0] !== mergeBase)
+            return false;
+        const [, carried] = parents;
+        const tree = (rev) => owedGit(cwd, ["rev-parse", `${rev}^{tree}`]).trim();
+        const trees = (from, to) => owedGit(cwd, ["log", "--reverse", "--format=%T", `${from}..${to}`]).trim();
+        if (tree(owedGit(cwd, ["merge-base", mergeBase, carried]).trim()) !== tree(o.base) || trees(mergeBase, carried) !== trees(o.base, o.head))
+            return false;
+        // A conflicted merge-tree exits 1 and throws; a clean one prints its tree first.
+        if (owedGit(cwd, ["merge-tree", "--write-tree", mergeBase, carried]).trim().split("\n")[0] !== tree(head))
+            return false;
+        const series = rangePatches(cwd, mergeBase, carried);
+        return series.length === o.patches.length && series.every((id, i) => id === o.patches[i])
+            && rangePatch(cwd, mergeBase, head) === o.patch;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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
+ * written without yielding. Recreation rows name SOURCE hashes, so ownership joins by stable patch
+ * identity across changed commit objects; a gate-only restore (resume-restore's seat, a recreation
+ * after work started) never becomes an author. Unreadable history names an unknown author.
+ */
+export function owedAuthors(events, taskId, cwd, base, head) {
+    const cache = new Map();
+    const patches = (commits) => {
+        const ids = new Set();
+        for (const commit of commits) {
+            if (!cache.has(commit))
+                cache.set(commit, patchIdOf(cwd, owedGit(cwd, ["show", "--format=", "--binary", commit])));
+            const id = cache.get(commit);
+            if (id)
+                ids.add(id);
+        }
+        return ids;
+    };
+    let current;
+    let previous;
+    let awaitingCarry = false;
+    const owners = new Map();
+    const preservedOwner = new Map();
+    const attribute = (ids, attempt) => {
+        for (const id of ids) {
+            if (attempt?.incoming.has(id))
+                continue;
+            const authors = owners.get(id) ?? new Set();
+            authors.add(preservedOwner.get(id) ?? attempt?.author ?? "unknown author (missing task-dispatch assignment)");
+            owners.set(id, authors);
+        }
+    };
+    try {
+        for (const row of events) {
+            if (row.taskId !== taskId)
+                continue;
+            const preserved = [row.data.ref, row.data.preservedRef].find((v) => typeof v === "string" && v.startsWith("refs/tickmarkr/preserved/"));
+            if (preserved) {
+                const [commit, subject, trailer] = owedGit(cwd, ["show", "-s", `--format=%H%n%s%n%(trailers:key=${PRESERVE_PRODUCER_TRAILER},valueonly)`, `${preserved}^{commit}`]).trim().split("\n");
+                if (commit && subject === PRESERVE_COMMIT_SUBJECT) {
+                    const owner = typeof row.data.producer === "string" ? row.data.producer
+                        : trailer?.trim().replace(/ attempt \d+$/, "") || "unknown author (legacy unattributed preservation)";
+                    for (const id of patches([commit])) {
+                        const prior = preservedOwner.get(id);
+                        if (prior === undefined || prior === "unknown" || prior.startsWith("unknown author"))
+                            preservedOwner.set(id, owner);
+                    }
+                }
+            }
+            if (row.event === "task-dispatch") {
+                previous = current;
+                const a = row.data.assignment;
+                current = { author: typeof a?.adapter === "string" && typeof a?.model === "string"
+                        ? `${a.adapter}:${a.model}` : "unknown author (missing task-dispatch assignment)", incoming: new Set() };
+                awaitingCarry = true;
+            }
+            else if (row.event === "worktree-recreation") {
+                const carried = patches(Array.isArray(row.data.carried) ? row.data.carried : []);
+                attribute(carried, awaitingCarry ? previous : current);
+                if (awaitingCarry && current)
+                    current.incoming = carried;
+                awaitingCarry = false;
+            }
+            else if (["worker-launch", "worker-result", "gate-result", "task-human"].includes(row.event)) {
+                awaitingCarry = false;
+            }
+        }
+        const subject = patches(owedGit(cwd, ["rev-list", "--reverse", `${base}..${head}`]).trim().split("\n").filter(Boolean));
+        attribute(subject, current);
+        return [...new Set([...subject].flatMap((id) => [...(owners.get(id) ?? [])]))].sort();
+    }
+    catch (error) {
+        return [`unknown author (${String(error).split("\n")[0]})`];
+    }
+}
+/**
+ * The obligation a waive of `gate` leaves on the task branch's current range. Synchronous on purpose:
+ * approve writes it into the waive row under the approval serialization without yielding, so a live
+ * daemon's boundary sees the same single append it always did. Anything not bound exactly — the
+ * waived row measured another subject, unreadable refs, unresolved authors, unreadable criteria — is
+ * recorded, never guessed, as known: false.
+ */
+export function captureOwedCheck(input) {
+    const { cwd, runId, taskId, gate, events } = input;
+    let base = "unknown", head = "unknown", subject = "unknown", patch = "unknown";
+    let patches = [];
+    let authors = [];
+    let unknownReason;
+    try {
+        head = owedGit(cwd, ["rev-parse", "--verify", `${input.taskRef}^{commit}`]).trim();
+        base = owedGit(cwd, ["merge-base", input.integrationRef, head]).trim();
+        subject = owedSubject(cwd, base, head);
+        const measured = [...events].reverse().find((e) => e.taskId === taskId && e.event === "gate-result" && e.data.gate === gate);
+        if (measured?.data.commit !== subject) {
+            throw new Error(`the waived ${gate} row measured ${String(measured?.data.commit ?? "no subject")}, not ${input.taskRef}'s range`);
+        }
+        patches = rangePatches(cwd, base, head);
+        patch = rangePatch(cwd, base, head);
+        authors = owedAuthors(events, taskId, cwd, base, head);
+        if (!authors.length || authors.some((a) => a.startsWith("unknown")))
+            throw new Error(`unresolved patch authors: ${authors.join(", ") || "none"}`);
+    }
+    catch (error) {
+        unknownReason = (error instanceof Error ? error.message : String(error)).split("\n")[0];
+    }
+    if (!Array.isArray(input.acceptance))
+        unknownReason ??= "task acceptance criteria unreadable";
+    const files = Array.isArray(input.files) && input.files.every((f) => typeof f === "string") ? input.files : undefined;
+    if (!files)
+        unknownReason ??= "task file scope unreadable";
+    if (!input.declared?.length)
+        unknownReason ??= "declared channels unreadable";
+    const criteria = Array.isArray(input.acceptance) ? owedCriteria(input.acceptance) : "unknown";
+    return {
+        version: OWED_CHECK_VERSION,
+        id: sha256(JSON.stringify([runId, taskId, gate, base, head, subject, criteria])).slice(0, 16),
+        runId, taskId, gate, base, head, subject, patch, patches, criteria, files: files ?? [], authors,
+        declared: [...(input.declared ?? [])].map(({ key, vendor }) => ({ key, vendor })), cause: input.cause,
+        evidence: `tickmarkr verify --base ${base} --task ${taskId} --record ${runId}: ${gate} passing on ${base}..${head} or on its recorded integration merge, reviewed outside the authors' vendors`,
+        disposition: "accepted-risk",
+        known: unknownReason === undefined,
+        ...(unknownReason === undefined ? {} : { unknownReason }),
+    };
+}
+/** A bound fact: a non-empty string that capture did not record as unknown. */
+const isBound = (v) => typeof v === "string" && v !== "" && !v.startsWith("unknown");
+/** Every required field present and well-typed; anything else is malformed evidence, never a known check. */
+const isOwedCheck = (value, taskId, gate) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const o = value;
+    return o.version === OWED_CHECK_VERSION && o.known === true && o.disposition === "accepted-risk"
+        && o.taskId === taskId && o.gate === gate && GATE_NAMES.includes(o.gate)
+        && [o.id, o.runId, o.taskId, o.base, o.head, o.subject, o.patch, o.criteria].every(isBound)
+        && typeof o.cause === "string" && typeof o.evidence === "string"
+        && Array.isArray(o.patches) && o.patches.every(isBound)
+        && Array.isArray(o.authors) && o.authors.length > 0 && o.authors.every(isBound)
+        && Array.isArray(o.files) && o.files.every((f) => typeof f === "string")
+        && Array.isArray(o.declared) && o.declared.length > 0 && o.declared.every(isChannelFact);
+};
+const providerOf = (fact) => modelProvider(fact.key.slice(fact.key.indexOf(":") + 1), fact.vendor);
+/** A resolved channel: an `adapter:model` key and a bound vendor — never an empty or placeholder claim. */
+const isChannelFact = (f) => typeof f === "object" && f !== null
+    && typeof f.key === "string" && /^[^:\s]+:\S+$/.test(f.key) && isBound(f.vendor);
+/**
+ * The trusted channel identities, key → vendors: what this repository's adapters declared under its config
+ * when the waive was written, recorded on the obligation by approve. Declaration, not doctor health — a
+ * later logout does not revoke a proof, but a seat not declared (or declared under another vendor) never
+ * resolved. Read from the row, the fold resolves identically in every process and every checkout.
+ */
+const declaredVendors = (o) => {
+    const vendors = new Map();
+    for (const c of o.declared)
+        vendors.set(c.key, (vendors.get(c.key) ?? new Set()).add(c.vendor));
+    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) {
+    const d = row.data;
+    if (row.taskId !== o.taskId)
+        return "discharge names another task";
+    if (d.criteria !== o.criteria)
+        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);
+    if (!exact && !integration)
+        return "discharge range does not bind the obligation";
+    let artifact;
+    try {
+        const bytes = readFileSync(String(d.artifactPath));
+        if (createHash("sha256").update(bytes).digest("hex") !== d.artifactSha256)
+            return "artifact hash mismatch";
+        artifact = JSON.parse(bytes.toString("utf8")) ?? {};
+    }
+    catch {
+        return "artifact unavailable";
+    }
+    if (artifact.head !== d.head || artifact.mergeBase !== d.mergeBase)
+        return "artifact measured another range";
+    if (artifact.green !== true)
+        return "artifact verdict is not green";
+    // The criteria the hash-bound evidence itself measured: the row's claim alone only repeats the obligation.
+    if (artifact.criteria !== o.criteria)
+        return "artifact measured other criteria";
+    // The scope the waived task declared, exactly: a wider allowlist (--files '*') is weakened evidence.
+    if (JSON.stringify(artifact.files) !== JSON.stringify(o.files))
+        return "artifact gated another file scope";
+    const rows = (Array.isArray(artifact.gateRows) ? artifact.gateRows : []);
+    const gateRow = rows.find((r) => r?.gate === o.gate && r.pass === true && r.meta?.skipped !== true);
+    if (!gateRow)
+        return `artifact holds no passing ${o.gate} row`;
+    if (o.gate === "review") {
+        const reviewer = d.reviewer;
+        const authors = Array.isArray(d.authorChannels) ? d.authorChannels : [];
+        // The row's reviewer must be the seat the hash-bound review row recorded — key, vendor and provider.
+        if (!isChannelFact(reviewer) || gateRow.meta?.reviewer !== reviewer.key || gateRow.meta.vendor !== reviewer.vendor
+            || gateRow.meta.provider !== providerOf(reviewer))
+            return "unresolved reviewer";
+        // ...and a channel the waive recorded as declared under exactly that vendor: agreement between the row
+        // and the artifact only repeats a claim, so identity and vendor resolve against the obligation's own.
+        const declared = declaredVendors(o);
+        const resolves = (f) => { const v = declared.get(f.key); return v?.size === 1 && v.has(f.vendor); };
+        // An author key stays excluded whatever vendor any row claims for it.
+        if (o.authors.includes(reviewer.key))
+            return "same-vendor reviewer (the reviewer is a recorded patch author)";
+        if (!resolves(reviewer))
+            return "unresolved reviewer (no declared channel with that identity and vendor)";
+        if (!authors.every(isChannelFact) || !o.authors.every((key) => authors.some((a) => a.key === key)))
+            return "unresolved author channel";
+        if (authors.some((a) => authors.some((b) => a.key === b.key && a.vendor !== b.vendor)))
+            return "unresolved author channel (inconsistent vendor claims)";
+        if (!authors.every(resolves))
+            return "unresolved author channel (no declared channel with that identity and vendor)";
+        if (authors.some((a) => a.vendor === reviewer.vendor || providerOf(a) === providerOf(reviewer)))
+            return "same-vendor reviewer";
+    }
+    return undefined;
+}
+/**
+ * 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.
+ */
+export function foldOwedChecks(events, cwd) {
+    try {
+        return foldOwedChecksOrThrow(events, cwd);
+    }
+    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) {
+    const accepted = new Map();
+    const discharged = new Set();
+    const unknown = [];
+    for (const e of effectiveEvents(events)) {
+        if (e.event === "task-approved" && e.data.release === GATE_SATISFIED_RELEASE) {
+            const o = e.data.obligation;
+            if (isOwedCheck(o, e.taskId, e.data.gate))
+                accepted.set(o.id, o);
+            else {
+                const recorded = typeof o === "object" && o !== null ? o.unknownReason : undefined;
+                unknown.push({ taskId: e.taskId, gate: String(e.data.gate), reason: o === undefined ? "legacy waiver without an owed-check obligation"
+                        : typeof recorded === "string" ? recorded : "malformed owed-check obligation" });
+            }
+        }
+        else if (e.event === OWED_DISCHARGE_EVENT) {
+            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";
+            });
+            const problem = ids.length ? problems.find((p) => p !== undefined) : "discharge names no obligation";
+            if (problem)
+                unknown.push({ taskId: e.taskId, reason: problem });
+            else
+                for (const id of ids)
+                    discharged.add(String(id));
+        }
+    }
+    const acceptedRisk = [...accepted.values()];
+    const outstanding = acceptedRisk.filter((o) => !discharged.has(o.id));
+    const known = unknown.length === 0;
+    return { known, debt: known ? outstanding.length : "unknown", outstanding, acceptedRisk, discharged: [...discharged], unknown };
+}

package/dist/run/lease.d.ts

@@ -33,7 +33,20 @@ export interface RepositoryLeaseOptions {
     signal?: AbortSignal;
     /** Called once per distinct holder the waiter is queued behind. */
     onWait?: (holder: RepositoryLeaseHolder) => void;
+    /** The token a descendant inherited; defaults to REPOSITORY_LEASE_TOKEN_ENV. */
+    inherited?: string;
 }
+/** OBS-880/1071: the file lease's token, exported to the holder's descendants for the span it is held
+ * so a nested runner (a gate's suite under `tickmarkr verify`, a mutation child inside a leased suite)
+ * reenters instead of waiting on its own ancestor. Deliberately NOT COMMAND_LEASE_TOKEN_ENV: the
+ * installed daemon clears and rewrites that in-process token, and a command-lease token never names
+ * this file. Environment text alone proves nothing: see `reentrantHolder`. */
+export declare const REPOSITORY_LEASE_TOKEN_ENV = "TICKMARKR_REPOSITORY_LEASE_TOKEN";
+/** Reentry is identity-bound: the inherited token must name the record at THIS repository's lease path
+ * right now, its holder must be alive, and that holder must be a strict ancestor of this process. A
+ * forged, stale (released or superseded), foreign-repository or command-lease token matches no record;
+ * an in-process sibling is not a descendant — each of those waits like any other runner. */
+export declare function reentrantHolder(path: string, inherited: string | undefined): Promise<RepositoryLeaseHolder | undefined>;
 export declare function repositoryLeasePath(cwd: string): Promise<string>;
 /** OBS-1057: dev+ino alone is not an identity across unlink/recreate — Linux hands the freed inode
  * number straight to the next file, so a stale observation of a dead or corrupt reservation matched