tickmarkr 1.90.5 → 1.90.7

package/dist/gates/baseline.js

@@ -51,11 +51,53 @@ const TRAILING_FAIL_RE = /^\s*(?:test\s+)?\S+(?:\s+\([^)]*\))?\s+(?:\.{3}|-{3,})
 // runner sharing the glyph protocol is read without being enumerated; a status strip drawing ✖
 // mid-line inside chrome matches nothing, the same position rule as the other shapes.
 const GLYPH_FAIL_RE = /^\s*(?:(?:[\w@./-]+:\s*)*)✖\s+\S/;
+// vitest's default reporter draws the same glyph protocol with × (U+00D7, verbatim capture,
+// GATE-FIX-4 drill: `intake-backend:test:  × GF4BE deliberate failure — probe only`). It is a
+// fingerprintable SHAPE (isFailureShaped) but deliberately NOT in namesFailure: vitest prints a
+// FAIL twin naming the same test, and the HYG-08 meta.failingTests pin (tests/gates/baseline.test.ts)
+// keeps headline naming to one line per failure — duplicating each failure as glyph + FAIL would
+// re-headline the noise HYG-08 removed, while dropping the × from the fingerprint set would shrink
+// the per-test discriminators DEFECT 4 exists to harvest.
+const X_GLYPH_FAIL_RE = /^\s*(?:(?:[\w@./-]+:\s*)*)×\s+\S/;
+// Q137s (verbatim capture, dossier run-2 consult dossier, turbo 2.9.14 + pnpm 10): monorepo
+// drivers prefix child output and summarize failures in their own grammar. Four shapes, all
+// positional — `<pkg>:<task>:` prefixes reuse GLYPH_FAIL_RE's prefix idiom; `Failed:`/`ERROR`
+// require the driver's own `pkg#task` identifier or its literal terminus, so prose or drawn
+// chrome containing the words matches nothing (OBS-278 discipline):
+//   `intake-frontend:lint:  ELIFECYCLE  Command failed with exit code 1.`
+//   `Failed:    intake-frontend#lint`
+//   ` ERROR  intake-frontend#lint: command (…) … exited (1)`
+//   ` ERROR  run failed: command  exited (1)`
+const TURBO_FAIL_RE = /^\s*(?:[\w@./-]+:\s*)*ELIFECYCLE\s+Command failed\b|^\s*Failed:\s+\S+#\S+|^\s*ERROR\s+(?:\S+#\S+:|run failed\b)/;
+// GATE-FIX-4 DEFECT 4 (dossier drill, control 3): turbo prefixes every child line with
+// `<pkg>:<task>:  `, so the per-test shapes above (FAIL_ANCHOR_RE etc.) — all anchored at line
+// START — never fingerprinted; forgiveness compared only TURBO_FAIL_RE's package-level lines, and a
+// package with one tolerated pre-existing red was blind to every NEW failure inside it (a deliberate
+// failing test came back green). The counts route is closed too: normalizeLine masks digits, so
+// `Tests 3 failed` vs `Tests 2 failed` is not a discriminator — per-test lines, which carry file
+// paths and test names, are. This prefix is deliberately narrower than TURBO_FAIL_RE's label idiom:
+// at least TWO colon-joined segments (`<pkg>:<task>:`, tasks may nest — `pkg:test:unit:`), every
+// segment after the first starting with a letter — so `Error: boom` (one segment), `src/x.ts:12:`
+// (digit segment) and `12:34 error` (eslint stylish) are never stripped.
+const TURBO_PREFIX_RE = /^\s*[\w@./-]+(?::[A-Za-z_][\w.-]*)+:\s+/;
+const stripTurboPrefix = (l) => {
+    const m = TURBO_PREFIX_RE.exec(l);
+    return m ? l.slice(m[0].length) : undefined;
+};
 // Lines that NAME a failing test — the ones worth headlining to the operator. One list, so recognition
 // and reporting cannot drift apart (a shape that blocks but never gets named cost 3 attempts once).
