tickmarkr 1.87.0 → 1.90.0

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/harness.d.ts

@@ -0,0 +1,13 @@
+export type HarnessProvenance = "installed" | "checkout" | "unknown" | "unresolved";
+export type Harness = {
+    path: string;
+    provenance: HarnessProvenance;
+};
+/**
+ * Resolve the harness that is executing from a path the CALLER supplies — never from process state, so a
+ * caller can pin the rendering without pinning its own filesystem. The resolution is the point: a global
+ * bin is a symlink into node_modules, and the invoked name hides exactly the segment provenance is read
+ * from (`process.argv[1]` never shows it).
+ */
+export declare function resolveHarness(from: string | undefined): Harness;
+export declare const harnessLine: (h: Harness) => string;

package/dist/cli/harness.js

@@ -0,0 +1,50 @@
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+const LABEL = {
+    installed: "installed package",
+    checkout: "working checkout",
+    unknown: "unknown origin",
+    unresolved: "unresolved location",
+};
+// Read off the RESOLVED location — never a build-time constant and never a value the binary states about
+// itself, because a self-report is exactly as trustworthy as the version string it exists to replace.
+// node_modules first: a package installed inside a checkout is still an installed package.
+const provenanceOf = (path) => {
+    if (path.split(sep).includes("node_modules"))
+        return "installed";
+    // a git worktree's `.git` is a FILE, not a directory — existsSync covers both
+    for (let d = dirname(path);; d = dirname(d)) {
+        if (existsSync(join(d, ".git")))
+            return "checkout";
+        if (dirname(d) === d)
+            return "unknown";
+    }
+};
+/**
+ * Resolve the harness that is executing from a path the CALLER supplies — never from process state, so a
+ * caller can pin the rendering without pinning its own filesystem. The resolution is the point: a global
+ * bin is a symlink into node_modules, and the invoked name hides exactly the segment provenance is read
+ * from (`process.argv[1]` never shows it).
+ */
+export function resolveHarness(from) {
+    let path;
+    try {
+        // `realpathSync("")` does NOT throw — it returns the cwd, so an absent `process.argv[1]` would name a
+        // DIRECTORY as the executing harness and read provenance off the caller's location instead of the
+        // binary's (inside a checkout: a confident, false "working checkout"). Absence is admitted as ITSELF:
+        // taking `undefined` means no caller has to invent an empty string to say "no location", and the one
+        // function every caller routes through rejects both forms before realpathSync ever sees them.
+        if (!from)
+            throw new Error("no location");
+        path = realpathSync(from);
+    }
+    catch {
+        // Fail closed: with no resolved location there is nothing to derive FROM, and classifying the
+        // unresolved TEXT would invent the claim — `/nowhere/node_modules/tickmarkr/…` would read
+        // "installed package" about a file that does not exist. The raw text survives as diagnostic only,
+        // never as evidence; a throw here would take down `plan`/`compile` over a provenance banner.
+        return { path: from ?? "", provenance: "unresolved" };
+    }
+    return { path, provenance: provenanceOf(path) };
+}
+export const harnessLine = (h) => `harness: ${h.path} (${LABEL[h.provenance]})`;

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;
@@ -121,14 +121,14 @@ export function collateralLints(tasks, repoRoot) {
                 continue;
             if (mentions(text, needles))
                 hits.push(tf);
-            if (hits.length >= MAX_HITS_PER_TASK)
-                break;
         }
         if (!hits.length)
             continue;
         // deterministic: walk already sorted; stable list
-        const listed = hits.join(", ");
-        const tail = hits.length >= MAX_HITS_PER_TASK ? " (capped)" : "";
+        const listed = hits.slice(0, MAX_HITS_PER_TASK).join(", ");
+        const tail = hits.length > MAX_HITS_PER_TASK
+            ? ` (${hits.length} total; capped at ${MAX_HITS_PER_TASK} shown)`
+            : "";
         lines.push(`${t.id}: likely collateral tests not in files[]: ${listed}${tail}`);
     }
     return lines;
