tickmarkr 2.5.7 → 2.5.8

package/dist/cli/commands/approve.js

@@ -3,7 +3,7 @@ import { execFileSync } from "node:child_process";
 import { userInfo } from "node:os";
 import { loadConfig } from "../../config/config.js";
 import { integrationBranch } from "../../run/merge.js";
-import { separabilityErrors } from "../../compile/collateral.js";
+import { separabilityErrors, surfaceErrors, taskBudgetErrors } from "../../compile/collateral.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { applyScopeAmendments, engagementComparable, engagementReleased, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
 export const APPROVAL_DISPOSITIONS = ["dispatch", "waive-gate", "re-dispatch", "fund-fixed-attempt", "fresh-budget"];
@@ -194,6 +194,13 @@ export async function approve(argv, cwd = process.cwd()) {
             const conflicts = separabilityErrors(amended.tasks);
             if (conflicts.length)
                 throw new Error(`refusing scope-request approval for ${taskId}: ${conflicts.join("\n")}`);
+            // C4: a live grant may not take a task past the bounds that fail every compile. The exception
+            // list is EMPTY on purpose — a recorded historical compile exception confers no live authority.
+            const overBound = [...taskBudgetErrors([{ ...task, files: amendedFiles }]), ...surfaceErrors([{ ...task, files: amendedFiles }], [])];
+            if (overBound.length) {
+                throw new Error(`refusing scope-request approval for ${taskId}: ${overBound.join("\n")}\n`
+                    + `remedy: close the run, split the task in its spec, recompile, then \`tickmarkr resume ${runId} --graph-changed\``);
+            }
             journal.append("task-approved", taskId, {
                 by, ...(reason ? { reason } : {}), via: "cli", release: "scope-request",
                 amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line, definition: taskDefinitionFingerprint(task) },

package/dist/cli/commands/compile.js

@@ -3,6 +3,7 @@ import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeFindings, sourceScopeLints, } from "../../compile/collateral.js";
 import { CompileError } from "../../compile/common.js";
 import { compileSource } from "../../compile/index.js";
+import { retiredLiteralErrors } from "../../compile/retired-literals.js";
 import { clearCompileRefusal, saveCompileRefusal, saveGraph, stateDirName } from "../../graph/graph.js";
 import { formatPriorFindingEvidence, readPriorRunEvidence } from "../../run/journal.js";
 import { shGit } from "../../run/git.js";
@@ -75,6 +76,12 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
         if (unwaived.length > 0) {
             throw new CompileError(`${src} has unwaived native source-scope authoring errors:\n${unwaived.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
         }
+        // v2.5.8 T14: a declared pin whose obligated file the declaring task does not own refuses the seal
+        // here, before any state write, so a dry run reaches the same refusal. Diagnostic only: never widens scope.
+        const uncovered = retiredLiteralErrors(g.tasks, cwd);
+        if (uncovered.length > 0) {
+            throw new CompileError(`${src} has uncovered declared pin obligations:\n${uncovered.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
+        }
         // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
         // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
         // remain the source compiler's answer.

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

@@ -1,6 +1,11 @@
+import { type Task } from "../../graph/schema.js";
 import { type VitestListResult } from "../../gates/acceptance.js";
 import { type WorkerAdapter } from "../../adapters/types.js";
 export type PlanOpts = {
     listTests?: (cwd: string) => Promise<VitestListResult>;
 };
+export declare function plannedOracleDisposition(task: Pick<Task, "files" | "acceptance">, listing: VitestListResult): {
+    refusals: string[];
+    advisories: string[];
+};
 export declare function plan(argv: string[], cwd?: string, adapters?: WorkerAdapter[], harnessFrom?: string | undefined, opts?: PlanOpts): Promise<string>;

package/dist/cli/commands/plan.js

@@ -8,6 +8,7 @@ import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
 import { chainDepth, dispatchWaves, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
+import { filesGlob } from "../../graph/files-glob.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -47,6 +48,32 @@ const fleetCanCrossVendorReview = (channels) => {
                 return true;
     return false;
 };
+// Planning can defer authorship only to this criterion's explicitly owned landing.
+// This advisory does not change runtime oracle execution or name resolution.
+export function plannedOracleDisposition(task, listing) {
+    const refusals = [];
+    const advisories = [];
+    const items = task.acceptance.filter((item) => typeof item === "object" && item.oracle === "test");
+    if (listing.status === "failed") {
+        if (items.length)
+            refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
+        return { refusals, advisories };
+    }
+    const owns = filesGlob(task.files.map((path) => path.replace(/^\.\//, "")));
+    for (const item of items) {
+        const audit = auditNamedTestOracles([item], listing.tests)[0];
+        if (audit.matches.length === 0 && item.landing && owns(item.landing)) {
+            advisories.push(`acceptance oracle ${JSON.stringify(audit.criterion)} not yet written (worker authors ${item.landing})`);
+        }
+        else if (audit.matches.length === 0) {
+            refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
+        }
+        else if (audit.matches.length > 1) {
+            refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches ${audit.matches.length} runner-listed test names`);
+        }
+    }
+    return { refusals, advisories };
+}
 const NAMED_CRITERION_PATH = /(?:^|[\s("'`])((?:src|tests|fixtures|scripts)\/[A-Za-z0-9_@{}*?.,/+-]+\.(?:tsx|ts|jsx|json|js|mjs|cjs|md|txt))(?![A-Za-z0-9])/g;
 const judgeOracle = (task) => task.acceptance.some((item) => typeof item === "string" || (typeof item === "object" && item.oracle === "judge"));
 const latestRunStatusLine = (cwd) => {
@@ -166,29 +193,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
         const listing = await (opts.listTests ?? listVitestTests)(cwd);
         for (const task of g.tasks) {
-            const refusals = [];
-            const advisories = [];
-            const authoredTest = task.files
-                .map((path) => path.replace(/^\.\//, ""))
-                .find((path) => /^tests\/.+\.test\.ts$/.test(path) && !/[?*{[]/.test(path) && !existsSync(join(cwd, path)));
-            if (listing.status === "failed") {
-                if (task.acceptance.some((item) => typeof item === "object" && item.oracle === "test")) {
-                    refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
-                }
-            }
-            else {
-                for (const audit of auditNamedTestOracles(task.acceptance, listing.tests)) {
-                    if (audit.matches.length === 0 && authoredTest) {
-                        advisories.push(`acceptance oracle ${JSON.stringify(audit.criterion)} not yet written (worker authors ${authoredTest})`);
-                    }
-                    else if (audit.matches.length === 0) {
-                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
-                    }
-                    else if (audit.matches.length > 1) {
-                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches ${audit.matches.length} runner-listed test names`);
-                    }
-                }
-            }
+            const { refusals, advisories } = plannedOracleDisposition(task, listing);
             if (refusals.length)
                 oracleRefusals.set(task.id, refusals);
             if (advisories.length)

package/dist/cli/commands/resume.js

@@ -39,7 +39,7 @@ export async function resume(argv, cwd = process.cwd()) {
     }
     await assertRefsWritable(cwd, "resume");
     const host = classifyHost();
-    preflightHostDriver(cfg, driverOverride, host);
+    await preflightHostDriver(cfg, driverOverride, host, cwd);
     const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,

package/dist/cli/commands/run.js

@@ -511,7 +511,7 @@ export async function run(argv, cwd = process.cwd()) {
         }
         await assertRefsWritable(cwd, "run");
         const host = classifyHost();
-        preflightHostDriver(cfg, driverOverride, host);
+        await preflightHostDriver(cfg, driverOverride, host, cwd);
         // The run id is minted HERE rather than inside the daemon, because the narration sink has to know
         // which run it is narrating before the first event arrives (the daemon's `narrate` callback is
         // handed an event and nothing else, and `run-start` carries no run id). `runDaemon` uses the id

package/dist/compile/native.js

@@ -69,7 +69,51 @@ const NESTED_RE = /^\s+- (.+)$/;
 // v1.19: a typed acceptance oracle line — "command: ...", "test: ...", or "judge: ...". Anything
 // without one of these prefixes is a plain-string judge criterion (compat path, emits a warning).
 const ORACLE_RE = new RegExp(`^(${ORACLES.join("|")}):\\s*(.*)$`);
-const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout"]);
+const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout", "pins"]);
+const listItems = (draft) => draft.list === "acceptance" ? draft.acceptanceRaw : draft.list === "pins" ? draft.pinsRaw : draft.gates;
+// v2.5.8 T7: one declared pin item — "literal: <exact text> | glob: <search glob>" (split at the LAST
+// " | glob: " so the text may itself hold a bar) or "fixture: <path set>". A declaration missing the
+// payload its own kind requires refuses the compile naming the task and the item.
+const PIN_GLOB_SEP = "| glob:";
+// v2.5.8 T8 (OBS-1064): "test: <title> | suite: <path>" — split at the LAST " | suite: " so the title
+// stays the verbatim leaf the gate matches and the landing path never enters it.
+const LANDING_SEP = "| suite:";
+function parsePin(task, raw, index, pathSet) {
+    const bad = (detail) => invalid(task, "pins", `item ${index + 1} (${JSON.stringify(raw)}) ${detail}`);
+    const typed = raw.match(/^(\w+):\s*(.*)$/);
+    if (typed?.[1] === "fixture") {
+        const paths = pathSet(typed[2]);
+        if (!paths.length)
+            bad("is a fixture pin missing its path set");
+        return { kind: "fixture", paths };
+    }
+    if (typed?.[1] === "literal") {
+        const at = typed[2].lastIndexOf(PIN_GLOB_SEP);
+        const text = (at < 0 ? typed[2] : typed[2].slice(0, at)).trim();
+        const glob = at < 0 ? "" : typed[2].slice(at + PIN_GLOB_SEP.length).trim();
+        if (!text)
+            bad("is a literal pin missing its text");
+        if (!glob)
+            bad(`is a literal pin missing its search glob — write "literal: <text> ${PIN_GLOB_SEP} <glob>"`);
+        return { kind: "literal", text, glob };
+    }
+    return bad('must be "literal: <text> | glob: <glob>" or "fixture: <path set>"');
+}
+function parseTestOracle(task, body, index) {
+    const at = body.lastIndexOf(LANDING_SEP);
+    if (at < 0)
+        return { oracle: "test", test: body.trim() };
+    const test = body.slice(0, at).trim();
+    const landing = body.slice(at + LANDING_SEP.length).trim();
+    const bad = (detail) => invalid(task, "acceptance", `item ${index + 1} (${JSON.stringify(body)}) ${detail}`);
+    if (!test)
+        bad("is a test oracle missing its title before the landing");
+    if (!landing)
+        bad(`is a test oracle missing its landing path — write "test: <title> ${LANDING_SEP} <path>"`);
+    if (!picomatch(COLLECTABLE_TESTS, { dot: true })(landing))
+        bad(`declares landing ${JSON.stringify(landing)} which no runner collects (${COLLECTABLE_TESTS})`);
+    return { oracle: "test", test, landing };
+}
 function invalid(task, field, detail) {
     throw new CompileError(`Task ${task} field "${field}" ${detail}`);
 }
@@ -376,7 +420,7 @@ export function compileNative(file, options = {}) {
     for (const [index, line] of content.split("\n").entries()) {
         const heading = line.match(HEAD_RE);
         if (heading) {
-            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptanceRaw: [], acceptance: [], gates: [], hasGates: false, list: null, itemOpen: false, continuationField: null });
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptanceRaw: [], acceptance: [], gates: [], hasGates: false, pinsRaw: [], list: null, itemOpen: false, continuationField: null });
             continue;
         }
         const draft = drafts.at(-1);
@@ -411,7 +455,7 @@ export function compileNative(file, options = {}) {
                 invalid(draft.id, field[1], "is unknown");
             const value = field[2].trim();
             draft.itemOpen = false;
-            if (name === "acceptance" || name === "gates") {
+            if (name === "acceptance" || name === "gates" || name === "pins") {
                 if (value)
                     invalid(draft.id, field[1], "must be a nested list");
                 draft.list = name;
@@ -459,7 +503,7 @@ export function compileNative(file, options = {}) {
             const value = nested[1].trim();
             if (!value)
                 invalid(draft.id, draft.list, "must not contain empty entries");
-            (draft.list === "acceptance" ? draft.acceptanceRaw : draft.gates).push(value);
+            listItems(draft).push(value);
             draft.itemOpen = true;
             continue;
         }
@@ -468,7 +512,7 @@ export function compileNative(file, options = {}) {
         // 1.87.0 dropped these lines silently: 53/78 of run-551's criteria compiled to first-line
         // stubs and every falsifier tail was invisible to the judge.
         if (draft.list && draft.itemOpen && (line.startsWith(" ") || line.startsWith("\t")) && line.trim()) {
-            const items = draft.list === "acceptance" ? draft.acceptanceRaw : draft.gates;
+            const items = listItems(draft);
             items[items.length - 1] += ` ${line.trim()}`;
             continue;
         }
@@ -489,14 +533,14 @@ export function compileNative(file, options = {}) {
     // OBS-488: typed-oracle prefixes parse on the COMPLETE joined item text, never its first
     // physical line — a wrapped `command:` body or falsifier tail is part of the criterion.
     for (const draft of drafts) {
-        for (const raw of draft.acceptanceRaw) {
+        for (const [index, raw] of draft.acceptanceRaw.entries()) {
             const typed = raw.match(ORACLE_RE);
             if (typed) {
                 const [, kind, body] = typed;
                 if (!body.trim())
                     invalid(draft.id, "acceptance", `${kind} oracle must carry a value`);
                 draft.acceptance.push(kind === "command" ? { oracle: "command", command: body.trim() }
-                    : kind === "test" ? { oracle: "test", test: body.trim() }
+                    : kind === "test" ? parseTestOracle(draft.id, body, index)
                         : { oracle: "judge", text: body.trim() });
             }
             else {
@@ -561,6 +605,9 @@ export function compileNative(file, options = {}) {
         return trimmed;
     };
     const csv = (value) => value && value.toLowerCase() !== "none" ? splitTop(value).map((item) => stripAnnotation(item.trim())).filter(Boolean) : [];
+    // A fixture pin's path set is split only — never annotation-stripped: "fixtures/output (old)" is a
+    // filename, and csv() would silently retarget the declared obligation to "fixtures/output".
+    const pinPaths = (value) => splitTop(value).map((item) => item.trim()).filter(Boolean);
     // OBS-97: a typed test: oracle needs a collectable home. vitest only collects COLLECTABLE_TESTS
     // paths, so a task whose non-empty files[] cannot host one makes scope-green and acceptance-green
     // mutually exclusive by construction — run-20260719-210434 burned two dispatch attempts before a
@@ -677,6 +724,7 @@ export function compileNative(file, options = {}) {
             ...(timeoutMinutes !== undefined ? { timeoutMinutes } : {}),
             ...(routingHints ? { routingHints } : {}),
             ...(draft.hasGates ? { gates: draft.gates } : {}),
+            ...(draft.pinsRaw.length ? { pins: draft.pinsRaw.map((raw, i) => parsePin(draft.id, raw, i, pinPaths)) } : {}),
         };
     });
     const result = validateGraph({
@@ -780,9 +828,19 @@ acceptance is required on every task (a nested list of observable outcomes).
     acceptance:  nested list (REQUIRED, non-empty). Each item is either a typed oracle or plain text:
                  - command: <shell>   (oracle: command — exit code)
                  - test: <name>       (oracle: test — named test)
+                 - test: <name> | suite: <path>   (same, plus the tests/**/*.test.ts file it lands in;
+                                       the path lives in the item's landing field, never in the title)
                  - judge: <rubric>    (oracle: judge — LLM-judged, free text)
                  A judge criterion carries ONE claim; a semicolon-joined criterion warns — split its clauses.
                  - <plain text>       (compat: compiles as judge oracle, warns)
+    pins:        nested list (optional) of retired-literal and fixture pin obligations:
+                 - literal: <exact text> | glob: <search glob>   (every file matching the glob that holds
+                                                                  the text is an obligated file)
+                 - fixture: <comma-separated path set>           (every matching file is itself obligated:
+                                                                  byte-pinned output the change will move;
+                                                                  it carries no literal text)
+                 LAW: a pins declaration is a LIMITED AUTHORING CONTRACT, not an assertion analyzer —
+                 tickmarkr holds you to the obligations you DECLARE; it does not discover the pins you forgot.
 
   HARD BOUNDS — these FAIL the compile, they do not warn:
     - at most 6 acceptance items per task (no exception path)
@@ -799,6 +857,9 @@ acceptance is required on every task (a nested list of observable outcomes).
       describe() is allowed (OBS-511: the gate matches the criterion as the trailing segment of the
       runner-visible full name), but the leaf title itself must equal the criterion: a shortened,
       decorated, or paraphrased leaf selects ZERO tests and the gate parks even though the suite is green.
+      To say WHICH suite the test lands in, append " | suite: <tests/**/*.test.ts path>" — the path is
+      parsed off into the item's landing field and the title stays the bare leaf; a landing outside the
+      collectable glob refuses the compile.
       Measured before the widening: two parks across two runs, one full attempt lost in each.
     - NO criterion may be satisfiable by an absence, a rename, a source-text grep, or an empty collection.
       "no file references X" is not a criterion — it passes in a repo where the feature was never built.

package/dist/compile/retired-literals.d.ts

@@ -0,0 +1,22 @@
+import type { Task } from "../graph/schema.js";
+/** The file-system seam: tests substitute it to stage an unreadable file or a truncated read. */
+export interface PinScanIo {
+    size(abs: string): number;
+    read(abs: string): Buffer;
+    /** stat-following; throws like statSync (ENOENT for a broken link). */
+    isDirectory(abs: string): boolean;
+    /** stat-following: a regular file (or a link resolving to one) — never a FIFO, socket or device. */
+    isFile(abs: string): boolean;
+}
+export interface LiteralHit {
+    path: string;
+    line: number;
+}
+/** Each line of `content` holding `text`, 1-based. */
+export declare function literalHits(path: string, content: string, text: string): LiteralHit[];
+/**
+ * One line per uncovered obligation or uncertifiable scan; empty means every declared pin is covered
+ * by the task that declares it. Ownership by any OTHER task — merged predecessor or downstream — is
+ * named in the diagnostic and is no substitute.
+ */
+export declare function retiredLiteralErrors(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "pins">>, repoRoot: string, io?: PinScanIo): string[];

package/dist/compile/retired-literals.js

@@ -0,0 +1,271 @@
+import { lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { filesGlob, literalParens } from "../graph/files-glob.js";
+const NODE_IO = {
+    size: (abs) => statSync(abs).size,
+    read: (abs) => readFileSync(abs),
+    isDirectory: (abs) => statSync(abs).isDirectory(),
+    isFile: (abs) => statSync(abs).isFile(),
+};
+const cause = (error) => (error instanceof Error ? error.message : String(error));
+const patternsOf = (pin) => (pin.kind === "literal" ? [pin.glob] : pin.paths);
+/** Leading segments with no glob syntax at all (never the last): every match of the pattern sits under them. */
+const literalBase = (pattern) => {
+    const segs = literalParens(pattern).split("/");
+    const wild = segs.findIndex((s) => !/^[\w.-]+$/.test(s) || s === "..");
+    return segs.slice(0, Math.min(wild < 0 ? segs.length : wild, segs.length - 1)).join("/");
+};
+/**
+ * picomatch's brace semantics are expansion (`{a,b/c}/x` ≡ `a/x`, `b/c/x`; `\,` and `\{` are literal):
+ * every top-level comma-holding brace is expanded until none remains, so a slash inside a brace is an
+ * honest segment boundary. A brace with no top-level comma (`{a}`, `{1..3}`) is left for filesGlob.
+ */
+function expandBraces(pattern) {
+    let depth = 0;
+    let open = -1;
+    let alts = [];
+    let last = -1;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "\\")
+            i++;
+        else if (c === "{") {
+            if (depth++ === 0) {
+                open = i;
+                last = i + 1;
+                alts = [];
+            }
+        }
+        else if (c === "," && depth === 1) {
+            alts.push(pattern.slice(last, i));
+            last = i + 1;
+        }
+        else if (c === "}" && depth > 0 && --depth === 0) {
+            if (!alts.length)
+                continue; // no top-level comma: a literal or range brace, not an alternation
+            alts.push(pattern.slice(last, i));
+            const head = pattern.slice(0, open);
+            const tail = pattern.slice(i + 1);
+            return alts.flatMap((a) => expandBraces(head + a + tail));
+        }
+    }
+    return [pattern];
+}
+/** Split on "/" where it is a segment boundary; null when a slash is escaped or sits inside brackets. */
+function segmentsOf(pattern) {
+    const out = [""];
+    let depth = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "\\") {
+            if (pattern[i + 1] === "/")
+                return null;
+            out[out.length - 1] += c + (pattern[++i] ?? "");
+        }
+        else if (c === "/") {
+            if (depth)
+                return null;
+            out.push("");
+        }
+        else {
+            if (c === "[")
+                depth++;
+            else if (c === "]" && depth)
+                depth--;
+            out[out.length - 1] += c;
+        }
+    }
+    return out;
+}
+/**
+ * Does `alt` (brace-free) match EVERY path beneath `d`? Only a trailing globstar right after a matched prefix
+ * proves it; a globstar before that may swallow any run of `d`'s segments (`**\/cache/**` covers fixtures/cache/loop).
+ */
+function coversBeneath(alt, d) {
+    const segs = segmentsOf(alt);
+    if (!segs)
+        return false;
+    const covers = (si, di) => {
+        if (si >= segs.length)
+            return false;
+        if (segs[si] === "**") {
+            if (si === segs.length - 1)
+                return true;
+            for (let k = di; k <= d.length; k++)
+                if (covers(si + 1, k))
+                    return true;
+            return false;
+        }
+        if (di >= d.length)
+            return false;
+        // the prefix is matched as ONE pattern: a standalone `!cache` segment would read as a negation
+        return filesGlob(segs.slice(0, si + 1).join("/"))(d.slice(0, di + 1).join("/")) && covers(si + 1, di + 1);
+    };
+    return covers(0, 0);
+}
+/**
+ * Could `pattern` match a path strictly beneath directory `dir`? Matcher-consistent by construction:
+ * braces are expanded the way picomatch reads them, then every segment prefix is decided by filesGlob itself,
+ * and only an exact `**` segment is a globstar (`**.txt` is one ordinary segment). A leading `!` matches
+ * every path its body does not, so it reaches beneath `dir` unless some branch of the body provably covers
+ * all of it. What still cannot be split soundly (an escaped or bracketed slash) answers yes rather than certify blind.
+ */
+function reachesBeneath(pattern, dir) {
+    const p = pattern.replace(/^\.\//, "");
+    const d = dir ? dir.split("/") : [];
+    if (p.startsWith("!"))
+        return !expandBraces(literalParens(p.slice(1))).some((alt) => coversBeneath(alt, d));
+    return expandBraces(literalParens(p)).some((alt) => {
+        const segs = segmentsOf(alt);
+        if (!segs)
+            return true;
+        for (let i = 0; i < d.length; i++) {
+            if (i >= segs.length)
+                return false;
+            if (segs[i] === "**")
+                return true;
+            // the prefix is matched as ONE pattern: a standalone `!cache` segment would read as a negation
+            if (!filesGlob(segs.slice(0, i + 1).join("/"))(d.slice(0, i + 1).join("/")))
+                return false;
+        }
+        return segs.length > d.length;
+    });
+}
+/**
+ * Every non-directory path at or under `base`, decided later by filesGlob alone. NOTHING is pruned:
+ * not .git, not node_modules, not ignored files, not the state dir — the declared glob is the only
+ * narrowing (the literal base is exact: no match can sit outside it). A directory symlink is
+ * followed so matches behind it are listed under the symlink's own path; a link back into its own
+ * ancestry has no finite listing, so it refuses by name instead of being skipped.
+ * ponytail: a rootless glob such as ** / *.txt walks node_modules too; narrow the glob if that is slow.
+ */
+function walkAll(repoRoot, base, io) {
+    const out = { paths: [], causes: [] };
+    const visit = (rel, chain) => {
+        const abs = join(repoRoot, rel);
+        let isDir;
+        try {
+            isDir = io.isDirectory(abs);
+        }
+        catch (error) {
+            try {
+                // only a confirmed ENOENT is a known non-directory: a broken link stays a candidate whose read names the cause
+                if (error.code === "ENOENT") {
+                    if (lstatSync(abs, { throwIfNoEntry: false }))
+                        out.paths.push(rel);
+                    return;
+                }
+            }
+            catch { /* the lstat failed too: fall through to the refusal */ }
+            // anything else may be a directory hiding obligations: never a candidate that a glob could filter away
+            out.causes.push({ at: rel, why: `unstattable path ${rel || "."} (${cause(error)})`, maybeFile: true });
+            return;
+        }
+        if (!isDir) {
+            if (rel)
+                out.paths.push(rel);
+            return;
+        }
+        try {
+            const real = realpathSync(abs);
+            if (chain.includes(real)) {
+                out.causes.push({ at: rel, why: `symlink cycle at ${rel} cannot be enumerated`, maybeFile: false });
+                return;
+            }
+            for (const name of readdirSync(abs).sort())
+                visit(rel ? `${rel}/${name}` : name, [...chain, real]);
+        }
+        catch (error) {
+            out.causes.push({ at: rel, why: `unlistable directory ${rel || "."} (${cause(error)})`, maybeFile: false });
+        }
+    };
+    visit(base, []);
+    return out;
+}
+/** Whole-file read, or a thrown cause: a short read is never evidence of absence. */
+function readWhole(repoRoot, rel, io) {
+    const abs = join(repoRoot, rel);
+    let size;
+    let bytes;
+    try {
+        // a FIFO, socket or device has no finite whole to read: refuse it by kind before any read could block
+        if (!io.isFile(abs))
+            throw new Error(`unsupported file ${rel} (not a regular file)`);
+        size = io.size(abs);
+        bytes = io.read(abs);
+    }
+    catch (error) {
+        throw new Error(`unreadable file ${rel} (${cause(error)})`);
+    }
+    if (bytes.length !== size)
+        throw new Error(`truncated read of ${rel} (${bytes.length} of ${size} bytes)`);
+    return bytes.toString("utf8");
+}
+/** Each line of `content` holding `text`, 1-based. */
+export function literalHits(path, content, text) {
+    return content.split("\n").flatMap((line, i) => (line.includes(text) ? [{ path, line: i + 1 }] : []));
+}
+const pinName = (pin) => pin.kind === "literal" ? `literal ${JSON.stringify(pin.text)} in ${pin.glob}` : `fixture pin ${pin.paths.join(", ")}`;
+/**
+ * One line per uncovered obligation or uncertifiable scan; empty means every declared pin is covered
+ * by the task that declares it. Ownership by any OTHER task — merged predecessor or downstream — is
+ * named in the diagnostic and is no substitute.
+ */
+export function retiredLiteralErrors(tasks, repoRoot, io = NODE_IO) {
+    const declaring = tasks.filter((t) => t.pins?.length);
+    if (!declaring.length)
+        return [];
+    const walks = new Map();
+    const walked = (base) => walks.get(base) ?? walks.set(base, walkAll(repoRoot, base, io)).get(base);
+    const owns = new Map(tasks.map((t) => [t.id, filesGlob(t.files.map((f) => f.replace(/^\.\//, "")))]));
+    const errors = [];
+    for (const task of declaring) {
+        const owner = (path) => {
+            const others = tasks.filter((t) => t.id !== task.id && owns.get(t.id)(path)).map((t) => t.id);
+            return others.length
+                ? `owned by ${others.join(", ")}, which is no substitute: add it to ${task.id}.files[]`
+                : `owned by no task: add it to ${task.id}.files[]`;
+        };
+        for (const pin of task.pins) {
+            const matches = filesGlob(patternsOf(pin));
+            const found = [...new Set(patternsOf(pin).map((p) => literalBase(p.replace(/^\.\//, ""))))].map(walked);
+            // a cause refuses only a pin that could match at or beneath it: a cycle under fixtures/sub never refuses fixtures/*.txt
+            const affects = (c) => (c.maybeFile && matches(c.at)) || patternsOf(pin).some((p) => reachesBeneath(p, c.at));
+            const causes = [...new Set(found.flatMap((w) => w.causes).filter(affects).map((c) => c.why))];
+            for (const why of causes)
+                errors.push(`${task.id}: ${pinName(pin)} refuses certification: ${why}`);
+            const refused = causes.length > 0;
+            const surface = [...new Set(found.flatMap((w) => w.paths))].filter(matches).sort();
+            if (!surface.length) {
+                if (refused)
+                    continue; // the refusal above already names why nothing was certified
+                errors.push(`${task.id}: ${pinName(pin)} refuses certification: empty search surface (the pattern matches no file)`);
+                continue;
+            }
+            for (const path of surface) {
+                const owned = owns.get(task.id)(path);
+                // both kinds certify a whole-file read first: an owned fixture nobody could read is not evidence
+                let content;
+                try {
+                    content = readWhole(repoRoot, path, io);
+                }
+                catch (error) {
+                    errors.push(`${task.id}: ${pinName(pin)} refuses certification: ${cause(error)}`);
+                    continue;
+                }
+                if (pin.kind === "fixture") {
+                    if (!owned)
+                        errors.push(`${task.id}: ${pinName(pin)} obligates ${path}, outside ${task.id}.files[] (${owner(path)})`);
+                    continue;
+                }
+                const hits = literalHits(path, content, pin.text);
+                if (owned)
+                    continue;
+                for (const hit of hits) {
+                    errors.push(`${task.id}: ${pinName(pin)} still appears at ${hit.path}:${hit.line}, outside ${task.id}.files[] (${owner(path)})`);
+                }
+            }
+        }
+    }
+    return errors;
+}

package/dist/drivers/index.d.ts

@@ -13,9 +13,11 @@ export declare function classifyHost(env?: NodeJS.ProcessEnv): ClassifiedHost;
 /**
  * A config driver of herdr or orca whose host is not the classified one is refused naming the
  * detected host, the config line and the --driver remedy. Any explicit --driver value bypasses
- * this; auto and subprocess are never refused.
+ * that; auto and subprocess are never refused. Then, when the RESOLVED driver is orca (config,
+ * auto on an Orca host, or an explicit flag), the run root is admitted by one probe before any run
+ * directory, journal row or dispatch exists. Subprocess and herdr selections probe nothing.
  */
-export declare function preflightHostDriver(cfg: TickmarkrConfig, driverOverride: string | undefined, host: ClassifiedHost): void;
+export declare function preflightHostDriver(cfg: TickmarkrConfig, driverOverride: string | undefined, host: ClassifiedHost, runRoot: string, env?: NodeJS.ProcessEnv): Promise<void>;
 /**
  * Orca authors both markers on every terminal it creates. Requiring the pair avoids treating an
  * unrelated TERM_PROGRAM value or a copied terminal handle as host identity. This is deliberately