-const namesFailure = (l) => FAIL_ANCHOR_RE.test(l) || RUNNER_FAIL_RE.test(l) || TRAILING_FAIL_RE.test(l) || GLYPH_FAIL_RE.test(l);
+const namesFailure = (l) => FAIL_ANCHOR_RE.test(l) || RUNNER_FAIL_RE.test(l) || TRAILING_FAIL_RE.test(l) || GLYPH_FAIL_RE.test(l) || TURBO_FAIL_RE.test(l);
+// The stripped form is a second READ of the same line, for the recognition/headline paths that ask
+// "does anything here name a failure" — verdict classification (isInfraLine/namesRegression) keeps
+// reading the raw line only, so infra/regression verdicts are byte-unchanged by the prefix pass.
+const namesFailureEitherForm = (l) => {
+    if (namesFailure(l))
+        return true;
+    const stripped = stripTurboPrefix(l);
+    return stripped !== undefined && namesFailure(stripped);
+};
 const isFailureShaped = (l) => namesFailure(l) || SUMMARY_FAIL_RE.test(l) || ERROR_ANCHOR_RE.test(l)
-    || TSC_ERROR_RE.test(l) || LINTER_ERROR_RE.test(l);
+    || TSC_ERROR_RE.test(l) || LINTER_ERROR_RE.test(l) || X_GLYPH_FAIL_RE.test(l);
 const VOCAB_RE = /\b(?:error|fail(?:ed|ure|ing)?)\b/i;
 // T9 — the infra/regression discriminator. A runner that died because the MACHINE ran out of
 // processes, file descriptors or memory never finished asking the question, so its nonzero exit is
@@ -95,7 +137,18 @@ export function fingerprint(output) {
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
         .filter((l) => !PASS_LINE_RE.test(l));
-    const shaped = lines.filter(isFailureShaped);
+    // GATE-FIX-4 DEFECT 4: every line is read twice — as printed, and with a turbo `<pkg>:<task>:`
+    // prefix removed. A recognized stripped line fingerprints as its STRIPPED text, so the same
+    // failure fingerprints identically whether turbo prefixed it or a bare runner printed it; the
+    // prefixed form keeps fingerprinting too (baseline-recorded package-level reds stay forgivable).
+    const shaped = [];
+    for (const l of lines) {
+        if (isFailureShaped(l))
+            shaped.push(l);
+        const stripped = stripTurboPrefix(l);
+        if (stripped !== undefined && !PASS_LINE_RE.test(stripped) && isFailureShaped(stripped))
+            shaped.push(stripped);
+    }
     if (!shaped.length)
         return lines.some((l) => l.trim()) ? [UNRECOGNIZED_FAILURE] : [];
     return [...new Set(shaped.map(normalizeLine))];
@@ -170,6 +223,36 @@ export function detectGateCommands(repoRoot, cfg) {
     }
     return out;
 }
