tickmarkr 2.8.6 → 2.8.8

package/dist/adapters/grok.js

@@ -115,16 +115,12 @@ export const grok = {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },
     parse: parseWorkerResult, // prompt.ts — last-valid-trailer, hard-wrap tolerant. No grok fork.
-    // v1.89 T1 / OBS-414: no capture exists, so none is invented. grok 0.2.93 has never been observed
-    // rendering a workspace/folder-trust prompt: it loads the operator's global Claude-Code-compat
-    // config rather than keeping a per-directory trust store, and no grok dispatch in any recorded run
-    // has stalled before launch (OBS-414's own sweep lists grok's gap as MCP suppression, not trust).
-    // FALSIFIER, and it is cheap: dispatch grok into a never-seen worktree and read the pane. One
-    // capture of a trust prompt replaces this with {fingerprint, key} — the capture is the only
-    // admissible evidence, and a guess here would press a key on whatever it happened to match.
+    // Queue row 215 (D-2118 add.1, D-2125): recorded Grok Build 1.0.62 and 1.0.67 directory-trust
+    // modal, quoted in GROK_TRUST_PANE. Enter is the measured acceptance key (y also accepts).
+    // Accepted residual: answering persists grok's trust for the main checkout root.
     trustDialog: {
-        kind: "none",
-        reason: "grok 0.2.93 keeps no per-directory trust store and no recorded pane shows it rendering a workspace-trust prompt; falsified by one capture from a fresh worktree",
+        fingerprint: "Grok Build may run or modify contents in this directory",
+        key: "Enter",
     },
     // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). Parses the model LIST only —
     // the auth banner on line 1 is ignored BY CONSTRUCTION (parseGrokModels anchors on the header).

package/dist/adapters/prompt.js

@@ -12,13 +12,21 @@ import { CAPACITY_RE } from "./types.js";
 // and the allowlist stays exactly as immutable during a run as it was before this text changed.
 export function buildTaskPrompt(task, feedback = "", nonce = "") {
     const list = (xs) => xs.map((x) => `- ${x}`).join("\n");
+    // Queue row 234 (D-2130 add.1, D-2131): only the worker brief carries the suite;
+    // the judge and the review brief keep the shared criterion text byte-equal.
+    const criteria = task.acceptance.map((item) => typeof item !== "string" && item.oracle === "test" && item.landing !== undefined
+        ? `${renderAcceptanceItem(item)} | suite: ${item.landing}`
+        : renderAcceptanceItem(item));
+    const suiteNote = task.acceptance.some((item) => typeof item !== "string" && item.oracle === "test" && item.landing !== undefined)
+        ? '\n\nFor test criteria with ` | suite: `, the test title is the text before the marker, and the test must pass in the named file.'
+        : "";
     return `You are an autonomous coding worker dispatched by tickmarkr into an isolated git worktree.
 
 ## Task ${task.id}: ${task.title}
 Goal: ${task.goal}
 
 ## Acceptance criteria (you will be judged against these, verbatim)
-${list(task.acceptance.map(renderAcceptanceItem))}
+${list(criteria)}${suiteNote}
 ${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(task.files)}\n` : ""}${task.context.length ? `\n## Context (read these first)\n${list(task.context)}\n` : ""}${task.outOfScope?.length ? `\n## Out of scope\nStay within the task’s declared bounds; do not pursue these items:\n${list(task.outOfScope)}\n` : ""}
 ## Rules
 - Work only inside the current directory (your isolated worktree). Never push. Never switch branches.

package/dist/adapters/types.d.ts

@@ -117,6 +117,7 @@ export declare const TRUST_DIALOG_BLANK_MESSAGE = "trust-dialog fingerprint must
 export declare const CLAUDE_TRUST_PANE: string;
 export declare const CODEX_TRUST_PANE: string;
 export declare const CURSOR_TRUST_PANE = "Workspace Trust Required\nTrust this folder?";
+export declare const GROK_TRUST_PANE: string;
 export declare const KIMI_TRUST_PANE: string;
 export declare const KIMI_TRUST_PANE_029: string;
 export declare const KIMI_MCP_TRUST_PANE: string;

package/dist/adapters/types.js

@@ -59,6 +59,16 @@ export const CODEX_TRUST_PANE = [
 ].join("\n");
 // v1.22 T5 / OBS-19, cursor-agent's per-worktree dialog.
 export const CURSOR_TRUST_PANE = "Workspace Trust Required\nTrust this folder?";