@@ -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/index.d.ts

@@ -1,4 +1,15 @@
-import type { RunGraph } from "../graph/schema.js";
-type SourceType = "speckit" | "gsd" | "prd" | "native";
-export declare function compileSource(src: string, type?: SourceType, root?: string): RunGraph;
+import { type RunGraph, type SpecSource } from "../graph/schema.js";
+type SourceType = SpecSource;
+export type PlanIR = {
+    version: RunGraph["version"];
+    source: RunGraph["spec"]["source"];
+    paths: RunGraph["spec"]["paths"];
+    hash: RunGraph["spec"]["hash"];
+    base?: RunGraph["spec"]["base"];
+    mode?: RunGraph["mode"];
+    tasks: RunGraph["tasks"];
+};
+export type PlanFinalizationHook = (plan: PlanIR) => PlanIR;
+export declare function finalizePlan(plan: PlanIR, src: string): RunGraph;
+export declare function compileSource(src: string, type?: SourceType, root?: string, beforeFinalize?: PlanFinalizationHook): RunGraph;
 export {};

package/dist/compile/index.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { validateGraph } from "../graph/schema.js";
 import { taskUnitContractErrors } from "./collateral.js";
 import { CompileError } from "./common.js";
 import { compileGsd, isGsdPhaseDir } from "./gsd.js";
@@ -39,15 +40,40 @@ function enforceTaskUnitContract(g, src) {
     }
     return g;
 }
-export function compileSource(src, type, root) {
+export function finalizePlan(plan, src) {
+    const graph = validateGraph({
+        version: plan.version,
+        ...(plan.mode !== undefined ? { mode: plan.mode } : {}),
+        spec: {
+            source: plan.source,
+            paths: plan.paths,
+            hash: plan.hash,
+            ...(plan.base !== undefined ? { base: plan.base } : {}),
+        },
+        tasks: plan.tasks,
+    });
+    return enforceTaskUnitContract(graph, src);
+}
+function compilePlan(src, type, root) {
     const kind = type ?? detect(src);
-    if (kind === "speckit")
-        return enforceTaskUnitContract(compileSpecKit(src), src);
-    if (kind === "gsd")
-        return enforceTaskUnitContract(compileGsd(src, root), src);
-    if (kind === "native")
-        return enforceTaskUnitContract(compileNative(src), src);
-    if (kind === "prd")
-        return enforceTaskUnitContract(compilePrd(src), src);
-    throw new CompileError(`cannot detect spec type for ${src} — pass a Spec Kit feature dir (with tasks.md), a GSD phase dir (with *-PLAN.md), or a marked native/generic PRD .md file, or use --type speckit|prd|gsd|native`);
+    const graph = kind === "speckit" ? compileSpecKit(src)
+        : kind === "gsd" ? compileGsd(src, root)
+            : kind === "native" ? compileNative(src)
+                : kind === "prd" ? compilePrd(src)
+                    : null;
+    if (!graph) {
+        throw new CompileError(`cannot detect spec type for ${src} — pass a Spec Kit feature dir (with tasks.md), a GSD phase dir (with *-PLAN.md), or a marked native/generic PRD .md file, or use --type speckit|prd|gsd|native`);
+    }
+    return {
+        version: graph.version,
+        source: graph.spec.source,
+        paths: graph.spec.paths,
+        hash: graph.spec.hash,
+        ...(graph.spec.base !== undefined ? { base: graph.spec.base } : {}),
+        ...(graph.mode !== undefined ? { mode: graph.mode } : {}),
+        tasks: graph.tasks,
+    };
+}
+export function compileSource(src, type, root, beforeFinalize = (plan) => plan) {
+    return finalizePlan(beforeFinalize(compilePlan(src, type, root)), src);
 }

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;