tickmarkr 1.89.0 → 1.90.1

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

@@ -9,4 +9,31 @@ export type DoctorOpts = {
     catalog?: CatalogReadResult;
     catalogNow?: () => Date;
 };
+/**
+ * Q122s (TRIAL T-OBS-3): tickmarkr provisions run worktrees INSIDE the repo
+ * (.tickmarkr/worktrees.noindex/). A target repo whose test runner collects with
+ * repo-wide globs (jest's default `**​/__tests__/**` shape, vitest's default include)
+ * scans every suite once per live worktree — duplicate-suite interference red the
+ * baseline AND tip-verify on SentioQ's first external run, a class invisible to
+ * dogfooding (this repo's own includes are rooted at tests/).
+ *
+ * Q130s (TRIAL T-OBS-6): the ignore must be <rootDir>-anchored. Jest
+ * testPathIgnorePatterns are REGEXES matched against the ABSOLUTE test path; an
+ * unanchored "/.tickmarkr/" also matches every suite INSIDE a worktree provisioned at
+ * <repo>/.tickmarkr/worktrees.noindex/… — jest discovers nothing there and the whole
+ * gate battery fails closed (SentioQ run 2: 10 dispatches, 0 merges). Anchored
+ * patterns resolve <rootDir> to the worktree itself and stay inert. Vitest
+ * include/exclude globs match root-relative paths, so they cannot self-match, but the
+ * prescribed shape is root-anchored anyway.
+ *
+ * Text-level heuristic, advisory only — never enters health/doctor.json or routing.
+ * ponytail: ceilings — comments are stripped before judgment, but an include built
+ * from variables is still judged by its literal text, and a pattern string containing
+ * `//` would be truncated by the line-comment strip. Each costs one advisory row,
+ * nothing more.
+ */
+export declare function runnerIgnoreFinding(cwd: string): {
+    verdict: "pass" | "warn";
+    detail: string;
+} | undefined;
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;

package/dist/cli/commands/doctor.js