+// Queue row 215 (D-2118 add.1, D-2125): quoted from the recorded Grok Build 1.0.62 modal in
+// tests/fixtures/grok-trust/grok-1.0.62.screen.txt; 1.0.67 renders these same modal rows centered.
+export const GROK_TRUST_PANE = [
+    "Do you trust the contents of this directory?",
+    "/Users/…/repo",
+    "Grok Build may run or modify contents in this directory,",
+    "posing security risks.",
+    "Yes, proceed                 y",
+    "No, quit                     n",
+].join("\n");
 // Queue row 198, kimi 2.2.0's folder-trust modal on a fresh task worktree (run 1394 T3, read off the
 // Orca screen before its one Enter). The worktree path is shortened as above; every other row is as
 // rendered. 2.2.0 renamed the selected option, so the 0.29.0 fingerprint below never matched it and the
@@ -92,6 +102,7 @@ export const KIMI_MCP_TRUST_PANE = [
 ].join("\n");
 export const RECORDED_TRUST_PANES = [
     CLAUDE_TRUST_PANE, CODEX_TRUST_PANE, CURSOR_TRUST_PANE, KIMI_TRUST_PANE, KIMI_TRUST_PANE_029, KIMI_MCP_TRUST_PANE,
+    GROK_TRUST_PANE,
 ];
 // v1.89 T1 / OBS-414 round 4 — EXACT, not "leading bytes of a recorded line". Round 3 accepted any
 // prefix of a captured line, and every prefix of a trust prompt is also a substring of unrelated
@@ -111,6 +122,7 @@ export const APPROVED_TRUST_FINGERPRINTS = [
     "Workspace Trust Required", // cursor-agent, OBS-19
     "❯ Trust this folder", // kimi 0.29.0, OBS-358 + OBS-406 — the cursor glyph is load-bearing
     "❯ Trust and continue", // kimi 2.2.0, queue row 198 — the same gate with its option renamed
+    "Grok Build may run or modify contents in this directory", // queue row 215, D-2125
 ];
 const isApprovedFingerprint = (fingerprint) => APPROVED_TRUST_FINGERPRINTS.includes(fingerprint)
     && RECORDED_TRUST_PANES.some((pane) => pane.includes(fingerprint));

package/dist/cli/commands/compile.js

@@ -67,7 +67,7 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
         // Both modes reach the same pure compiler; --dry-run removes every state write below.
         const g = compileSource(sourcePath, values.type, cwd, // repo root: gsd stores context[0] repo-relative so workers resolve it inside their worktree
         (plan) => plan, { strict: values.strict });