+/**
+ * Dossier GATE-FIX-4 §3 (2026-08-13): turbo schedules per-package tasks and ABORTS the whole
+ * run at the first failing package, so every package after the abort goes unverified — and the
+ * baseline gate then forgives the truncated output as "matching". The class appeared in three
+ * gates and four syntaxes on one repo (turbo's scheduler, `&&`, a JS for-loop process.exit, and
+ * turbo nested inside two of them). This preflight names only what it can see textually: the
+ * resolved gate command, and — for the synthesized `<pm> run <script>` form — that script's own
+ * body. The remedy deliberately demands a forwarding check first: the same repo's lint wrapper
+ * branched on argv.length, so a blind `-- --continue` silently replaced the gate with a
+ * different command (the trap their overseer caught by reading, not by symmetry).
+ */
+export function turboContinueFindings(repoRoot, cfg) {
+    const pkgPath = join(repoRoot, "package.json");
+    const scripts = existsSync(pkgPath)
+        ? (JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {})
+        : {};
+    const findings = [];
+    for (const [gate, cmd] of Object.entries(detectGateCommands(repoRoot, cfg))) {
+        // The command text plus every package.json script it invokes by name — one level, textual.
+        const referenced = Object.keys(scripts).filter((name) => new RegExp(`\\brun\\s+(?:-s\\s+)?${reEscape(name)}(?:\\s|$)`).test(cmd));
+        const surface = [cmd, ...referenced.map((name) => scripts[name])].join("\n");
+        if (/\bturbo\s+run\b/.test(surface) && !surface.includes("--continue")) {
+            findings.push({
+                gate,
+                detail: `runs turbo without --continue — turbo aborts at the first failing package, so later packages go unverified yet baseline-forgiven. Append --continue where turbo is invoked, and verify forwarding first (\`run ${gate} -- --continue --dry=text\` must echo it): wrappers that branch on argv can silently swap the gated command`,
+            });
+        }
+    }
+    return findings;
+}
 const shellToken = (cmd) => {
     for (const raw of cmd.trim().split(/\s+/)) {
         if (!raw || /^[A-Za-z_][A-Za-z0-9_]*=/.test(raw))
@@ -292,12 +375,12 @@ function headlineDetails(raw, fresh) {
     const headlines = raw
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
-        .filter((l) => namesFailure(l) || SUMMARY_FAIL_RE.test(l));
+        .filter((l) => namesFailureEitherForm(l) || SUMMARY_FAIL_RE.test(l));
     if (!headlines.length)
         return { details: `new failures vs baseline:\n${fresh.join("\n")}` };
     return {
         details: `failing tests:\n${headlines.join("\n")}\n\nnew failure fingerprints vs baseline (secondary):\n${fresh.join("\n")}`,
-        meta: { failingTests: headlines.filter(namesFailure) },
+        meta: { failingTests: headlines.filter(namesFailureEitherForm) },
     };
 }
 export async function compareToBaseline(cwd, commands, baseline, enabled) {

package/dist/run/consult.js

@@ -2,7 +2,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAdapter } from "../adapters/registry.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
-import { extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
+import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
 import { disallowedBy } from "../route/preference.js";
 import { sh } from "./git.js";
@@ -173,7 +173,22 @@ opts = {}) {
                     await driver.close(slot);
             }
         }
-        return parseConsultVerdict(out, nonce);
+        // D-OBS-12 (dossier runs 1-2, 3/3 valid verdicts destroyed): the pane path is a terminal
+        // scrape — a single-line ~2000-char verdict soft-wraps in rendering and brace balance dies.
+        // Judge/review got dewrapPaneVerdict for exactly this (llm.ts, OBS-209 lineage); the consult
+        // seat never did. Headless output is machine-read stdout and needs no reconstruction.
+        const effective = cfg.visibility.llm === "headless" ? out : dewrapPaneVerdict(out, nonce);
+        const parsed = parseConsultVerdict(effective, nonce);
+        if (!parsed.verdict) {
+            // Q144s / OBS-196 parity: an unparseable verdict persists its raw bytes (pre-dewrap,
+            // rendering verbatim) beside the prompt — three human parks carried zero diagnostic
+            // payload because this artifact did not exist.
+            try {
+                writeFileSync(join(dir, `${d.taskId}-${n}${seatIdx > 0 ? `-s${seatIdx}` : ""}-response.txt`), out);
+            }
+            catch { /* evidence persistence must never fail the seat walk */ }
+        }
+        return parsed;
     };
     // v1.54 T1: ranked seat failover. Walk consult.prefer (adapter:model entries) to the first entry
     // whose adapter is in the live channel set; a failed seat or unparseable verdict falls to the next;

package/dist/run/daemon.js