@@ -1,4 +1,5 @@
 import { writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
@@ -13,6 +14,77 @@ import { readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
+/**
+ * Q122s (TRIAL T-OBS-3): tickmarkr provisions run worktrees INSIDE the repo
+ * (.tickmarkr/worktrees.noindex/). A target repo whose test runner collects with
+ * repo-wide globs (jest's default `**​/__tests__/**` shape, vitest's default include)
+ * scans every suite once per live worktree — duplicate-suite interference red the
+ * baseline AND tip-verify on SentioQ's first external run, a class invisible to
+ * dogfooding (this repo's own includes are rooted at tests/).
+ *
+ * Q130s (TRIAL T-OBS-6): the ignore must be <rootDir>-anchored. Jest
+ * testPathIgnorePatterns are REGEXES matched against the ABSOLUTE test path; an
+ * unanchored "/.tickmarkr/" also matches every suite INSIDE a worktree provisioned at
+ * <repo>/.tickmarkr/worktrees.noindex/… — jest discovers nothing there and the whole
+ * gate battery fails closed (SentioQ run 2: 10 dispatches, 0 merges). Anchored
+ * patterns resolve <rootDir> to the worktree itself and stay inert. Vitest
+ * include/exclude globs match root-relative paths, so they cannot self-match, but the
+ * prescribed shape is root-anchored anyway.
+ *
+ * Text-level heuristic, advisory only — never enters health/doctor.json or routing.
+ * ponytail: ceilings — comments are stripped before judgment, but an include built
+ * from variables is still judged by its literal text, and a pattern string containing
+ * `//` would be truncated by the line-comment strip. Each costs one advisory row,
+ * nothing more.
+ */
+export function runnerIgnoreFinding(cwd) {
+    const readIf = (p) => (existsSync(join(cwd, p)) ? readFileSync(join(cwd, p), "utf8") : "");
+    const pkgText = readIf("package.json");
+    let pkg = {};
+    try {
+        pkg = JSON.parse(pkgText || "{}");
+    }
+    catch { /* unparseable manifest: judge config files alone */ }
+    const jestConfig = ["jest.config.js", "jest.config.cjs", "jest.config.mjs", "jest.config.ts", "jest.config.json"].find((p) => existsSync(join(cwd, p)));
+    const vitestConfig = ["vitest.config.ts", "vitest.config.js", "vitest.config.mts", "vitest.config.mjs", "vitest.config.cts"].find((p) => existsSync(join(cwd, p)));
+    const testScript = pkg.scripts?.test ?? "";
+    const isJest = jestConfig !== undefined || pkg.jest !== undefined || /\bjest\b/.test(testScript);
+    const isVitest = !isJest && (vitestConfig !== undefined || /\bvitest\b/.test(testScript));
+    if (!isJest && !isVitest)
+        return undefined;
+    // Comments are stripped before judgment: a commented-out ignore must not false-pass,
+    // and a prose comment mentioning .tickmarkr must not false-warn the anchor probe.
+    const stripComments = (s) => s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    const configText = stripComments(isJest
+        ? `${jestConfig ? readIf(jestConfig) : ""}${pkg.jest ? JSON.stringify(pkg.jest) : ""}`
+        : vitestConfig ? readIf(vitestConfig) : "");
+    if (/\.tickmarkr|worktrees\.noindex/.test(configText)) {
+        // Q130s self-match probe: erase every <rootDir>-anchored token (through the end of
+        // its quoted string); any surviving mention is a pattern that would also match
+        // inside a provisioned worktree (jest regex-vs-absolute-path semantics only).
+        const unanchored = configText.replace(/<rootDir>[^"'`\s]*/g, "");
+        if (isJest && /\.tickmarkr|worktrees\.noindex/.test(unanchored)) {
+            return {
+                verdict: "warn",
+                detail: `jest ignore for .tickmarkr/ is not <rootDir>-anchored — testPathIgnorePatterns are regexes against ABSOLUTE paths, so inside run worktrees (provisioned under .tickmarkr/worktrees.noindex/) it matches EVERY suite and the test gate fails closed; use "<rootDir>/\\\\.tickmarkr/" in ${jestConfig ?? "the package.json jest block"}`,
+            };
+        }
+        return { verdict: "pass", detail: `${isJest ? "jest" : "vitest"} config ignores .tickmarkr/ — run worktrees stay out of the suite` };
+    }
+    // Rooted collection globs never reach .tickmarkr/…; only repo-wide `**/`-style patterns (or
+    // runner defaults, which are repo-wide) can collect worktree copies.
+    const repoWide = configText === "" || /["'`]\*\*\//.test(configText);
+    if (!repoWide) {
+        return { verdict: "pass", detail: `${isJest ? "jest" : "vitest"} collection globs are rooted — run worktrees are not collectable` };
+    }
+    const remedy = isJest
+        ? `add "<rootDir>/\\\\.tickmarkr/" to testPathIgnorePatterns in ${jestConfig ?? "the package.json jest block"}`
+        : `add ".tickmarkr/**" to test.exclude in ${vitestConfig ?? "a vitest config"}`;
+    return {
+        verdict: "warn",
+        detail: `${isJest ? "jest" : "vitest"} collects repo-wide and will scan .tickmarkr/ run worktrees (duplicate suites, false reds) — ${remedy}`,
+    };
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     if (_argv.length === 1 && _argv[0] === "--refresh-catalog") {
         const refreshed = await refreshCatalogCommand({ repoRoot: cwd, now: opts.catalogNow });
@@ -90,6 +162,10 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     rows.push(...detectCandidateClis({ cwd }).map(({ binary, path }) => alignedStatusRow("warn", binary, `detected at ${path} (no drive contract — not routable)`)));
     const herdr = HerdrDriver.available();
     rows.push(alignedStatusRow(herdr ? "pass" : "fail", "herdr", herdr ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"));
+    // Q122s: the target repo's runner must not scan tickmarkr's own worktrees (advisory row).
+    const runnerIgnore = runnerIgnoreFinding(cwd);
+    if (runnerIgnore)
+        rows.push(alignedStatusRow(runnerIgnore.verdict, "test-runner", runnerIgnore.detail));
     // v1.22 T5: workspace-trust pre-flight — per installed adapter: trusted | seeded | action-required | n/a.
     // action-required names the exact one-time command (or dialog) the operator must run once.
     rows.push(legend("workspace trust:"));

package/dist/cli/commands/init.js

@@ -87,6 +87,7 @@ tickmarkr compiles repository specs into isolated, independently verified agent
 - \`tickmarkr resume <runId>\` — continue a paused or failed run
 - \`tickmarkr approve <runId> <taskId>\` — release a human gate
 - \`tickmarkr report <runId> --md\` — execution record beside the spec
+- \`tickmarkr verify --base <ref>\` — run the gate battery standalone against merge-base(base, HEAD)..HEAD: no daemon, no retries, one fail-closed verdict (\`--criteria <file>\` or \`--task <id>\` adds the semantic gates; \`--no-review\` for deterministic-only)
 
 Loop: compile → plan → run → report. Watch the journal for run-end rather than polling workers.
 

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

@@ -0,0 +1,9 @@
+import { type Assignment, type BillingChannel } from "../../adapters/types.js";
+import { type AcceptanceItem } from "../../graph/schema.js";
+export declare function parseCriteria(text: string): AcceptanceItem[];
+export declare const HUMAN_CHANNEL: BillingChannel;
+export declare const HUMAN_AUTHOR: Assignment;
+export declare function verify(argv: string[], cwd?: string): Promise<{
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/verify.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { allAdapters, probeAll, readDoctor, rolePools } from "../../adapters/registry.js";
+import { channelKey } from "../../adapters/types.js";
+import { loadConfig } from "../../config/config.js";
+import { captureBaseline, detectGateCommands } from "../../gates/baseline.js";
+import { runGates } from "../../gates/run-gates.js";
+import { getTask, loadGraph } from "../../graph/graph.js";
+import { GATE_NAMES } from "../../graph/schema.js";
+import { linkNodeModules, removeWorktree, shGit, shGitOk } from "../../run/git.js";
+/**
+ * tickmarkr verify — the gate battery as a standalone command (OPERATING-MODEL-2026-08-11 item 3).
+ *
+ * Runs the existing seven-gate pipeline (build/test/lint against a captured base baseline, then
+ * evidence, scope, acceptance ‖ review) against `merge-base(--base, HEAD)..HEAD` of the CURRENT
+ * checkout. No daemon, no worktree lifecycle, no retries, no approvals, no resumable state: one
+ * invocation, one immutable candidate, one machine-readable verdict. A verifier failure costs one
+ * rerun. Same fail-closed guarantees — this is a thin caller of runGates, not a second pipeline.
+ */
+// "- test: x" / "test: x" → typed oracle; plain lines → judge criterion (native.ts's exact grammar).
+const ORACLE_LINE = /^(command|test|judge):\s*(.+)$/;
+export function parseCriteria(text) {
+    return text
+        .split("\n")
+        .map((l) => l.trim().replace(/^-\s+/, ""))
+        .filter((l) => l && !l.startsWith("#"))
+        .map((l) => {
+        const m = ORACLE_LINE.exec(l);
+        if (!m)
+            return l;
+        const body = m[2].trim();
+        return m[1] === "command" ? { oracle: "command", command: body }
+            : m[1] === "test" ? { oracle: "test", test: body }
+                : { oracle: "judge", text: body };
+    });
+}
+// The human-author sentinel: pickReviewer resolves the author IN the channel list and excludes that
+// vendor (fail-closed when unresolvable). A human/plain-session diff has no vendor to exclude, so
+// verify models the author as a "human" vendor channel — resolvable, excludes nothing real.
+export const HUMAN_CHANNEL = { adapter: "human", vendor: "human", model: "human", channel: "sub", tier: "frontier" };
+export const HUMAN_AUTHOR = { adapter: "human", model: "human", channel: "sub", tier: "frontier" };
+export async function verify(argv, cwd = process.cwd()) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            base: { type: "string", default: "main" },
+            criteria: { type: "string" },
+            task: { type: "string" },
+            files: { type: "string", multiple: true },
+            author: { type: "string" },
+            baseline: { type: "string" },
+            json: { type: "boolean", default: false },
+            "no-review": { type: "boolean", default: false },
+            "no-acceptance": { type: "boolean", default: false },
+        },
+        allowPositionals: false,
+    });
+    const cfg = loadConfig(cwd);
+    const head = (await shGitOk("git rev-parse HEAD", cwd)).trim();
+    const baseTip = (await shGitOk(`git rev-parse '${values.base}'`, cwd).catch(() => {
+        throw new Error(`--base ${values.base} is not a resolvable ref — pass --base <ref> naming the branch this diff targets`);
+    })).trim();
+    const mergeBase = (await shGitOk(`git merge-base '${baseTip}' HEAD`, cwd)).trim();
+    if (mergeBase === head) {
+        throw new Error(`nothing to verify — HEAD is contained in ${values.base} (merge-base == HEAD). Commit work on a branch first.`);
+    }
+    // Criteria: an explicit compiled task, a criteria file, or none (deterministic gates + review only).
+    let acceptance = [];
+    let files = values.files ?? [];
+    let goal = `independent verification of the ${values.base}..HEAD diff`;
+    if (values.task) {
+        const t = getTask(loadGraph(cwd), values.task);
+        if (!t)
+            throw new Error(`--task ${values.task}: no such task in .tickmarkr/graph.json`);
+        acceptance = t.acceptance;
+        if (!files.length)
+            files = t.files;
+        goal = t.goal;
+    }
+    else if (values.criteria) {
+        acceptance = parseCriteria(readFileSync(values.criteria, "utf8"));
+        if (!acceptance.length)
+            throw new Error(`--criteria ${values.criteria}: no criteria found (bullets or command:/test:/judge: lines)`);
+    }
+    const wantAcceptance = acceptance.length > 0 && !values["no-acceptance"];
+    const wantReview = !values["no-review"];
+    const gates = GATE_NAMES.filter((g) => (g !== "acceptance" || wantAcceptance) && (g !== "review" || wantReview));
+    const task = {
+        id: "VERIFY", title: "standalone verification", goal, shape: "implement", complexity: 5,
+        deps: [], files, context: [], acceptance: acceptance.length ? acceptance : ["(deterministic verification only)"],
+        gates, humanGate: false, status: "pending",
+        evidence: { commits: [], artifacts: [], gateResults: [] },
+    };
+    const commands = detectGateCommands(cwd, cfg);
+    // 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.
+    // ponytail: tmpdir means the baseline cache dies on reboot/cleanup — worst case is one re-capture.
+    const stateDir = join(tmpdir(), "tickmarkr-verify", createHash("sha256").update(cwd).digest("hex").slice(0, 12));
+    mkdirSync(stateDir, { recursive: true });
+    let baseline;
+    const cachePath = join(stateDir, `baseline-${mergeBase.slice(0, 12)}.json`);
+    if (values.baseline) {
+        baseline = JSON.parse(readFileSync(values.baseline, "utf8"));
+    }
+    else if (existsSync(cachePath)) {
+        console.error(`verify: reusing cached baseline for ${mergeBase.slice(0, 12)} (${cachePath})`);
+        baseline = JSON.parse(readFileSync(cachePath, "utf8"));
+    }
+    else {
+        const baseDir = join(stateDir, `base-${mergeBase.slice(0, 12)}`);
+        console.error(`verify: capturing baseline at merge-base ${mergeBase.slice(0, 12)} (one-time per base; cached at ${cachePath})`);
+        await shGit(`git worktree remove --force '${baseDir}'`, cwd); // stale leftover from an interrupted run
+        await shGitOk(`git worktree add --detach '${baseDir}' '${mergeBase}'`, cwd);
+        try {
+            linkNodeModules(cwd, baseDir, { force: true });
+            baseline = await captureBaseline(baseDir, commands);
+            writeFileSync(cachePath, JSON.stringify(baseline, null, 2));
+        }
+        finally {
+            await removeWorktree(cwd, baseDir);
+        }
+    }
+    // LLM seats only when a semantic gate will run.
+    let channels = [];
+    let judgeChannels;
+    let author = HUMAN_AUTHOR;
+    const adapters = allAdapters();
+    if (wantAcceptance || wantReview) {
+        const health = readDoctor(cwd) ?? (await probeAll(adapters));
+        const pools = rolePools(cfg, adapters, health);
+        judgeChannels = pools.judge;
+        channels = pools.review;
+        if (values.author && values.author !== "human") {
+            const [adapter, ...rest] = values.author.split(":");
+            const model = rest.join(":");
+            const c = channels.find((ch) => ch.adapter === adapter && ch.model === model);
+            if (!c) {
+                throw new Error(`--author ${values.author} does not name a discoverable review channel — one of: ${channels.map(channelKey).join(", ") || "(none)"}`);
+            }
+            author = { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier };
+        }
+        else {
+            channels = [...channels, HUMAN_CHANNEL];
+        }
+        if (wantReview && !channels.some((c) => c.vendor !== "human")) {
+            throw new Error("review gate needs at least one authed LLM channel (run `tickmarkr doctor`) — or pass --no-review");
+        }
+    }
+    const artifactDir = join(stateDir, new Date().toISOString().replace(/[:.]/g, "-"));
+    mkdirSync(artifactDir, { recursive: true });
+    const { results } = await runGates(task, {
+        worktree: cwd, baseRef: mergeBase,
+        result: { ok: true, summary: "standalone verify — no worker claims to trust", deviations: [], raw: "" },
+        author, commands, baseline, channels, ...(judgeChannels ? { judgeChannels } : {}), adapters, cfg,
+        pipeline: "v185", artifactDir,
+        onGate: (e) => {
+            if (e.phase === "start")
+                console.error(`verify: → ${e.gate} (${e.index}/${e.total})`);
+            else
+                console.error(`verify: ${e.result.pass ? "✓" : "✗"} ${e.result.gate} — ${e.result.details.split("\n")[0] ?? ""}`);
+        },
+    });
+    const green = results.length > 0 && results.every((r) => r.pass || r.meta?.skipped === true);
+    if (values.json) {
+        return { out: JSON.stringify({ base: baseTip, head, mergeBase, green, results }, null, 2), code: green ? 0 : 2 };
+    }
+    const lines = results.map((r) => `${r.pass ? "PASS" : "FAIL"} ${r.gate}\n${r.details.split("\n").map((l) => `  ${l}`).join("\n")}`);
+    const verdict = green
+        ? `verify GREEN — ${results.length} gate(s) passed on ${mergeBase.slice(0, 12)}..${head.slice(0, 12)} (merge is a human decision)`
+        : `verify RED — first failure decides; artifacts in ${artifactDir}`;
+    return { out: [...lines, "", verdict].join("\n"), code: green ? 0 : 2 };
+}

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -16,10 +16,11 @@ import { scope } from "./commands/scope.js";
 import { status } from "./commands/status.js";
 import { ui } from "./commands/ui.js";
 import { unlock } from "./commands/unlock.js";
+import { verify } from "./commands/verify.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version, eval: evalCommand,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version, verify, eval: evalCommand,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -35,6 +36,7 @@ usage: tickmarkr <command>
   eval          run checked-in fixtures against every channel in isolated temp repos
   run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
   status        live run state
+  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD — no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])
   resume <id>   continue a run from its journal
   report <id>   cost/quality report (--md for committable execution record)
   profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)

package/dist/compile/collateral.js

@@ -1,6 +1,6 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, relative } from "node:path";
-import picomatch from "picomatch";
+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";
 // Advisory plan-time scan only (OBS-12/13/14/21, OBS-76). NEVER expands files[], fails compile,
@@ -106,7 +106,7 @@ export function collateralLints(tasks, repoRoot) {
     const lines = [];
     for (const t of tasks) {
         // OBS-22: scopeGate accepts picomatch globs; advisory collateral warnings must agree.
-        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
         const srcFiles = t.files.map((f) => f.replace(/^\.\//, "")).filter(isSrcPath);
         if (!srcFiles.length)
             continue;
@@ -175,7 +175,7 @@ export function newDirectoryLints(tasks, repoRoot) {
     const lines = [];
     for (const t of tasks) {
         // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.
-        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
         const newDirs = new Set();
         for (const f of t.files) {
             const dir = topLevelSrcDir(f);
@@ -213,7 +213,7 @@ export function sourceScopeLints(tasks, repoRoot) {
     const lines = [];
     for (const { t, needles } of perTask) {
         // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.
-        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
         // needles are word-chars by construction — no regex escaping needed; whole-word match only
         const res = needles.map((n) => new RegExp(`\\b${n}\\b`));
         const hits = [];
@@ -267,9 +267,9 @@ function overlappingPatterns(a, b) {
                 hits.add(pa);
                 continue;
             }
-            if (isGlob(pa) && !isGlob(pb) && picomatch(pa)(pb))
+            if (isGlob(pa) && !isGlob(pb) && filesGlob(pa)(pb))
                 hits.add(`${pb} ⊂ ${pa}`);
-            else if (isGlob(pb) && !isGlob(pa) && picomatch(pb)(pa))
+            else if (isGlob(pb) && !isGlob(pa) && filesGlob(pb)(pa))
                 hits.add(`${pa} ⊂ ${pb}`);
         }
     }
@@ -515,7 +515,7 @@ export function symbolOwnershipErrors(tasks, repoRoot) {
     }
     for (const { t, symbols } of perTask) {
         // OBS-22: scopeGate accepts picomatch globs; ownership must agree.
-        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
         for (const sym of symbols) {
             const defs = sites.get(sym) ?? [];
             if (defs.length !== 1)

package/dist/compile/common.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import picomatch from "picomatch";
+import { filesGlob } from "../graph/files-glob.js";
 export class CompileError extends Error {
     constructor(msg) {
         super(msg);
@@ -29,7 +29,7 @@ export function assertWriteScope(source, taskId, files, writes) {
     // #1 over-fire landmine: empty files[] is unrestricted — mirrors scope.ts:12
     if (!files.length)
         return;
-    const inScope = picomatch(files, { dot: true }); // byte-identical options to src/gates/scope.ts:15
+    const inScope = filesGlob(files); // the ONE files[] matcher — src/graph/files-glob.ts (Q120s)
     for (const { path, directive, bare } of writes) {
         const normalized = path.replace(/^\.\//, "");
         if (inScope(normalized))

package/dist/compile/native.d.ts

@@ -1,4 +1,4 @@
-import { type RunGraph } from "../graph/schema.js";
+import { type RunGraph, type Task } from "../graph/schema.js";
 /**
  * Classify one `context:` entry against the tree a worker's worktree is built from.
  *   ok        — reachable
@@ -17,5 +17,19 @@ export declare const COLLECTABLE_TESTS = "tests/**/*.test.ts";
 export declare const LEGACY_PREFIX: string;
 export declare const TICKMARKR_NATIVE_MARKER: RegExp;
 export declare const NATIVE_MARKER: RegExp;
+export declare const AUTHORING_LINT_CODES: readonly ["criterion-scope", "dependency-closure", "dependency-coupling", "proxy-metric", "external-referent", "closed-enumeration", "one-behavior", "concern-bundle", "seam-exists"];
+export type AuthoringLintCode = (typeof AUTHORING_LINT_CODES)[number];
+export interface AuthoringLintFinding {
+    code: AuthoringLintCode;
+    fixtureId: string;
+    taskId: string;
+    criterion?: number;
+    detail: string;
+}
+/**
+ * Frame-v2 authoring checks over the compiled native task shape. Criterion-scope is blocking at the
+ * compile boundary; the remaining checks are review findings, emitted by compileNative below.
+ */
+export declare function authoringLintFindings(tasks: readonly Task[], file: string): AuthoringLintFinding[];
 export declare function compileNative(file: string): RunGraph;
 export declare function specTemplate(): string;