-        const sourceFindings = sourceScopeFindings(g.tasks, cwd);
+        const sourceFindings = sourceScopeFindings(g.tasks, cwd, { failClosed: g.spec.source === "native" });
         const scopeLints = [
             ...collateralLints(g.tasks, cwd),
             ...sourceScopeLints(g.tasks, cwd, sourceFindings),

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,12 @@
+interface SkillDrift {
+    skill: string;
+    dir: string;
+    missing: string[];
+    modified: string[];
+}
+export declare function skillDrift(cwd: string): SkillDrift[];
+export declare const docsDrift: (cwd: string) => string[];
+export declare function installedAgentGuidance(cwd: string): string[];
 export type DetectedHost = "herdr" | "orca" | "subprocess";
 export declare function detectedHost(env?: NodeJS.ProcessEnv): DetectedHost;
 /** Test seam mirroring FleetIO: production callers omit it and get the process streams. */
@@ -6,3 +15,4 @@ export type InitIO = {
     output?: NodeJS.WriteStream;
 };
 export declare function init(argv: string[], cwd?: string, io?: InitIO): Promise<string>;
+export {};

package/dist/cli/commands/init.js

@@ -107,7 +107,11 @@ Outside multi-agent environments, run the loop directly.
 
 ### Version preflight
 
-Before \`tickmarkr compile\` or \`tickmarkr run\`: run \`tickmarkr version\`, read \`package.json\` version, and stop if the versions differ anywhere (major, minor, or patch); the binary and repository must agree on the entire version, so binary \`2.1.0\` versus repository \`2.1.1\` is a stop. Tell the operator to update or link the correct binary. Never proceed on hope — stale binaries silently skip daemon gates. Also verify no run is live in this repository before starting one: lead with this repository's \`.tickmarkr/graph.lock\`, read its holder pid, and treat it as live until \`kill -0 <pid>\` proves that holder dead. Never require a machine-wide process pattern to be empty: a lawful run in another repository — or the probing shell's own argv — can match. If you use a process probe as secondary evidence, exclude the probing process, resolve every candidate's own cwd (for example with \`lsof -a -p <pid> -d cwd\`), and count only candidates whose cwd is this repository root.
+Before \`tickmarkr compile\` or \`tickmarkr run\`: run \`tickmarkr version --check\` and stop on a non-zero exit. In the tickmarkr source repository (\`package.json\` named \`tickmarkr\`), stop if the versions differ anywhere (major, minor, or patch); the binary and repository must agree on the entire version, so binary \`2.1.0\` versus repository \`2.1.1\` is a stop. In a consumer repository, the check compares installed agent guidance with this binary's packaged block and skills, never the app's manifest version; refresh drifted guidance with \`tickmarkr init --agent --force\`. Tell the operator to update or link the correct binary when the source version differs. Never proceed on hope — stale binaries silently skip daemon gates. Also verify no run is live in this repository before starting one: lead with this repository's \`.tickmarkr/graph.lock\`, read its holder pid, and treat it as live until \`kill -0 <pid>\` proves that holder dead. Never require a machine-wide process pattern to be empty: a lawful run in another repository — or the probing shell's own argv — can match. If you use a process probe as secondary evidence, exclude the probing process, resolve every candidate's own cwd (for example with \`lsof -a -p <pid> -d cwd\`), and count only candidates whose cwd is this repository root.
+
+### Seat hygiene
+
+In a multi-tier session, the tiers clear each other at 50% context or more, after writing a handoff. A new spec or run is a mission boundary: write the handoff and clear before taking the next mission. Copy this duty into every brief and handoff. On a single-tier plain host, write your handoff and ask the operator to clear the session.
 
 ### Tip-verify-before-green
 
@@ -184,7 +188,7 @@ function skillFileList(root, prefix = "") {
 }
 // Drift is only computed for skills that ARE installed. A skill never installed is not drift — `--agent`
 // installs it and says so, and nagging about it would bury the case this exists for.
-function skillDrift(cwd) {
+export function skillDrift(cwd) {
     const drifted = [];
     for (const { skillsDir } of hostTargets(cwd)) {
         for (const skill of AGENT_SKILLS) {
@@ -215,7 +219,7 @@ function skillDrift(cwd) {
 // superseded preflight rules (patch-version drift tolerated, a machine-wide process match required)
 // through the very release that fixed the tracked copy, and a consultation was launched under the stale
 // text with nobody able to see it. Same rule as skillDrift: a doc that was never written is not drift.
-const docsDrift = (cwd) => hostTargets(cwd).map(({ docPath }) => docPath).filter((docPath) => {
+export const docsDrift = (cwd) => hostTargets(cwd).map(({ docPath }) => docPath).filter((docPath) => {
     if (!existsSync(docPath))
         return false;
     const current = readFileSync(docPath, "utf8");
@@ -227,6 +231,12 @@ const docsDrift = (cwd) => hostTargets(cwd).map(({ docPath }) => docPath).filter
         return true; // a truncated block is stale by definition
     return current.slice(begin, end + DOCS_END.length) !== AGENT_DOCS.trimEnd();
 });
+export function installedAgentGuidance(cwd) {
+    return hostTargets(cwd).flatMap(({ skillsDir, docPath }) => [
+        ...AGENT_SKILLS.map((skill) => join(skillsDir, skill, "SKILL.md")).filter((path) => existsSync(path)),
+        ...(existsSync(docPath) && readFileSync(docPath, "utf8").includes(DOCS_BEGIN) ? [docPath] : []),
+    ]);
+}
 const describeDrift = (d) => [
     d.missing.length ? `missing ${d.missing.join(", ")}` : "",
     d.modified.length ? `modified ${d.modified.join(", ")}` : "",

package/dist/cli/commands/report.js

@@ -13,6 +13,7 @@ import { assignmentChannel, buildOperatorRecord, formatChannelMoney, formatChann
 import { cellsOf, cellSummary } from "../../route/profile.js";
 import { effectiveEvents, fatalRunEndCause, foldOwedChecks, Journal, loadRoutingProfile, OWED_DISCHARGE_EVENT, } from "../../run/journal.js";
 import { baselineProvenanceOf, fingerprintsOf, forgivenFingerprints, forgivenGateRow, formatBaselineProvenance, formatFingerprints, formatForgiven, formatTipProof, runEndTipProof, } from "../../run/daemon.js";
+import { normalizeGateOutcome } from "../../run/outcome.js";
 import { formatSpan, WALL_PRIORITY, WALL_PRIORITY_TEXT, wallBudget, wallBudgetFacts } from "../../run/wall-budget.js";
 import { deriveRunCockpitData } from "../../tui/cockpit/derive.js";
 import { cellWidth, wrapCells } from "../../tui/cockpit/width.js";
@@ -382,12 +383,15 @@ const verificationOf = (runId, events) => {
         return "failed";
     if (tip?.state !== "pass")
         return "absent";
-    // A cached green is a verified green of an EARLIER tip (daemon.ts verifyIntegrationTipCached
-    // stamps `cached` on every gate it replays), so the record names it instead of folding it into a
-    // plain pass. Still no second window: the cockpit reports "pass" only when the closed cycle
-    // carried verdicts, so the last `tip-verify` IN THAT CYCLE is the one it passed on.
-    const last = [...cycle].reverse().find((e) => e.event === "tip-verify");
-    return last?.data.cached === true ? "cached" : "passed";
+    // Queue 35 (D-2134 R6): the same per-gate proof names both the lead and verification line.
+    const proof = runEndTipProof(cycle);
+    if (proof.gates?.length) {
+        if (proof.gates.every(({ kind }) => kind === "reused"))
+            return "cached";
+        if (proof.gates.some(({ kind }) => kind === "reused"))
+            return "mixed";
+    }
+    return "passed";
 };
 // Absent is a state to render, never a zero to invent — and no reading here calls a run green.
 // NOTE: every reading below is byte-pinned by tests/fixtures/brand-surfaces/report-md.md — the
@@ -396,6 +400,7 @@ const verificationOf = (runId, events) => {
 const VERIFICATION_READING = {
     passed: "passed — tickmarkr verified this run's integration tip",
     cached: "cached — carried forward from an earlier verified tip, not re-run for this one",
+    mixed: "mixed — some tip gates ran fresh and others were carried forward",
     failed: "FAILED — the run did not verify its own tip",
     absent: "absent — no tip verification recorded: neither passed nor failed",
 };
@@ -406,9 +411,9 @@ function forgivenLines(events) {
 function verificationReading(runId, events) {
     const state = verificationOf(runId, events);
     const proof = runEndTipProof(closedCycle(events));
-    if ((state === "passed" || state === "cached") && proof.gates?.length) {
-        const allCarried = proof.gates.every(({ kind }) => kind === "reused");
-        return `${allCarried ? "cached" : "passed"} — ${formatTipProof(proof)}`;
+    if ((state === "passed" || state === "cached" || state === "mixed") && proof.gates?.length) {
+        // Queue 35 (D-2134 R6): mixed describes the lead's provenance; per-gate details retain it here.
+        return `${state === "mixed" ? "passed" : state} — ${formatTipProof(proof)}`;
     }
     return VERIFICATION_READING[state];
 }
@@ -520,9 +525,13 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = [], suit
         lines.push("- **tickmarks:**");
         if (gates.length) {
             for (const g of gates) {
-                // T11: a declined gate never ran — report it as declined, never as a pass.
-                let pass = gateDeclined(g.data) ? "declined" : g.data.pass === true ? "pass" : g.data.pass === false ? "fail" : EM;
+                // Queue 35 (D-2134 R6): only held changes the existing tickmark vocabulary.
+                let pass = normalizeGateOutcome(g.data).kind === "held" ? "held"
+                    : gateDeclined(g.data) ? "declined" : g.data.pass === true ? "pass" : g.data.pass === false ? "fail" : EM;
                 const gate = typeof g.data.gate === "string" ? g.data.gate : EM;
+                if (gate === "acceptance" && g.data.judgeIndependent === false) {
+                    pass += " (independence not established)";
+                }
                 if (gate === "review" && pass === "pass") {
                     const reviewer = reviewerIdentity(g.data);
                     const before = events.slice(0, events.indexOf(g) + 1).reverse()
@@ -616,7 +625,7 @@ function textReport(runId, events, rows, cwd, suite) {
     // T11: gates that declined never ran — out of both the pass count and the rate base.
     const declinedCount = gateResults.filter((e) => gateDeclined(e.data)).length;
     const gateRan = gateResults.length - declinedCount;
-    const gatePass = gateResults.filter((e) => e.data.pass && !gateDeclined(e.data)).length;
+    const gatePass = gateResults.filter((e) => normalizeGateOutcome(e.data).kind === "passed" && !gateDeclined(e.data)).length;
     const escalations = events.filter((e) => e.event === "escalation").length;
     const consults = events.filter((e) => e.event === "consult-verdict").length;
     const failovers = events.filter((e) => e.event === "quota-failover").length;

package/dist/cli/commands/status.js

@@ -968,6 +968,16 @@ const recordedTasks = (graph, rows) => graph.tasks.filter((task) => {
         || row.parkKind !== undefined);
 });
 const recordedDone = (tasks, rows) => tasks.filter((task) => graphTaskStatus(rows.get(task.id)?.state, task.status) === "done").length;
+const judgeIndependenceNotes = (events) => {
+    // Queue row 34(a) (D-2134 R5): only the newest acceptance row owns this note.
+    const acceptance = new Map();
+    for (const event of events) {
+        if (event.taskId && event.event === "gate-result" && event.data.gate === "acceptance")
+            acceptance.set(event.taskId, event);
+    }
+    return [...acceptance].filter(([, event]) => event.data.judgeIndependent === false)
+        .map(([id]) => `${sanitizeTaskText(id)} judge not independent`);
+};
 const renderFrame = (cwd, 
 // No default: the version is the binary's, resolved once by its caller, and a frame that had to
 // invent one would be naming a version nobody can check.
@@ -976,6 +986,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const record = readRunRecord(cwd, g, namedRunId);
     const runId = record?.runId;
     const events = record?.events ?? [];
+    const judgeNotes = judgeIndependenceNotes(events);
     const runLine = runId && record ? runStatusLine(cwd, runId, events) : null;
     // The header and every live-phase consumer share this exact process reading. Proved death retires
     // stale phase markers; unknown identity deliberately does not, preserving pre-identity journals.
@@ -1171,7 +1182,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         // At its machine width and wider the plain print keeps each machine row whole — one row per task and
         // its evidence line after it, which consumers parse. A configured width narrower than that holds for
         // EVERY row: one that overflows wraps beneath its own indent, its identity kept on the first.
-        const body = [header, legendLine, `  ${supervisionText(supervision, divider)}`, ...rows];
+        const body = [header, legendLine, `  ${supervisionText(supervision, divider)}`, ...rows, ...judgeNotes.map((note) => `  ${note}`)];
         const wrapRow = (line) => wrapCells(line, width, { continuationPrefix: `${/^ */u.exec(line)[0]}  ` });
         return {
             content: [
@@ -1383,6 +1394,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             "",
             ...tableRows(),
             ...recoverySection,
+            ...judgeNotes.flatMap((note) => wrapCells(`    ${note}`, boardColumns, { continuationPrefix: "      " })),
             gatesLegend,
             "",
             rule(boardColumns),
@@ -1436,7 +1448,7 @@ const oneLine = (cwd, namedRunId) => {
     // A fatal run-end leads right after the run id: no completion fraction or verify state reads first.
     const crash = fatalRunEndCause(events);
     return sanitizeTaskText([
-        record.runId, ...(crash ? [`run crashed — ${crash}`] : []), ...claims, firstPassText(endToEndFirstPass(events)), wallText(events), needsYouText(events, currentOwed(events, cwd)),
+        record.runId, ...(crash ? [`run crashed — ${crash}`] : []), ...claims, firstPassText(endToEndFirstPass(events)), wallText(events), needsYouText(events, currentOwed(events, cwd)), ...judgeIndependenceNotes(events),
     ].join(" · "));
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {

package/dist/cli/commands/verify.js

@@ -370,8 +370,8 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
     }
     // Baseline: --baseline file > cached capture for this merge-base > fresh capture on a detached
     // temp worktree of the merge-base (so pre-existing failures on base are forgiven, exactly as a run).
-    // ALL verify state (cache, base worktree, artifacts) lives OUTSIDE the repo: verify gates the repo
-    // root itself, so any file it wrote there would trip the battery's own dirty-worktree refusal.
+    // Queue row 31 / D-2134: gate-time state lives outside the repo; a validated discharge's durable
+    // proof is copied into its run only after the battery's final dirty-worktree check.
     // ponytail: tmpdir means the baseline cache dies on reboot/cleanup — worst case is one re-capture.
     const stateDir = verifyStateDir(cwd);
     mkdirSync(stateDir, { recursive: true });
@@ -600,6 +600,7 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
         console.error(`verify: evidence capture failed for ${artifactPath}`);
     }
     const review = reviewRows.at(-1);
+    let recordedArtifactPath = artifactPath;
     // C1: ONE discharge row names what the fold re-reads — the artifact by hash, the range mapping, the
     // criteria and each resolved channel — and it is appended only when the fold, the single decider,
     // already accepts it: verify never writes a proof that would turn known debt into unknown debt.
@@ -624,8 +625,31 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
             dischargeRefusal = "the results artifact is unavailable";
         else if (!candidate.known || !owed.every((o) => candidate.discharged.includes(o.id)))
             dischargeRefusal = candidate.unknown.at(-1)?.reason ?? "the proof does not discharge the check";
-        else
-            recordJournal.append(OWED_DISCHARGE_EVENT, values.task, data);
+        else {
+            // Queue row 31 / D-2134: validate before writing under the run, then retain the exact bytes.
+            // Exclusive creation accepts an identical existing proof, never overwrites different bytes.
+            const relativePath = join("discharges", `${artifactSha256}.json`);
+            const durablePath = join(recordJournal.dir, relativePath);
+            try {
+                mkdirSync(dirname(durablePath), { recursive: true });
+                try {
+                    writeFileSync(durablePath, artifactBytes, { flag: "wx" });
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST")
+                        throw error;
+                    if (!readFileSync(durablePath).equals(artifactBytes))
+                        throw new Error("existing durable proof has different bytes");
+                }
+            }
+            catch {
+                dischargeRefusal = "durable results artifact unavailable or has different bytes";
+            }
+            if (!dischargeRefusal) {
+                recordedArtifactPath = relativePath;
+                recordJournal.append(OWED_DISCHARGE_EVENT, values.task, { ...data, artifactPath: recordedArtifactPath });
+            }
+        }
     }
     const owedAfter = recordJournal ? foldOwedChecks(recordJournal.read(), cwd) : undefined;
     const code = green && !dischargeRefusal ? 0 : 2;
@@ -633,7 +657,7 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
         ? [...(dischargeRefusal ? [`verify --record refused discharge: ${dischargeRefusal}`] : []), debtLine(owedAfter)] : [];
     if (recordJournal && review) {
         recordJournal.append("review-leg2", values.task ?? "VERIFY", {
-            base: baseTip, head, mergeBase, author: channelKey(author), artifactPath, artifactSha256, artifactAvailability,
+            base: baseTip, head, mergeBase, author: channelKey(author), artifactPath: recordedArtifactPath, artifactSha256, artifactAvailability,
             ...review,
         });
     }

package/dist/cli/commands/version.d.ts

@@ -1,2 +1,2 @@
 export declare function distFingerprint(dir?: string): string;
-export declare function version(argv?: string[], dir?: string): Promise<string>;
+export declare function version(argv?: string[], dir?: string, cwd?: string): Promise<string>;

package/dist/cli/commands/version.js

@@ -23,7 +23,41 @@ export function distFingerprint(dir = distDir) {
         hash.update(relative(dir, file)).update("\0").update(readFileSync(file)).update("\0");
     return hash.digest("hex");
 }
-export async function version(argv = [], dir = distDir) {
+export async function version(argv = [], dir = distDir, cwd = process.cwd()) {
     const { version: v } = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return argv.includes("--dist") ? `${v} dist:${resolve(dir)} fingerprint:${distFingerprint(dir)}` : v;
+    const stamp = argv.includes("--dist") ? `${v} dist:${resolve(dir)} fingerprint:${distFingerprint(dir)}` : v;
+    if (!argv.includes("--check"))
+        return stamp;
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    }
+    catch { /* no source manifest — consumer guidance check */ }
+    if (manifest?.name === "tickmarkr") {
+        const repoVersion = manifest.version ?? "missing";
+        const equal = v === repoVersion;
+        const out = `tickmarkr binary ${stamp}: compared tickmarkr source repository package.json version ${repoVersion} — ${equal ? "entire version matches" : "versions differ; update or link the correct binary"}`;
+        if (!equal)
+            throw new Error(out);
+        return out;
+    }
+    const { docsDrift, installedAgentGuidance, skillDrift } = await import("./init.js");
+    const installed = installedAgentGuidance(cwd);
+    if (!installed.length)
+        return `tickmarkr binary ${stamp}: no installed agent guidance to compare`;
+    const drift = [
+        ...skillDrift(cwd).flatMap(({ dir: skillDir, missing, modified }) => [
+            ...missing.map((file) => `missing ${relative(cwd, join(skillDir, file))}`),
+            ...modified.map((file) => `modified ${relative(cwd, join(skillDir, file))}`),
+        ]),
+        ...docsDrift(cwd).map((file) => `stale agent-docs block in ${relative(cwd, file)}`),
+    ];
+    const out = [
+        `tickmarkr binary ${stamp}: compared installed agent guidance with this binary's packaged block and skills:`,
+        ...installed.map((file) => `  ${relative(cwd, file)}`),
+        ...(drift.length ? [...drift, "refresh: tickmarkr init --agent --force"] : ["installed guidance matches"]),
+    ].join("\n");
+    if (drift.length)
+        throw new Error(out);
+    return out;
 }