@@ -920,6 +920,31 @@ export async function runDaemon(repoRoot, opts = {}) {
     let releaseApprovalSerialization;
     try {
         let graph = loadGraph(repoRoot);
+        // GATE-FIX-4 defect 4 (no-op run refusal): a fresh run on a graph with nothing dispatchable used
+        // to journal {run-start, run-end} with zero dispatches — and downstream readers (greenness exit,
+        // status, notify) treat that run-end as completion, so an all-terminal graph "went green" having
+        // done nothing. Refuse HERE, the earliest seam where the graph is known and BEFORE Journal.create
+        // makes the run dir: no run-start row, no run dir, and the error exits nonzero through the CLI's
+        // ordinary catch. Dispatchability reuses graph.ts's status math rather than restating it: a task
+        // is dispatchable iff it is ready now (readyTasks) or can still become ready — pending with a
+        // non-parked closure (pendingTasks), or unblocked later by in-flight running/gated residue.
+        // FRESH runs only: a resume where everything is terminal already owns its run-end and keeps its
+        // current replay-then-quiesce behavior (the run-narrate test pins run-resume → run-end).
+        if (!opts.resume && readyTasks(graph).length === 0 && pendingTasks(graph).length === 0
+            && !graph.tasks.some((t) => t.status === "running" || t.status === "gated")) {
+            // Every pending task here is blocked-on-terminal by construction (pendingTasks(graph) is empty),
+            // so the count is labeled truthfully instead of as still-runnable "pending".
+            const counts = new Map();
+            for (const t of graph.tasks) {
+                const bucket = t.status === "pending" ? "blocked-on-terminal" : t.status;
+                counts.set(bucket, (counts.get(bucket) ?? 0) + 1);
+            }
+            const breakdown = counts.size === 0 ? "graph has zero tasks"
+                : [...counts.entries()].map(([s, n]) => `${s} ${n}`).join(", ");
+            throw new Error(`nothing to dispatch — no task is ready and none can become ready (${breakdown}). `
+                + "Refusing to start a run that would journal run-start/run-end with zero dispatches. "
+                + "Release parked tasks with `tickmarkr approve <runId> <taskId>`, or compile a fresh graph with `tickmarkr compile`.");
+        }
         // v1.51 T2: the routing mode resolves BEFORE any routing input is built — run flag > spec front-matter
         // > repo > global > default. The resolved cfg carries mode-compiled floors; route() never sees the mode.
         const rm = resolveRunMode(repoRoot, { flag: opts.mode, spec: graph.mode, globalDir: opts.globalDir });

package/dist/tui/ink/components.d.ts

@@ -9,12 +9,14 @@ export declare function TextLines({ lines }: {
 export declare function ToggleMark({ active }: {
     active: boolean;
 }): import("react").JSX.Element;
-export declare function FleetListScreen({ title, legend, rows, cursor, details, }: {
+export declare function FleetListScreen({ title, legend, rows, cursor, details, filter, }: {
     title: string;
     legend: string;
     rows: FleetListRow[];
     cursor: number;
     details?: string[];
+    /** active type-to-search string; rendered on the legend line so the operator sees the narrowing */
+    filter?: string;
 }): import("react").JSX.Element;
 export declare function FleetReviewScreen({ title, legend, diff, }: {
     title: string;

package/dist/tui/ink/components.js

@@ -17,8 +17,8 @@ export function ToggleMark({ active }) {
         ? _jsx(Text, { color: "ansi256(41)", children: GLYPHS.toggleActive })
         : _jsx(Text, { dimColor: true, children: GLYPHS.toggleInactive });
 }
-export function FleetListScreen({ title, legend, rows, cursor, details = [], }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), _jsx(TextLines, { lines: details })] }));
+export function FleetListScreen({ title, legend, rows, cursor, details = [], filter, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: filter ? `${legend} · search: ${filter}` : legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), _jsx(TextLines, { lines: details })] }));
 }
 export function FleetReviewScreen({ title, legend, diff, }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));

package/dist/tui/ink/fleet-app.d.ts

@@ -8,6 +8,10 @@ export type FleetEditorState = {
     classifications: FleetClassification[];
     selectedMode: RoutingMode;
     map: Record<string, MapEntry>;
+    judgeSeat?: {
+        adapter: string;
+        model: string;
+    };
     steering: Record<FleetSteeringKey, string[] | undefined>;
 };
 export type FleetOverlayReview = {
@@ -72,7 +76,7 @@ export type FleetCandidateOption = {
     };
 };
 export declare function formatDoctorAge(ageMs: number | null): string;
-export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, }: {
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, }: {
     ageMs: number | null;
     agents: AgentCli[];
     initialDenyAdapters: string[];
@@ -89,8 +93,13 @@ export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDe
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
     reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
     reloadGuard: (bytes: string) => string | null;
+    entry?: "presets" | "probe";
+    /** resolved config judge as "adapter:model" — shown on the (keep default) picker row */
+    initialJudge?: string;
+    /** discovered adapter:model seats — the judge picker universe */
+    judgeSeats?: string[];
 }): import("react").JSX.Element;
-export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, initialInput, input, output, debug, }: {
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
     ageMs: number | null;
     adapters: WorkerAdapter[];
     health: Record<string, AuthHealth>;
@@ -108,6 +117,10 @@ export declare function runFleetInkEditor({ ageMs, adapters, health, initialDeny
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
     reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
     reloadGuard: (bytes: string) => string | null;
+    /** "presets" opens on the routing-mode screen with the extra custom row; default preserves the probe-first walk */
+    entry?: "presets" | "probe";
+    initialJudge?: string;
+    judgeSeats?: string[];
     initialInput?: string[];
     input: NodeJS.ReadStream;
     output: NodeJS.WriteStream;