tickmarkr 1.83.0 → 1.85.0

package/dist/gates/run-gates.js

@@ -1,4 +1,6 @@
-import { channelKey } from "../adapters/types.js";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { channelKey, shq } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { getAdapter } from "../adapters/registry.js";
 import { GATE_NAMES } from "../graph/schema.js";
@@ -9,13 +11,118 @@ import { captureLlmOutput } from "./llm.js";
 import { marginalCostRank } from "../route/router.js";
 import { reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
+import { shGit } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
+const TEST_FILE_RE = /(?:^|\/)[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/;
+// relative specifiers only — `from "./x.js"`, `import("./x.js")`, `require("./x.js")`
+const IMPORT_RE = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*)["'](\.[^"']*)["']/g;
+const SELECTION_FILE_CAP = 3000;
+/**
+ * T4: the tests covering this round's diff, or undefined when the diff cannot be attributed with
+ * certainty — a rename or delete (the old path's coverage is gone), or a changed file no test
+ * reaches. Coverage: a test file covers itself; a test covers every file reachable from it through
+ * relative imports, directly or transitively.
+ *
+ * ponytail: ceiling — relative specifiers only (no tsconfig paths, no bare aliases, no computed
+ * specifiers), and an import cycle contributes only what it had resolved when re-entered. So this
+ * CAN miss. The miss is bounded by construction, not by care: the merge-candidate round re-runs the
+ * full suite on the same commit, so a miss costs one round and can never merge. Teach it a resolver
+ * (tsconfig paths, package exports) if selection ever misses often enough to be worth a round.
+ */
+async function coveringTests(worktree, baseRef) {
+    const diff = await shGit(`git diff --name-status ${shq(baseRef)} HEAD`, worktree);
+    if (diff.code !== 0)
+        return undefined;
+    const changed = [];
+    for (const line of diff.stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const status = parts[0] ?? "";
+        // R (rename) and D (delete): whatever used to cover the old path is unattributable now — full suite.
+        if (!status || status[0] === "R" || status[0] === "D" || parts.length < 2)
+            return undefined;
+        changed.push(parts[parts.length - 1]);
+    }
+    if (!changed.length)
+        return undefined;
+    const listed = await shGit("git ls-files", worktree);
+    if (listed.code !== 0)
+        return undefined;
+    const tracked = listed.stdout.split("\n").filter(Boolean);
+    if (tracked.length > SELECTION_FILE_CAP)
+        return undefined; // ponytail: a huge repo pays the full suite rather than a long scan
+    const trackedSet = new Set(tracked);
+    const tests = tracked.filter((p) => TEST_FILE_RE.test(p));
+    if (!tests.length)
+        return undefined;
+    const resolveSpec = (from, spec) => {
+        const base = posix.join(posix.dirname(from), spec);
+        // ESM-TS writes ".js" for a ".ts" source; a directory specifier means its index.
+        const candidates = [base, base.replace(/\.js$/, ".ts"), base.replace(/\.jsx$/, ".tsx"),
+            `${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`];
+        return candidates.find((c) => trackedSet.has(c));
+    };
+    const reachCache = new Map();
+    const reachOf = (file) => {
+        const cached = reachCache.get(file);
+        if (cached)
+            return cached;
+        const out = new Set();
+        reachCache.set(file, out); // cycle guard: a re-entered file contributes what it has so far
+        let src;
+        try {
+            src = readFileSync(posix.join(worktree, file), "utf8");
+        }
+        catch {
+            return out;
+        }
+        for (const m of src.matchAll(IMPORT_RE)) {
+            const dep = m[1] ? resolveSpec(file, m[1]) : undefined;
+            if (!dep || out.has(dep))
+                continue;
+            out.add(dep);
+            for (const t of reachOf(dep))
+                out.add(t);
+        }
+        return out;
+    };
+    const selected = new Set();
+    for (const file of changed) {
+        if (TEST_FILE_RE.test(file)) {
+            selected.add(file);
+            continue;
+        }
+        const covering = tests.filter((t) => reachOf(t).has(file));
+        if (!covering.length)
+            return undefined; // nothing covers this file — only the full suite can speak for it
+        for (const t of covering)
+            selected.add(t);
+    }
+    return [...selected].sort();
+}
+/**
+ * The configured test command narrowed to these files. Mirrors testFiltered's `--` rule (acceptance.ts:104):
+ * npm/yarn/pnpm/npx script wrappers need one `--` to forward positional filters to the underlying runner;
+ * a command that already has `--` takes them directly. Every path is quoted — config flows into a shell.
+ */
+export function testCommandForFiles(testCmd, files) {
+    const wrapped = /^\s*(?:npm|yarn|pnpm|npx)\b/.test(testCmd);
+    const fwd = wrapped && !/\s--\s/.test(testCmd) ? " --" : "";
+    return `${testCmd}${fwd} ${files.map(shq).join(" ")}`;
+}
 export async function runGates(task, ctx) {
     const results = [];
     let commits = [];
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
+    const v185 = ctx.pipeline === "v185";
+    // T4 (OBS-265): a GREEN selected-test run is a screen, not the round's verdict — the merge-candidate
+    // round re-runs the full suite on the same commit and THAT is what the round reports. Held here so
+    // exactly one `test` gate-result ever leaves a round, always carrying which suite spoke for it.
+    // (A RED screen IS the verdict: the round ends there, so it is recorded immediately.)
+    let heldTest;
     const sequence = GATE_NAMES.filter((g) => enabled(g));
     const total = sequence.length;
     const indexOf = (gate) => sequence.indexOf(gate) + 1;
@@ -23,42 +130,109 @@ export async function runGates(task, ctx) {
         results.push(result);
         await ctx.onGate?.({ phase: "end", gate: result.gate, result });
     };
-    const emitStart = async (gate) => {
-        await ctx.onGate?.({ phase: "start", gate, index: indexOf(gate), total });
+    const emitStart = async (gate, parentAt) => {
+        await ctx.onGate?.({ phase: "start", gate, index: indexOf(gate), total, ...(parentAt === undefined ? {} : { parentAt }) });
+    };
+    // The returned array stays in GATE_NAMES order however few gates a short-circuiting round reached.
+    // A round that ends before its merge-candidate stage flushes the held screen on the way out, so a
+    // green subset run is still journaled exactly once — as a selected run, which is what it was.
+    const done = async () => {
+        if (heldTest) {
+            const held = heldTest;
+            heldTest = undefined;
+            await ctx.onGate?.({ phase: "end", gate: "test", result: held });
+        }
+        return {
+            results: [...results].sort((a, b) => GATE_NAMES.indexOf(a.gate) - GATE_NAMES.indexOf(b.gate)),
+            commits,
+        };
     };
-    // 1. build/test/lint vs shared baseline — deterministic and cheap, first
     const toolGates = ["build", "test", "lint"].filter(enabled);
-    if (toolGates.length) {
-        // ponytail: compareToBaseline batches build/test/lint — their starts are emitted at iteration,
-        // not at true execution start. They are collectively sub-second (measured), so the debounce
-        // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
-        const toolResults = await compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, toolGates);
-        for (const r of toolResults) {
-            await emitStart(r.gate);
-            await record(r);
+    // build/test/lint vs the shared baseline
+    const runBattery = async (commands, selected) => {
+        if (!toolGates.length)
+            return;
+        if (!v185) {
+            // ponytail: compareToBaseline batches build/test/lint — their starts are emitted at iteration,
+            // not at true execution start. They are collectively sub-second (measured), so the debounce
+            // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
+            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, toolGates);
+            for (const r of toolResults) {
+                await emitStart(r.gate);
+                await record(r);
+            }
+            return;
         }
-        if (failed())
-            return { results, commits };
-    }
-    // 2. evidence — did the worker actually commit anything?
-    if (enabled("evidence")) {
-        await emitStart("evidence");
+        // T4 (OBS-265): one command at a time, stopping at the first red — a failed build no longer buys
+        // the full vitest suite before anyone reads its verdict.
+        for (const g of toolGates) {
+            await emitStart(g);
+            const [r] = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [g]);
+            if (g === "test" && selected) {
+                const screened = { ...r, meta: { ...r.meta, selectedTests: selected } };
+                // green: held (see heldTest) so the full suite below can supersede it with ONE verdict.
+                if (!screened.pass)
+                    await record(screened);
+                else {
+                    heldTest = screened;
+                    results.push(screened);
+                }
+            }
+            else {
+                await record(r);
+            }
+            if (failed())
+                return;
+        }
+    };
+    // The two sub-second git checks, as pure verdicts: no journal, no results push. Both read committed
+    // state only (commits ahead of base, `git diff --name-only base..HEAD`), so neither can be moved by
+    // anything the battery does to the worktree — which is what lets the screen below trust them early.
+    const evidenceResult = async () => {
         const e = await evidenceGate(ctx.worktree, ctx.baseRef);
         commits = e.commits;
-        await record({ gate: e.gate, pass: e.pass, details: e.details });
-        if (!e.pass)
-            return { results, commits };
-    }
-    // 3. scope
-    if (enabled("scope")) {
-        await emitStart("scope");
-        await record(await scopeGate(ctx.worktree, ctx.baseRef, task.files, ctx.result, ctx.cfg.scope?.allowDeviations ?? []));
-        if (failed())
-            return { results, commits };
-    }
-    // 4. acceptance judge (first LLM spend — everything cheaper already passed)
-    if (enabled("acceptance")) {
-        await emitStart("acceptance");
+        return { gate: e.gate, pass: e.pass, details: e.details };
+    };
+    const scopeResult = () => scopeGate(ctx.worktree, ctx.baseRef, task.files, ctx.result, ctx.cfg.scope?.allowDeviations ?? []);
+    const runGate = async (gate, compute) => {
+        await emitStart(gate);
+        await record(await compute());
+    };
+    /**
+     * T4 (OBS-265): the deterministic git checks run BEFORE the battery, as a screen — they answer
+     * "is this diff worth starting a ~3.7m tool battery for?" before the first command runs. A red
+     * screen IS the round's verdict: what it produced is journaled (in the order it ran) and the round
+     * ends there, so a drive-by out-of-scope edit costs <1s instead of the whole battery.
+     *
+     * A green screen changes nothing downstream. The recorded sequence stays GATE_NAMES order, so the
+     * journal, `tickmarkr report`, the surfaces, and resume's GATE_NAMES walk over already-satisfied
+     * gates all keep reading exactly one order.
+     *
+     * ponytail: the price of that is re-reading two git checks (~40ms) in their canonical positions
+     * rather than teaching every consumer of the gate stream a second order. Both reads see the same
+     * commits — the battery never moves HEAD — so the screen cannot disagree with the gate it screens
+     * for. Charge it only when there IS a battery command to protect.
+     */
+    const screenBlocks = async () => {
+        if (!toolGates.some((g) => ctx.commands[g]))
+            return false;
+        const screened = [];
+        for (const [gate, compute] of [["evidence", evidenceResult], ["scope", scopeResult]]) {
+            if (!enabled(gate))
+                continue;
+            screened.push(await compute());
+            if (screened[screened.length - 1].pass)
+                continue;
+            for (const r of screened) {
+                await emitStart(r.gate);
+                await record(r);
+            }
+            return true;
+        }
+        return false;
+    };
+    // acceptance judge — LLM spend, so everything deterministic has already passed when this runs
+    const runAcceptance = async () => {
         const judgeAdapter = getAdapter(ctx.cfg.judge.adapter, ctx.adapters);
         const jvia = ctx.via
             ? { driver: ctx.via.driver, keep: ctx.via.keep, onSlot: ctx.via.onSlot, name: ctx.via.nameFor("judge", judgeAdapter.id), label: ctx.via.labelFor("judge") }
@@ -121,13 +295,10 @@ export async function runGates(task, ctx) {
             a = await invokeJudge(retryAdapter, retry.model, retryJvia);
             a = { ...a, meta: { ...a.meta, judgeRetry: { flaked: flakedKey, retried: channelKey({ adapter: retry.adapter, model: retry.model }) } } };
         }
-        await withJudgeInvocationEvidence(invocations, () => record(a));
-        if (failed())
-            return { results, commits };
-    }
-    // 5. cross-vendor review
-    if (enabled("review")) {
-        await emitStart("review");
+        return { result: a, invocations };
+    };
+    // cross-vendor review
+    const runReview = async () => {
         let rv = await reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, ctx.adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir);
         // OBS-193: an unparseable review verdict retries the REVIEW exactly once on a different reviewer —
         // never the worker (GATE-09's judge-retry shape: straight-line single `if`, meta-only detection,
@@ -145,7 +316,80 @@ export async function runGates(task, ctx) {
                 rv = { ...second, meta: { ...second.meta, reviewRetry: { flaked, retried } } };
             }
         }
-        await record(rv);
+        return rv;
+    };
+    if (v185 && await screenBlocks())
+        return done();
+    // A non-final round may run only the tests covering its own diff; the merge-candidate round below
+    // pays the full suite anyway, so a selection that misses costs a round and can never merge.
+    const selected = v185 && ctx.selectTests && enabled("test") && ctx.commands.test
+        ? await coveringTests(ctx.worktree, ctx.baseRef)
+        : undefined;
+    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected);
+    if (failed())
+        return done();
+    if (enabled("evidence")) {
+        await runGate("evidence", evidenceResult);
+        if (failed())
+            return done();
+    }
+    if (enabled("scope")) {
+        await runGate("scope", scopeResult);
+        if (failed())
+            return done();
+    }
+    if (v185 && (enabled("acceptance") || enabled("review"))) {
+        // Judge and review are launched TOGETHER (96m of serialization over 5 runs). Enforcement is
+        // unchanged — it is still the AND of both, both still fail closed, and neither reads the other's
+        // verdict: each gets the same commit and the same brief it always got, and neither promise is
+        // reachable from inside the other. Only the waiting is gone.
+        const parentAt = Date.now();
+        // Both starts are emitted before either gate is launched, so the stream's order is the round's
+        // order and not a race between two dispatches. BOTH ARE IN FLIGHT BEFORE EITHER IS AWAITED:
+        // whichever adapter is slower no longer decides when the other one runs.
+        if (enabled("acceptance"))
+            await emitStart("acceptance", parentAt);
+        if (enabled("review"))
+            await emitStart("review", parentAt);
+        const judging = enabled("acceptance") ? runAcceptance() : undefined;
+        const reviewing = enabled("review") ? runReview() : undefined;
+        // Attach BOTH publication handlers before awaiting either. Dispatch concurrency alone is not
+        // enough: an acceptance-first await withholds a completed review behind a slow/hung judge and a
+        // process death can lose that already-earned verdict. The returned result is still sorted into
+        // GATE_NAMES order by done(); the event stream truthfully records each independent completion.
+        const judged = judging?.then((outcome) => withJudgeInvocationEvidence(outcome.invocations, () => record(outcome.result)));
+        const reviewed = reviewing?.then((outcome) => record(outcome));
+        await Promise.all([judged, reviewed]);
+        if (failed())
+            return done();
+    }
+    else if (!v185) {
+        // Legacy serial walk — frozen, and reachable only from the fixtures that pin it.
+        if (enabled("acceptance")) {
+            await emitStart("acceptance");
+            const judged = await runAcceptance();
+            await withJudgeInvocationEvidence(judged.invocations, () => record(judged.result));
+            if (failed())
+                return done();
+        }
+        if (enabled("review")) {
+            await emitStart("review");
+            await record(await runReview());
+        }
+        return done();
+    }
+    // The merge-candidate round: every other gate is green, so THIS round is the one that can merge —
+    // the full suite runs on the exact gated commit before the pipeline reports green. Nothing merges
+    // on a subset (spec: "nothing merges without a complete green suite"). Its verdict SUPERSEDES the
+    // held screen rather than joining it: one `test` entry in the record, one `test` end event in the
+    // stream, and `fullSuite` says which suite spoke while `selectedTests` keeps what the screen ran.
+    if (selected) {
+        await emitStart("test");
+        const [full] = await compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"]);
+        const merged = { ...full, meta: { ...full.meta, fullSuite: true, selectedTests: selected } };
+        results[results.findIndex((r) => r.gate === "test")] = merged;
+        heldTest = undefined;
+        await ctx.onGate?.({ phase: "end", gate: "test", result: merged });
     }