package/dist/cli/help.d.ts

@@ -195,6 +195,7 @@ export declare const COMMAND_HELP: {
         description: string;
         options: {
             "--dist": string;
+            "--check": string;
         };
         examples: string[];
     };

package/dist/cli/help.js

@@ -169,9 +169,12 @@ export const COMMAND_HELP = {
         ],
     },
     version: {
-        usage: "version [--dist]", description: "Print the installed package version. Top-level aliases: --version and -v.",
-        options: { "--dist": "Also print the resolved build directory and distribution fingerprint." },
-        examples: ["version", "version --dist"],
+        usage: "version [--dist] [--check]", description: "Print the installed package version. Top-level aliases: --version and -v.",
+        options: {
+            "--dist": "Also print the resolved build directory and distribution fingerprint.",
+            "--check": "Compare the entire source version when package.json is named tickmarkr; otherwise check installed agent guidance against this binary. Exit non-zero on drift; no installed guidance exits zero.",
+        },
+        examples: ["version", "version --dist", "version --check"],
     },
     verify: {
         usage: "verify [--base <ref>] [--criteria <file> | --task <id>] [options]",

package/dist/compile/collateral.d.ts

@@ -55,7 +55,9 @@ export interface SourceScopeFinding {
     paths: string[];
 }
 /** Structured OBS-76 findings shared by human rendering and native compile enforcement. */
-export declare function sourceScopeFindings(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string): SourceScopeFinding[];
+export declare function sourceScopeFindings(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string, options?: {
+    failClosed?: boolean;
+}): SourceScopeFinding[];
 /** Human display is derived from the structured finding; no enforcement path parses this text. */
 export declare function renderSourceScopeFinding(finding: SourceScopeFinding): string;
 /**

package/dist/compile/collateral.js

@@ -3,18 +3,15 @@ import { extname, join, posix, relative } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { criticalPathHits, DEFAULT_CONFIG, DEFAULT_REVIEW_CRITICAL_PATHS, effectiveReviewPolicy, loadConfig, } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
+import { CompileError } from "./common.js";
 // Advisory scan (OBS-12/13/14/21, OBS-76). NEVER expands files[] or fails compile — a warning the
 // author acts on. Plain-text (no AST), capped + sorted for DISPLAY only.
 // OBS-547: the collateral prediction is no longer plan-time-only. The daemon computes one full
 // (uncapped) map per run and hands each task's slice to its scope gate, which classifies a red
 // against it — the prediction never causes a refusal, it only says whether a red the gate already
 // found was foreseeable (authoring defect) or not (chargeable quality failure).
-/** Max files walked per root (sorted walk; rest ignored). */
-const MAX_WALK_FILES = 400;
 /** Max collateral test paths listed per task. */
 const MAX_HITS_PER_TASK = 20;
-/** Skip giant fixtures / snapshots. */
-const MAX_READ_BYTES = 512 * 1024;
 const EXPORT_MANIFEST_TEST = "tests/repo/export-manifest.test.ts";
 const SRC_EXT = /\.(ts|tsx|js|jsx|mts|cts)$/;
 const CODE_EXT = /\.(ts|tsx|js|jsx|mts|cts)$/;
@@ -33,8 +30,6 @@ function walkCode(repoRoot, subdir) {
     const root = join(repoRoot, subdir);
     const out = [];
     const walk = (dir) => {
-        if (out.length >= MAX_WALK_FILES)
-            return;
         let entries;
         try {
             entries = readdirSync(dir, { withFileTypes: true });
@@ -45,8 +40,6 @@ function walkCode(repoRoot, subdir) {
         // deterministic order
         entries.sort((a, b) => a.name.localeCompare(b.name));
         for (const e of entries) {
-            if (out.length >= MAX_WALK_FILES)
-                return;
             if (e.name === "node_modules" || e.name === ".git" || e.name.startsWith("."))
                 continue;
             const full = join(dir, e.name);
@@ -78,22 +71,21 @@ function mentions(content, needles) {
     return false;
 }
 // cache file bodies (one read per path)
-function makeReader(repoRoot) {
+function makeReader(repoRoot, failClosed = false) {
     const body = new Map();
     return (rel) => {
         if (body.has(rel))
             return body.get(rel);
         try {
-            const st = statSync(join(repoRoot, rel));
-            if (st.size > MAX_READ_BYTES) {
-                body.set(rel, null);
-                return null;
-            }
             const text = readFileSync(join(repoRoot, rel), "utf8");
             body.set(rel, text);
             return text;
         }
         catch {
+            if (failClosed) {
+                throw new CompileError(`${rel} is unreadable, so the source-scope scan is incomplete — restore read access `
+                    + `or remove the path and recompile (queue row 27, D-2134).`);
+            }
             body.set(rel, null);
             return null;
         }
@@ -502,7 +494,7 @@ export function newDirectoryLints(tasks, repoRoot) {
     return lines;
 }
 /** Structured OBS-76 findings shared by human rendering and native compile enforcement. */
-export function sourceScopeFindings(tasks, repoRoot) {
+export function sourceScopeFindings(tasks, repoRoot, options = {}) {
     const perTask = tasks
         .map((t) => ({ t, needles: criteriaSymbols(t.acceptance) }))
         .filter((x) => x.needles.length);
@@ -511,7 +503,7 @@ export function sourceScopeFindings(tasks, repoRoot) {
     const srcFiles = walkCode(repoRoot, "src");
     if (!srcFiles.length)
         return [];
-    const read = makeReader(repoRoot);
+    const read = makeReader(repoRoot, options.failClosed);
     const findings = [];
     for (const { t, needles } of perTask) {
         // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.

package/dist/compile/native.js

@@ -272,6 +272,11 @@ function testsAtHead(root) {
     if (cached)
         return cached;
     const grep = gitSync(root, ["grep", "-I", "-n", "-e", "", "HEAD", "--", "tests/*.test.ts", "tests/**/*.test.ts"]);
+    if (grep.error || grep.signal || grep.status === null) {
+        const reason = grep.error?.message ?? (grep.signal ? `signal ${grep.signal}` : "no exit status");
+        throw new CompileError(`cannot complete the test corpus read (git grep HEAD tests) in ${root}: ${reason} — `
+            + `restore the corpus read and recompile (queue row 27, D-2134).`);
+    }
     if (grep.status !== 0 || typeof grep.stdout !== "string") {
         headTestCache.set(root, []);
         return [];
@@ -387,8 +392,8 @@ function criterionScopeFinding(task, text, criterion, id, tests) {
 // OBS-898: the fence lint's corpus is listed ONCE per compile by git (tracked plus untracked-not-ignored,
 // the same set a checkout walk sees minus the ignored trees) and filtered per task. The walk it replaces
 // descended every dot-directory (.tickmarkr/runs alone held 3 799 files here) once PER TASK, so a
-// 20-task spec compiled in seconds and the committed-spec corpus test timed out. Fail-open like
-// testsAtHead: no git answer means no corpus, and the lint stays quiet rather than wrong.
+// 20-task spec compiled in seconds and the committed-spec corpus test timed out.
+// Queue row 27 (D-2134): this advisory listing keeps its empty answer on git failure.
 function repoFileList(root) {
     const ls = gitSync(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
     if (ls.status !== 0 || typeof ls.stdout !== "string")

package/dist/drivers/subprocess.js

@@ -49,7 +49,7 @@ export class SubprocessDriver {
     n = 0;
     async slot(cwd, name) {
         const id = `sp-${++this.n}`;
-        this.slots.set(id, { buf: "", exited: false });
+        this.slots.set(id, { buf: "", receivedBytes: 0, exited: false });
         return { id, name, cwd };
     }
     state(slot) {
@@ -72,8 +72,13 @@ export class SubprocessDriver {
             detached: true,
         });
         s.proc = p;
-        p.stdout.on("data", (d) => (s.buf = (s.buf + d).slice(-MAX_BUF)));
-        p.stderr.on("data", (d) => (s.buf = (s.buf + d).slice(-MAX_BUF)));
+        // Queue row 233 (D-2130): count both received streams before retention truncates the tail.
+        const receive = (d) => {
+            s.receivedBytes += d.length;
+            s.buf = (s.buf + d).slice(-MAX_BUF);
+        };
+        p.stdout.on("data", receive);
+        p.stderr.on("data", receive);
         p.on("close", () => (s.exited = true));
         p.on("error", (e) => { s.buf = (s.buf + `\n[tickmarkr subprocess error] ${e}\n`).slice(-MAX_BUF); s.exited = true; });
         // Queue row 108 (D-1622): THIS run's transport state. The slot's `exited` outlives an invocation (a reused slot) and
@@ -117,7 +122,7 @@ export class SubprocessDriver {
     async transportState(slot) {
         const s = this.state(slot);
         const run = s.invocation;
-        return { closed: run?.closed ?? false, bytes: Buffer.byteLength(s.buf), exitCode: run?.exitCode ?? null, signal: run?.signal ?? null };
+        return { closed: run?.closed ?? false, bytes: s.receivedBytes, exitCode: run?.exitCode ?? null, signal: run?.signal ?? null };
     }
     async read(slot, lines) {
         return this.state(slot).buf.split("\n").slice(-lines).join("\n");

package/dist/gates/acceptance.d.ts

@@ -21,6 +21,14 @@ export interface JudgeVerdict {
     }>;
 }
 export declare function judgeCriterionId(index: number): string;
+export interface OracleFailure {
+    index: number;
+    kind: "command" | "test";
+    criterion: string;
+    landing?: string;
+    failure: "absent" | "elsewhere" | "untitled" | "red" | "unverified" | "no-runner";
+    output: string;
+}
 export declare function testFilterPattern(name: string): string;
 export declare function testFiltered(testCmd: string, name: string): string;
 export interface VitestListedTest {