tickmarkr 2.5.2 → 2.5.4

package/dist/adapters/qwen.d.ts

@@ -1,5 +1,6 @@
 import { type ClassifiedWorkerResult } from "./prompt.js";
 import { type WorkerAdapter } from "./types.js";
 export declare const QWEN_VERSION_IDENTITY: RegExp;
+export declare const QWEN_HARNESS_BANNER_ROWS: readonly ["⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice."];
 export declare function parseQwenResult(raw: string, nonce: string): ClassifiedWorkerResult;
 export declare const qwen: WorkerAdapter;

package/dist/adapters/qwen.js

@@ -3,6 +3,13 @@ import { parseWorkerResult } from "./prompt.js";
 import { channelsFromConfig, shq, } from "./types.js";
 export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
 const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
+// Verbatim stderr from tests/fixtures/qwen/safe-mode.stderr (qwen 0.21.15). These bytes are launch
+// harness, not evidence that a reviewer took a turn. Keep the declaration closed and row-shaped so
+// llm.ts can sweep partial terminal paints without a broad SAFE MODE/warning regex.
+export const QWEN_HARNESS_BANNER_ROWS = [
+    "⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.",
+    "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.",
+];
 function decodeQwenEvents(events) {
     const text = [];
     let failed = false;
@@ -136,6 +143,7 @@ export const qwen = {
     channels: (cfg) => channelsFromConfig("qwen", cfg),
     hardcodedFlags: { binary: "qwen", flags: ["--safe-mode", "--approval-mode", "-m", "-o", "-p"] },
     headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --safe-mode --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    harnessBannerRows: QWEN_HARNESS_BANNER_ROWS,
     // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
     // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
     // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.

package/dist/adapters/types.d.ts

@@ -171,6 +171,7 @@ export interface WorkerAdapter {
     probe(): Promise<AuthHealth>;
     channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;
+    harnessBannerRows?: readonly string[];
     interactiveCommand(promptFile: string, model: string): string | null;
     interactiveSeed?: InteractiveSeed;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;

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

@@ -8,6 +8,12 @@ import { type VitestListResult } from "../../gates/acceptance.js";
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export declare const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
 export declare const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
+type ReviewDemotionSummary = {
+    reviewer: string;
+    count: number;
+    causes: Record<string, number>;
+};
+export declare function recentReviewDemotions(cwd: string, lastRuns?: number): ReviewDemotionSummary[];
 export type DoctorOpts = {
     banner?: boolean;
     kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;
@@ -122,6 +128,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
         }>;
         floors: Record<string, "cheap" | "mid" | "frontier">;
         learned: "on" | "off";
+        escalateTier: "on" | "off";
         allowUnverifiedModels: boolean;
         mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
         learnedTuning?: {
@@ -179,6 +186,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
         complexityThreshold: number;
         timeoutMs: number;
         required: boolean;
+        floor: "cheap" | "mid" | "frontier" | "worker";
         prefer?: string[] | undefined;
         policy?: "full" | "judge-only" | undefined;
         criticalPaths?: string[] | undefined;
@@ -239,6 +247,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
         }>;
         floors: Record<string, "cheap" | "mid" | "frontier">;
         learned: "on" | "off";
+        escalateTier: "on" | "off";
         allowUnverifiedModels: boolean;
         mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
         learnedTuning?: {
@@ -296,6 +305,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
         complexityThreshold: number;
         timeoutMs: number;
         required: boolean;
+        floor: "cheap" | "mid" | "frontier" | "worker";
         prefer?: string[] | undefined;
         policy?: "full" | "judge-only" | undefined;
         criticalPaths?: string[] | undefined;

package/dist/cli/commands/doctor.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { detectPackageManager, turboContinueFindings } from "../../gates/baseline.js";
 import { version } from "./version.js";
@@ -26,6 +26,46 @@ const initialFetch = globalThis.fetch;
 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)}`;
+// Use the routing profile's established 50-run recency horizon without importing journal machinery
+// into doctor. Torn/malformed rows are ignored one at a time: diagnostics must survive a killed write.
+export function recentReviewDemotions(cwd, lastRuns = 50) {
+    const runs = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runs))
+        return [];
+    const grouped = new Map();
+    const ids = readdirSync(runs, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")
+        && existsSync(join(runs, entry.name, "journal.jsonl")))
+        .map((entry) => entry.name).sort().slice(-lastRuns);
+    for (const id of ids) {
+        const lines = readFileSync(join(runs, id, "journal.jsonl"), "utf8").split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!row || typeof row !== "object")
+                continue;
+            const event = row;
+            if (event.event !== "review-pool-demotion" || !event.data || typeof event.data !== "object")
+                continue;
+            const data = event.data;
+            if (typeof data.reviewer !== "string" || !data.reviewer.trim())
+                continue;
+            const cause = typeof data.cause === "string" && data.cause.trim() ? data.cause : "unknown";
+            const summary = grouped.get(data.reviewer) ?? { reviewer: data.reviewer, count: 0, causes: {} };
+            summary.count++;
+            summary.causes[cause] = (summary.causes[cause] ?? 0) + 1;
+            grouped.set(data.reviewer, summary);
+        }
+    }
+    return [...grouped.values()].sort((a, b) => a.reviewer.localeCompare(b.reviewer));
+}
 const ORCA_HOOK_ADAPTERS = {
     claude: "claude-code",
     "claude-code": "claude-code",
@@ -581,6 +621,15 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const healthy = h.installed && (a.id !== kimi.id || h.authed);
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
+    const reviewDemotions = recentReviewDemotions(cwd);
+    if (reviewDemotions.length) {
+        rows.push(legend("recent review-seat demotions:"));
+        for (const demotion of reviewDemotions) {
+            const causes = Object.entries(demotion.causes)
+                .map(([cause, count]) => `${cause}${count === demotion.count ? "" : ` ×${count}`}`).join(", ");
+            rows.push(alignedStatusRow("warn", demotion.reviewer, `${demotion.count} review seat${demotion.count === 1 ? "" : "s"} demoted · cause ${causes}`));
+        }
+    }
     if (existsSync(graphPath(cwd))) {
         try {
             const graph = loadGraph(cwd);

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -11,11 +11,11 @@ import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
-import { staffLedEvidence } from "../../route/profile.js";
+import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, readProfileCursor, recordedGraphDefinitionHash, RUNS_WINDOW } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -292,6 +292,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             }
         }
     }
+    lints.push(...tierEscalationAdvisories(cwd, cfg, g.tasks));
     for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
         if (!health[sel.adapter]?.installed)
             lints.push(`${role}: ${sel.adapter}:${sel.model} not installed — that gate/consult will fail closed`);
@@ -437,3 +438,143 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
     return stylizePlan(lines.join("\n"));
 }
+function extractClimb(event, taskShapeMap) {
+    if (event.event !== "tier-escalated")
+        return undefined;
+    const d = (event.data && typeof event.data === "object") ? event.data : {};
+    const shape = (typeof d.shape === "string" && d.shape)
+        || (typeof event.shape === "string" && event.shape)
+        || (typeof event.taskId === "string" ? taskShapeMap.get(event.taskId) : undefined)
+        || (typeof d.taskId === "string" ? taskShapeMap.get(d.taskId) : undefined);
+    if (!shape)
+        return undefined;
+    const beforeAssignment = (d.beforeAssignment && typeof d.beforeAssignment === "object") ? d.beforeAssignment : undefined;
+    const afterAssignment = (d.afterAssignment && typeof d.afterAssignment === "object") ? d.afterAssignment : undefined;
+    let fromTier = (typeof d.fromTier === "string" && d.fromTier)
+        || (typeof d.from === "string" && d.from)
+        || (typeof d.tierBefore === "string" && d.tierBefore)
+        || (typeof d.before === "string" && d.before)
+        || (typeof d.previousTier === "string" && d.previousTier)
+        || (typeof event.fromTier === "string" && event.fromTier)
+        || (typeof event.from === "string" && event.from)
+        || (typeof beforeAssignment?.tier === "string" && beforeAssignment.tier);
+    let toTier = (typeof d.toTier === "string" && d.toTier)
+        || (typeof d.to === "string" && d.to)
+        || (typeof d.tierAfter === "string" && d.tierAfter)
+        || (typeof d.after === "string" && d.after)
+        || (typeof d.nextTier === "string" && d.nextTier)
+        || (typeof d.tier === "string" && d.tier)
+        || (typeof event.toTier === "string" && event.toTier)
+        || (typeof event.to === "string" && event.to)
+        || (typeof afterAssignment?.tier === "string" && afterAssignment.tier);
+    if (!fromTier || !toTier) {
+        const text = [d.details, d.message, d.reason, d.summary, d.provenance].filter((s) => typeof s === "string").join(" ");
+        const m = /\b(cheap|mid|frontier)\s+to\s+(cheap|mid|frontier)\b/i.exec(text);
+        if (m) {
+            fromTier = fromTier || m[1].toLowerCase();
+            toTier = toTier || m[2].toLowerCase();
+        }
+    }
+    if (!fromTier || !toTier)
+        return undefined;
+    return { shape, fromTier, toTier };
+}
+function tierEscalationAdvisories(cwd, cfg, graphTasks) {
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runsRoot))
+        return [];
+    let candidateRunIds;
+    try {
+        candidateRunIds = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+    const cursor = readProfileCursor(cwd);
+    if (cursor)
+        candidateRunIds = candidateRunIds.filter((id) => id > cursor);
+    const windowRunIds = candidateRunIds.slice(-RUNS_WINDOW);
+    if (!windowRunIds.length)
+        return [];
+    // Leg-2 T5 (OBS-971): task ids restart at T1 every spec, so a shape lookup is only valid against the
+    // graph the run actually executed. Fallback to the current graph only when the run left no snapshot.
+    const currentShapeMap = new Map(graphTasks.map((t) => [t.id, t.shape]));
+    const numDistinct = windowRunIds.length;
+    const ascIndex = new Map(windowRunIds.map((id, i) => [id, i]));
+    const halfLife = cfg.routing.learnedTuning?.halfLifeRuns ?? HALF_LIFE_RUNS;
+    const shapeClimbs = new Map();
+    for (const runId of windowRunIds) {
+        const journalPath = join(runsRoot, runId, "journal.jsonl");
+        let lines;
+        try {
+            lines = readFileSync(journalPath, "utf8").split("\n");
+        }
+        catch {
+            continue;
+        }
+        let taskShapeMap = currentShapeMap;
+        const runGraphPath = join(runsRoot, runId, "graph.json");
+        if (existsSync(runGraphPath)) {
+            try {
+                const runGraph = JSON.parse(readFileSync(runGraphPath, "utf8"));
+                if (Array.isArray(runGraph.tasks)) {
+                    taskShapeMap = new Map();
+                    for (const rt of runGraph.tasks) {
+                        if (typeof rt?.id === "string" && typeof rt?.shape === "string")
+                            taskShapeMap.set(rt.id, rt.shape);
+                    }
+                }
+            }
+            catch {
+                // unreadable snapshot: fall back to the current graph
+            }
+        }
+        const runClimbedShapes = new Map();
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const event = parsed;
+            if (event.event !== "tier-escalated")
+                continue;
+            const climb = extractClimb(event, taskShapeMap);
+            if (climb) {
+                runClimbedShapes.set(climb.shape, { fromTier: climb.fromTier, toTier: climb.toTier });
+            }
+        }
+        const age = numDistinct - 1 - ascIndex.get(runId);
+        const w = decayWeight(age, halfLife);
+        for (const [shape, { fromTier, toTier }] of runClimbedShapes) {
+            let entry = shapeClimbs.get(shape);
+            if (!entry) {
+                entry = { fromTier, toTier, runs: new Set(), weighted: 0 };
+                shapeClimbs.set(shape, entry);
+            }
+            const tierRank = (t) => (t in TIER_RANK ? TIER_RANK[t] : 0);
+            if (tierRank(toTier) > tierRank(entry.toTier)) {
+                entry.toTier = toTier;
+            }
+            entry.runs.add(runId);
+            entry.weighted += w;
+        }
+    }
+    const advisories = [];
+    for (const shape of [...shapeClimbs.keys()].sort()) {
+        const info = shapeClimbs.get(shape);
+        const climbedRuns = info.runs.size;
+        const totalRuns = numDistinct;
+        const weightVal = Number.isInteger(info.weighted) ? info.weighted : Number(info.weighted.toFixed(2));
+        advisories.push(`${shape}: climbed from ${info.fromTier} to ${info.toTier} in ${climbedRuns} of ${totalRuns} runs (weighted ${weightVal}) — consider routing.floors.${shape}: ${info.toTier}`);
+    }
+    return advisories;
+}

package/dist/cli/commands/resume.js

@@ -5,6 +5,7 @@ import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
 import { narrationSink, bindNarration } from "./run.js";
+import { assertRefsWritable } from "../../run/git.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
@@ -36,6 +37,7 @@ export async function resume(argv, cwd = process.cwd()) {
     if (collisions.length) {
         throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
     }
+    await assertRefsWritable(cwd, "resume");
     const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,

package/dist/cli/commands/run.js

@@ -10,6 +10,7 @@ import { formatJournalNarration, loadRoutingProfile, newRunId } from "../../run/
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
+import { assertRefsWritable } from "../../run/git.js";
 // ── the operator event rail (v1.99 T2) ──────────────────────────────────────────────────────────
 // A run's TTY narration is an operator EVENT RAIL, not the journal dump it used to echo. The
 // repetitive worker-contact / worker-status polls and the ungated phase-start rows are the bulk of
@@ -35,6 +36,7 @@ const RAIL_TONES = {
 };
 /** Approval-close lifecycle labels extend the established closed rail vocabulary. */
 export const APPROVAL_RAIL_ROWS = {
+    "end-condition-held": { label: "close held", tone: "attention" },
     "approval-window-start": { label: "approval window", tone: "attention" },
     "approval-window-expired": { label: "approval window expired", tone: "attention" },
     "tip-verify-cancelled": { label: "tip verify cancelled", tone: "attention" },
@@ -60,10 +62,16 @@ export const RAIL_ROWS = {
     // run lifecycle
     "run-start": { label: "started", tone: "active" },
     "run-resume": { label: "resumed", tone: "active" },
+    "restore-rerouted": { label: "restore rerouted", tone: "attention" },
+    "tier-escalated": { label: "tier climbed", tone: "attention" },
     "resume-restore": { label: "restored", tone: "neutral" },
     // the operator's audited --graph-changed release: the resumed run journals it through this sink
     "graph-rehash": { label: "graph rehashed", tone: "attention" },
     "lock-reclaimed": { label: "lock reclaimed", tone: "neutral" },
+    // WB-1 (OBS-988): the daemon noticed its own cockpit die and what it did about it
+    "watch-board-lost": { label: "board lost", tone: "attention" },
+    "watch-board-reopened": { label: "board reopened", tone: "pass" },
+    "watch-board-reopen-failed": { label: "board reopen failed", tone: "fail" },
     "run-end": { label: "finished", tone: "neutral" },
     "tip-verify": { label: "tip verify", tone: "pass" },
     "tip-verify-failed": { label: "tip verify", tone: "fail" },
@@ -124,6 +132,7 @@ export const RAIL_ROWS = {
     "gate-result": { label: "gate", tone: "pass" },
     "baseline-wait": { label: "baseline wait", tone: "active" },
     "suite-budget": { label: "suite budget", tone: "attention" },
+    "gate-replayed": { label: "gate replayed", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
     "judge-retry": { label: "judge retry", tone: "attention" },
     "review-no-verdict": { label: "review unavailable", tone: "attention" },
@@ -213,6 +222,8 @@ const RAIL_SALIENT = [
     // both journal `gates: string[]` and neither states a scalar the ladder can pick up
     { key: "gates", render: (v) => (Array.isArray(v) && v.length > 0 ? `gates ${v.join(", ")}` : undefined) },
     { key: "channel", render: (v) => (typeof v === "string" ? `channel ${v}` : undefined) },
+    // the pane a board was lost on or reopened in — nothing on the ladder names it
+    { key: "pane", render: (v) => (typeof v === "string" ? `pane ${v}` : undefined) },
     { key: "status", render: (v) => (typeof v === "string" ? `status ${v}` : undefined) },
     { key: "cause", render: (v) => (typeof v === "string" ? `cause ${v}` : undefined) },
     { key: "silentMs", render: (v) => (typeof v === "number" ? `silent ${Math.round(v / 1000)}s` : undefined) },
@@ -491,6 +502,7 @@ export async function run(argv, cwd = process.cwd()) {
             if (lints.length)
                 throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
         }
+        await assertRefsWritable(cwd, "run");
         // The run id is minted HERE rather than inside the daemon, because the narration sink has to know
         // which run it is narrating before the first event arrives (the daemon's `narrate` callback is
         // handed an event and nothing else, and `run-start` carries no run id). `runDaemon` uses the id

package/dist/cli/commands/status.js

@@ -825,23 +825,17 @@ const liveness = (events, daemon, now = Date.now()) => {
     const state = daemon.state === "alive" ? "alive" : ended ? "finished" : "dead";
     return `last event ${age} ago · daemon pid ${daemon.pid} ${state}${cause ? ` · ${cause}` : ""}`;
 };
-// Resume's shared comparator remains the fail-closed baseline. Status may additionally accept the
-// daemon's audited graph-rehash release, but only when its `from` names that baseline identity (or
-// null for an explicitly released legacy journal) and its `to` names the graph loaded now.
+// OBS-978: the one comparator resume, plan and the operator fold read decides the join — it already
+// audits the rehash chain. When it binds and the journal holds a graph-rehash, the newest row is the
+// audit that bound the loaded graph; rehashAt marks the facts recorded against a prior graph.
 const statusEngagement = (events, loadedHash) => {
-    const baseline = engagementComparable(events, loadedHash);
+    if (!engagementComparable(events, loadedHash).comparable)
+        return { comparable: false };
     for (let i = events.length - 1; i >= 0; i--) {
-        const event = events[i];
-        if (event.event !== "graph-rehash")
-            continue;
-        const auditsBaseline = baseline.comparable || baseline.reason === "mismatch"
-            ? event.data.from === baseline.recorded
-            : event.data.from === null;
-        return event.data.to === loadedHash && auditsBaseline
-            ? { comparable: true, rehashAt: i }
-            : { comparable: false };
+        if (events[i].event === "graph-rehash")
+            return { comparable: true, rehashAt: i };
     }
-    return { comparable: baseline.comparable };
+    return { comparable: true };
 };
 // The journal's own reader rule (src/run/journal.ts readJsonl), applied to bytes already in hand:
 // skip blanks, drop a line that will not parse (a torn trailing write after a crash), keep the rest.

package/dist/compile/collateral.d.ts

@@ -28,6 +28,8 @@ export declare function classifyScopeOffenders(taskId: string, hard: ReadonlyArr
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.
+ * OBS-971: uncapped — every predicted path is listed, with direct importers of an owned source
+ * sorted first, followed by the total count. The runtime map (collateralHits) remains unchanged.
  */
 export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
 /**

package/dist/compile/collateral.js

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join, relative } from "node:path";
+import { extname, join, posix, relative } from "node:path";
 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";
@@ -156,20 +156,61 @@ export function classifyScopeOffenders(taskId, hard, predicted) {
     const missed = hard.filter((f) => !named.has(f));
     return { authoring: hard.length > 0 && missed.length === 0, predicted: hit, missed, repair: filesRepair(taskId, hit) };
 }
+const moduleKey = (path) => path.replace(/\\/g, "/").replace(/\.(?:[cm]?[jt]sx?)$/, "");
+function directImportSpecifiers(text) {
+    // Comments cannot create an edge. Keep strings intact because they are the import target.
+    const source = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+    const specifiers = new Set();
+    for (const match of source.matchAll(/\bimport\s+(?:type\s+)?(?:[\w$*{},\s]+?\s+from\s+)?["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    for (const match of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+        specifiers.add(match[1]);
+    }
+    return [...specifiers];
+}
+function directlyImports(testPath, testText, sourcePath) {
+    const target = moduleKey(sourcePath);
+    const testDir = posix.dirname(testPath.replace(/\\/g, "/"));
+    return directImportSpecifiers(testText).some((specifier) => {
+        const imported = specifier.startsWith(".")
+            ? posix.normalize(posix.join(testDir, specifier))
+            : specifier.startsWith("src/") ? specifier : "";
+        return imported !== "" && moduleKey(imported) === target;
+    });
+}
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.
+ * OBS-971: uncapped — every predicted path is listed, with direct importers of an owned source
+ * sorted first, followed by the total count. The runtime map (collateralHits) remains unchanged.
  */
 export function collateralLints(tasks, repoRoot) {
     const lines = [];
-    for (const [id, hits] of collateralHits(tasks, repoRoot)) {
-        const listed = hits.slice(0, MAX_HITS_PER_TASK).join(", ");
-        // OBS-547: the cap hides names, never predictions. Say so, and say where the hidden ones surface —
-        // a count with no route is exactly what left one run's victim unreadable.
-        const tail = hits.length > MAX_HITS_PER_TASK
-            ? ` (${hits.length} total; ${MAX_HITS_PER_TASK} shown, ${hits.length - MAX_HITS_PER_TASK} capped out of view`
-                + ` but RETAINED for the scope gate — a matching scope red prints the hidden path with its files[] repair)`
-            : "";
+    const hitsMap = collateralHits(tasks, repoRoot);
+    const read = makeReader(repoRoot);
+    const tasksById = new Map(tasks.map((t) => [t.id, t]));
+    for (const [id, hits] of hitsMap) {
+        const t = tasksById.get(id);
+        const files = (t?.files ?? []).map((f) => f.replace(/^\.\//, ""));
+        const ownedSources = files.filter(isSrcPath);
+        const direct = [];
+        const indirect = [];
+        for (const h of hits) {
+            const text = read(h) ?? "";
+            const isDirect = ownedSources.some((src) => directlyImports(h, text, src));
+            if (isDirect) {
+                direct.push(h);
+            }
+            else {
+                indirect.push(h);
+            }
+        }
+        direct.sort((a, b) => a.localeCompare(b));
+        indirect.sort((a, b) => a.localeCompare(b));
+        const ordered = [...direct, ...indirect];
+        const listed = ordered.join(", ");
+        const tail = hits.length > MAX_HITS_PER_TASK ? ` (${hits.length} total)` : "";
         lines.push(`${id}: likely collateral tests not in files[]: ${listed}${tail}`);
     }
     return lines;

package/dist/compile/ownership.d.ts

@@ -13,6 +13,12 @@ export type OwnershipFinding = {
     taskIds: string[];
     corroboration?: OwnershipCorroboration;
     detail: string;
+} | {
+    code: "unowned-shape-oracle";
+    taskId: string;
+    source: string;
+    oracle: string;
+    detail: string;
 } | {
     code: "test-path-outside-allowlist";
     taskId: string;
@@ -25,7 +31,17 @@ export type OwnershipFinding = {
     ownerTaskId: string;
     path: string;
     detail: string;
+} | {
+    code: "unowned-source-of-owned-test";
+    taskId: string;
+    test: string;
+    source: string;
+    corroboration?: OwnershipCorroboration;
+    detail: string;
 };
+export declare const SHAPE_ORACLES: readonly ["tests/run/narration.test.ts", "tests/cli/brand-surfaces.test.ts", "tests/run/notify-identity.test.ts", "tests/run/outcome-projections.test.ts", "tests/cockpit/setup.test.ts"];
+export declare const SHAPE_ORACLE_SOURCES: readonly ["src/run/daemon.ts", "src/cli/commands/run.ts"];
+export declare const SHAPE_ORACLE_MAP: Record<string, readonly string[]>;
 /**
  * Cross-task ownership evidence. Findings are data: this checker never throws or changes the graph;
  * the compile seam promotes only a corroborated unowned-test finding and reports every other shape.