-    return { results, commits };
+    return done();
 }

package/dist/run/daemon.d.ts

@@ -1,7 +1,7 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type ExecutorDriver } from "../drivers/types.js";
-import { type JournalEvent } from "./journal.js";
+import { Journal, type JournalEvent } from "./journal.js";
 export interface RunOptions {
     runId?: string;
     resume?: boolean;
@@ -42,13 +42,59 @@ export interface RunSummary {
     lastMergedTask?: string;
 }
 export declare function formatSummary(s: RunSummary): string;
+/**
+ * T4 (OBS-265): the journal with the review objections a round did NOT hinge on removed. Judge and
+ * review are now launched together, so a round can journal a failed review that the serial walk would
+ * never have asked for — it returned at the judge. Those verdicts stay on the record (they are real,
+ * and the retry brief carries them), but they must not spend the OPERATOR-facing review round budget:
+ * otherwise concurrency alone parks a task rounds early for objections the old pipeline never bought.
+ * A round is the gate-result span opened by each `gates` phase-start, per task.
+ */
+export declare function decisiveReviewRounds(events: JournalEvent[]): JournalEvent[];
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
 export declare function resetEarlyLaunchLivenessMsForTests(): void;
-export declare const NUDGEABLE_ADAPTERS: Set<string>;
+export { NUDGEABLE_ADAPTERS } from "./stall.js";
 export declare const WORKER_NUDGE_MESSAGE = "tickmarkr liveness check: if the task is complete, print your TICKMARKR_RESULT completion trailer exactly as specified in your prompt now. If not, state your next concrete action and continue working.";
 /** Test seam — shrink the nudge gate and grace without minute-long sleeps. */
 export declare function setNudgeTimingForTests(silentMs: number, graceMs: number): void;
 export declare function resetNudgeTimingForTests(): void;
+/** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */
+export declare function setQuotaBannerSilentMsForTests(ms: number): void;
+export declare function resetQuotaBannerSilentMsForTests(): void;
+/** Test seam — shrink the repeat-page cadence without minute-long sleeps. */
+export declare function setPageRepeatMsForTests(ms: number): void;
+export declare function resetPageRepeatMsForTests(): void;
+/** Test seam — shrink the fast-kill window without minute-long sleeps. */
+export declare function setDeadChannelFastKillMsForTests(ms: number): void;
+export declare function resetDeadChannelFastKillMsForTests(): void;
+/** Test seam — shrink the harvest silence gate without minute-long sleeps. */
+export declare function setHarvestSilentMsForTests(ms: number): void;
+export declare function resetHarvestSilentMsForTests(): void;
+export declare function harvestCpuFlatWindowMs(resolutionMs: number): number;
+/** Test seam — pin the flat window so a probe case need not sit through a real one. */
+export declare function setHarvestCpuFlatMsForTests(ms: number): void;
+export declare function resetHarvestCpuFlatMsForTests(): void;
+export declare const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries committed work; the worker emitted no TICKMARKR_RESULT trailer";
+/** T4 (OBS-266): identity of the command SET a tip verify ran — a changed command is a different verify. */
+export declare function commandsHash(commands: Record<string, string>): string;
+/**
+ * OBS-34's strict tip verify, but it stops re-paying for an unmoved tip (~334m corpus-wide; 69.5m in
+ * one park-heavy run whose 18 resume cycles merged nothing new). The verify journals the SHA it
+ * verified and the hash of the command set, so a later run-end can recognize the same verified state:
+ * head equals the LAST green verified SHA, commands unchanged, tree clean → journal
+ * `tip-verify-cached` and skip. ANY doubt — moved head, changed commands, dirty tree, a gate missing
+ * from that cycle's green set, a failure recorded in it, a cycle older than the last one — runs the
+ * full verify. The tip-verify-before-green law is untouched: a cached green is a verified green OF
+ * THAT EXACT COMMIT, established by the most recent real run of the same commands.
+ * Returns whether the tip is failing.
+ */
+export declare function verifyIntegrationTipCached(intWt: string, commands: Record<string, string>, journal: Journal, opts?: {
+    lastMergedTask?: string;
+}): Promise<boolean>;
+export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
+    ms: number;
+    resolutionMs: number;
+} | undefined>;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;