tickmarkr 2.5.6 → 2.5.8

package/dist/adapters/prompt.js

@@ -71,9 +71,29 @@ function workerVerdictWitness(raw, nonce, positions) {
 // these — a result carrying any other summary is a PARSED trailer, i.e. the worker speaking.
 export const NO_TRAILER_SUMMARY = "worker produced no TICKMARKR_RESULT trailer";
 export const UNPARSEABLE_TRAILER_SUMMARY = "unparseable TICKMARKR_RESULT trailer";
+// OBS-1062: every interactive TUI echoes the brief into the pane, and the brief carries the trailer
+// TEMPLATE above — so the nonce token is on screen before the worker has said anything. A token
+// whose object opens with the template's literal `"ok":true|false` (not a bool) is the brief being
+// displayed, never the worker speaking; it must not count as trailer participation, or the daemon
+// reaps the attempt as malformed at its first poll (v2.5.7 run …115246, both workers at 34 s).
+const TEMPLATE_BODY = '{"ok":true|false';
+// Bounded to THIS occurrence (review finding, Leg 0a R2): the `{` must sit before the next nonce
+// token, or a malformed worker token followed by a later template redraw would be erased as echo.
+function isTemplateEcho(raw, at, end) {
+    const open = raw.indexOf("{", at);
+    if (open === -1 || open >= end)
+        return false;
+    const joined = raw
+        .slice(open, open + 64)
+        .split("\n")
+        .map((l) => l.replace(/^[\s│|]+/, "").replace(/[\s│|]+$/, ""))
+        .join("");
+    return joined.startsWith(TEMPLATE_BODY);
+}
 export function parseWorkerResult(raw, nonce) {
     const fail = (summary, cause) => ({ ok: false, summary, deviations: [], raw, cause });
-    const positions = trailerTokenPositions(raw, nonce);
+    const all = trailerTokenPositions(raw, nonce);
+    const positions = all.filter((at, i) => !isTemplateEcho(raw, at, all[i + 1] ?? raw.length));
     // TUIs echo the prompt template, redraw lines, and HARD-wrap the JSON with per-line margins
     // (cursor does; recent-unwrapped can't rejoin hard newlines). Scan occurrences backward — last
     // parseable wins — joining wrapped lines, stripping margin/box chrome, and growing the candidate

package/dist/cli/commands/approve.js

@@ -1,11 +1,11 @@
-import { graphDefinitionHash, loadGraph, saveGraph } from "../../graph/graph.js";
+import { graphDefinitionHash, loadGraph, saveGraph, taskDefinitionFingerprint } from "../../graph/graph.js";
 import { execFileSync } from "node:child_process";
 import { userInfo } from "node:os";
 import { loadConfig } from "../../config/config.js";
 import { integrationBranch } from "../../run/merge.js";
-import { separabilityErrors } from "../../compile/collateral.js";
+import { separabilityErrors, surfaceErrors, taskBudgetErrors } from "../../compile/collateral.js";
 import { GATE_NAMES } from "../../graph/schema.js";
-import { applyScopeAmendments, engagementComparable, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
+import { applyScopeAmendments, engagementComparable, engagementReleased, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
 export const APPROVAL_DISPOSITIONS = ["dispatch", "waive-gate", "re-dispatch", "fund-fixed-attempt", "fresh-budget"];
 /**
  * What each disposition's release actually buys — the clause every operator-facing sentence about
@@ -178,7 +178,7 @@ export async function approve(argv, cwd = process.cwd()) {
                 throw new Error(`scope-request for ${taskId} requires --files <glob,…>`);
             if (decisions)
                 throw new Error("--files cannot be combined with --waive, --uphold or --recheck");
-            const graph = applyScopeAmendments(loadGraph(cwd), journal);
+            const graph = applyScopeAmendments(loadGraph(cwd), journal, false, engagementReleased(events));
             const from = graphDefinitionHash(graph);
             if (!engagementComparable(journal.read(), from).comparable
                 || (lastHuman?.data.graphDefinitionHash !== undefined && lastHuman.data.graphDefinitionHash !== from)) {
@@ -194,13 +194,20 @@ export async function approve(argv, cwd = process.cwd()) {
             const conflicts = separabilityErrors(amended.tasks);
             if (conflicts.length)
                 throw new Error(`refusing scope-request approval for ${taskId}: ${conflicts.join("\n")}`);
+            // C4: a live grant may not take a task past the bounds that fail every compile. The exception
+            // list is EMPTY on purpose — a recorded historical compile exception confers no live authority.
+            const overBound = [...taskBudgetErrors([{ ...task, files: amendedFiles }]), ...surfaceErrors([{ ...task, files: amendedFiles }], [])];
+            if (overBound.length) {
+                throw new Error(`refusing scope-request approval for ${taskId}: ${overBound.join("\n")}\n`
+                    + `remedy: close the run, split the task in its spec, recompile, then \`tickmarkr resume ${runId} --graph-changed\``);
+            }
             journal.append("task-approved", taskId, {
                 by, ...(reason ? { reason } : {}), via: "cli", release: "scope-request",
-                amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line },
+                amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line, definition: taskDefinitionFingerprint(task) },
             });
             // Do not write graph.json from this process while the daemon owns it: its sweep materializes
             // the amendment without replacing a sibling's running state with this command's snapshot.
-            const projected = applyScopeAmendments(graph, journal);
+            const projected = applyScopeAmendments(graph, journal, false, engagementReleased(events));
             const owner = approvalRunOwner(cwd, runId);
             if (!owner.live && !owner.blockingRunId)
                 saveGraph(cwd, projected);

package/dist/cli/commands/compile.js

@@ -3,6 +3,7 @@ import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeFindings, sourceScopeLints, } from "../../compile/collateral.js";
 import { CompileError } from "../../compile/common.js";
 import { compileSource } from "../../compile/index.js";
+import { retiredLiteralErrors } from "../../compile/retired-literals.js";
 import { clearCompileRefusal, saveCompileRefusal, saveGraph, stateDirName } from "../../graph/graph.js";
 import { formatPriorFindingEvidence, readPriorRunEvidence } from "../../run/journal.js";
 import { shGit } from "../../run/git.js";
@@ -75,6 +76,12 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
         if (unwaived.length > 0) {
             throw new CompileError(`${src} has unwaived native source-scope authoring errors:\n${unwaived.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
         }
+        // v2.5.8 T14: a declared pin whose obligated file the declaring task does not own refuses the seal
+        // here, before any state write, so a dry run reaches the same refusal. Diagnostic only: never widens scope.
+        const uncovered = retiredLiteralErrors(g.tasks, cwd);
+        if (uncovered.length > 0) {
+            throw new CompileError(`${src} has uncovered declared pin obligations:\n${uncovered.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
+        }
         // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
         // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
         // remain the source compiler's answer.

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

@@ -1,6 +1,11 @@
+import { type Task } from "../../graph/schema.js";
 import { type VitestListResult } from "../../gates/acceptance.js";
 import { type WorkerAdapter } from "../../adapters/types.js";
 export type PlanOpts = {
     listTests?: (cwd: string) => Promise<VitestListResult>;
 };
+export declare function plannedOracleDisposition(task: Pick<Task, "files" | "acceptance">, listing: VitestListResult): {
+    refusals: string[];
+    advisories: string[];
+};
 export declare function plan(argv: string[], cwd?: string, adapters?: WorkerAdapter[], harnessFrom?: string | undefined, opts?: PlanOpts): Promise<string>;

package/dist/cli/commands/plan.js

@@ -8,6 +8,7 @@ import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
 import { chainDepth, dispatchWaves, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
+import { filesGlob } from "../../graph/files-glob.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -47,6 +48,32 @@ const fleetCanCrossVendorReview = (channels) => {
                 return true;
     return false;
 };
+// Planning can defer authorship only to this criterion's explicitly owned landing.
+// This advisory does not change runtime oracle execution or name resolution.
+export function plannedOracleDisposition(task, listing) {
+    const refusals = [];
+    const advisories = [];
+    const items = task.acceptance.filter((item) => typeof item === "object" && item.oracle === "test");
+    if (listing.status === "failed") {
+        if (items.length)
+            refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
+        return { refusals, advisories };
+    }
+    const owns = filesGlob(task.files.map((path) => path.replace(/^\.\//, "")));
+    for (const item of items) {
+        const audit = auditNamedTestOracles([item], listing.tests)[0];
+        if (audit.matches.length === 0 && item.landing && owns(item.landing)) {
+            advisories.push(`acceptance oracle ${JSON.stringify(audit.criterion)} not yet written (worker authors ${item.landing})`);
+        }
+        else if (audit.matches.length === 0) {
+            refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
+        }
+        else if (audit.matches.length > 1) {
+            refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches ${audit.matches.length} runner-listed test names`);
+        }
+    }
+    return { refusals, advisories };
+}
 const NAMED_CRITERION_PATH = /(?:^|[\s("'`])((?:src|tests|fixtures|scripts)\/[A-Za-z0-9_@{}*?.,/+-]+\.(?:tsx|ts|jsx|json|js|mjs|cjs|md|txt))(?![A-Za-z0-9])/g;
 const judgeOracle = (task) => task.acceptance.some((item) => typeof item === "string" || (typeof item === "object" && item.oracle === "judge"));
 const latestRunStatusLine = (cwd) => {
@@ -166,29 +193,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
         const listing = await (opts.listTests ?? listVitestTests)(cwd);
         for (const task of g.tasks) {
-            const refusals = [];
-            const advisories = [];
-            const authoredTest = task.files
-                .map((path) => path.replace(/^\.\//, ""))
-                .find((path) => /^tests\/.+\.test\.ts$/.test(path) && !/[?*{[]/.test(path) && !existsSync(join(cwd, path)));
-            if (listing.status === "failed") {
-                if (task.acceptance.some((item) => typeof item === "object" && item.oracle === "test")) {
-                    refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
-                }
-            }
-            else {
-                for (const audit of auditNamedTestOracles(task.acceptance, listing.tests)) {
-                    if (audit.matches.length === 0 && authoredTest) {
-                        advisories.push(`acceptance oracle ${JSON.stringify(audit.criterion)} not yet written (worker authors ${authoredTest})`);
-                    }
-                    else if (audit.matches.length === 0) {
-                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
-                    }
-                    else if (audit.matches.length > 1) {
-                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches ${audit.matches.length} runner-listed test names`);
-                    }
-                }
-            }
+            const { refusals, advisories } = plannedOracleDisposition(task, listing);
             if (refusals.length)
                 oracleRefusals.set(task.id, refusals);
             if (advisories.length)

package/dist/cli/commands/resume.js

@@ -39,7 +39,7 @@ export async function resume(argv, cwd = process.cwd()) {
     }
     await assertRefsWritable(cwd, "resume");
     const host = classifyHost();
-    preflightHostDriver(cfg, driverOverride, host);
+    await preflightHostDriver(cfg, driverOverride, host, cwd);
     const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,

package/dist/cli/commands/run.js

@@ -511,7 +511,7 @@ export async function run(argv, cwd = process.cwd()) {
         }
         await assertRefsWritable(cwd, "run");
         const host = classifyHost();
-        preflightHostDriver(cfg, driverOverride, host);
+        await preflightHostDriver(cfg, driverOverride, host, cwd);
         // 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

@@ -7,8 +7,11 @@ import { HerdrDriver } from "../../drivers/herdr.js";
 import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
-import { foldActivity } from "../../run/activity.js";
-import { Journal, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
+import { projectActivity } from "../../run/activity.js";
+import { projectOperatorSummary } from "../../run/operator-summary.js";
+import { trackJournalRows } from "../../run/protocol.js";
+import { newestPark, permittedDecisionVerbs } from "./approve.js";
+import { Journal, formatJournalNarration, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
 import { isPidLive, runLockRunId, runStatusLine } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
@@ -96,8 +99,8 @@ const taskClockReference = (events, taskId, content, fallback) => {
     }
     return fallback;
 };
-// Every attempt number a cell phrase carries is the engagement's own ladder (foldActivity counts
-// dispatch labels from 1). Name that ruler wherever a bare one appears, not only in the one phrase
+// Every attempt number a cell phrase carries is the engagement's own ladder (journal dispatch
+// labels are displayed from 1). Name that ruler wherever a bare one appears, not only in the one phrase
 // shipping today — a phrase added upstream must not reach the operator unruled.
 const labelAttemptRuler = (text) => text.replace(/(?<!engagement |run )\battempt (?=\d)/gu, "engagement attempt ");
 // The timer must keep the process ALIVE: an unref'd timer here let the event loop drain after the
@@ -907,9 +910,58 @@ const readRunRecord = (cwd, graph, namedRunId) => {
  * catch an empty or torn first write. Those snapshots own no task fold yet; once run-start exists,
  * however, a fold failure is unexpected and must surface instead of becoming a false empty run.
  */
-const recordTaskRows = (record, graph) => record.comparable && record.events.some((event) => event.event === "run-start")
-    ? new Map(deriveRunCockpitData({ fileName: `${record.runId}.journal.jsonl`, raw: record.raw }, "status", { graph }).taskRows.map((row) => [row.taskId, row]))
+const recordTaskRows = (record, graph, isDaemonAlive) => record.comparable && record.events.some((event) => event.event === "run-start")
+    ? new Map(deriveRunCockpitData({ fileName: `${record.runId}.journal.jsonl`, raw: record.raw }, "status", { graph, isDaemonAlive }).taskRows.map((row) => [row.taskId, row]))
     : new Map();
+/** Adapt the single journal snapshot to the shared, evidence-only projections. */
+const recordProjection = (record, graph, isDaemonAlive) => {
+    const rows = record ? recordTaskRows(record, graph, isDaemonAlive) : new Map();
+    const events = record?.comparable ? record.events : [];
+    const activity = projectActivity(record?.runId ?? "", trackJournalRows(record?.runId ?? "", events.map((raw, sourceIndex) => ({ raw, sourceIndex }))), graph.tasks);
+    const tasks = graph.tasks.map(task => {
+        const row = rows.get(task.id);
+        const evidence = events.filter(event => event.taskId === task.id);
+        const last = evidence.at(-1);
+        const recorded = activity.get(task.id);
+        let phase = last ? recorded.state : undefined;
+        // A completed battery is evidence of readiness, never evidence that merge started.
+        const gates = gateSnapshot(task, events, record?.rehashAt);
+        const boundary = events.reduce((index, event, at) => ["run-start", "run-resume", "run-end"].includes(event.event)
+            || (event.taskId === task.id && (event.event === "task-dispatch"
+                || (event.event === "phase-start" && event.data.phase === "gates"))) ? at : index, -1);
+        // Read the latest outcome, including non-verdicts. The gate rail retains earlier
+        // verdicts while a screen or infrastructure retry is pending; that historical
+        // pass must not make the current battery look ready to merge.
+        const currentResults = new Map(events.slice(boundary + 1).filter(event => event.taskId === task.id && event.event === "gate-result")
+            .map(event => [event.data.gate, normalizeGateOutcome(event.data).kind]));
+        if (recorded.state === "unconfirmed" && task.gates.length > 0 && !gates.priorGraph
+            && task.gates.every(gate => currentResults.get(gate) === "passed")) {
+            phase = "awaiting merge phase";
+        }
+        const responsibility = [...evidence].reverse().find(event => typeof event.data.role === "string" || typeof event.data.agent === "string");
+        return {
+            id: task.id, deps: task.deps, status: row?.state ?? task.status,
+            phase, lastEvidenceAt: last?.ts,
+            responsible: responsibility ? {
+                role: typeof responsibility.data.role === "string" ? responsibility.data.role : undefined,
+                agent: typeof responsibility.data.agent === "string" ? responsibility.data.agent : undefined,
+            } : undefined,
+        };
+    });
+    const decisions = tasks.flatMap(task => {
+        const park = task.status === "human" ? newestPark(events, task.id) : undefined;
+        return park ? [{ taskId: task.id, park, verbs: permittedDecisionVerbs(park) }] : [];
+    });
+    return { rows, activity, summaries: new Map(projectOperatorSummary(tasks, decisions).map(task => [task.taskId, task])) };
+};
+const summaryText = (summary) => sanitizeTaskText([
+    `phase ${summary.phase ?? "unrecorded"}`,
+    `last evidence ${summary.lastEvidenceAt ?? "unrecorded"}`,
+    `responsible ${[summary.responsible?.role, summary.responsible?.agent].filter(Boolean).join(" / ") || "unrecorded"}`,
+    `blocker ${summary.blocker?.kind ?? "none"}`,
+    `next action ${summary.blocker?.nextAction ?? "unrecorded"}`,
+    `human-decision ${summary.blocker?.decisionRequired ? "yes" : "no"}`,
+].join(" · "));
 /** The graph tasks this run's record actually speaks about — a row with no recorded fact is silence. */
 const recordedTasks = (graph, rows) => graph.tasks.filter((task) => {
     const row = rows.get(task.id);
@@ -936,14 +988,11 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const comparable = record?.comparable ?? false;
     const rehashAt = record?.rehashAt;
     const assignments = new Map();
-    let replayed = null;
     const contexts = new Map();
     // v1.53 T5: this run is dead — a newer run replaced it
     const supersededBy = [...events].reverse()
         .find((e) => e.event === "superseded" && typeof e.data.by === "string")?.data.by;
     if (record && comparable) {
-        if (!journalRowsOnly)
-            replayed = Journal.open(cwd, record.runId).replayStatuses();
         for (const e of events) {
             if (!journalRowsOnly && e.event === "task-dispatch" && e.taskId) {
                 const a = e.data.assignment;
@@ -956,7 +1005,12 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             }
         }
     }
-    const taskRows = record && journalRowsOnly ? recordTaskRows(record, g) : new Map();
+    const projection = recordProjection(record, g, () => daemon.state !== "dead");
+    const taskRows = projection.rows;
+    // Preserve the plain table's compact status vocabulary using the same snapshot as its evidence.
+    const replayed = new Map([...taskRows].flatMap(([id, row]) => row.state === undefined ? [] : [[id,
+            row.state === "running" || row.state === "interrupted" ? "pending" : graphTaskStatus(row.state, "pending"),
+        ]]));
     const clockFallback = new Date(now);
     const recordedClock = new Date(events.at(-1)?.ts ?? now);
     const zoneReference = Number.isFinite(recordedClock.getTime()) ? recordedClock : clockFallback;
@@ -973,14 +1027,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     };
     const renderedTasks = journalRowsOnly ? recordedTasks(g, taskRows) : g.tasks;
     const starved = new Set(blockedTasks(effective).map((t) => t.id));
-    // OBS-104: ONE activity fold feeds both surfaces — never re-derived here. Comparable events only
-    // (a recompiled graph's journal must not animate the wrong tasks); with no or stale journal the
-    // dep-waiting cells still derive from the effective graph statuses.
-    const activity = foldActivity(comparable ? events : [], effective.tasks);
-    // RULING-v189-scope §14c: a card answers BOTH supervisor questions. `foldActivity` names what a
-    // task waits FOR; this names what waits ON it. Read from `effective.tasks` — whose statuses are
-    // the journal's replay, never the compiled graph's — so a dependent the record says is done stops
-    // being named, and a task all of whose dependents are done acquires no entry at all.
+    // Reverse dependencies share the effective task statuses with the projection.
     const dependents = new Map();
     for (const task of effective.tasks) {
         if (task.status === "done")
@@ -1039,7 +1086,18 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             || (st === "failed" && failureKind === undefined));
         const livePhase = phases.get(t.id);
         const isStarved = !livePhase && starved.has(t.id);
-        const rawPhrase = livePhase ? phaseDetail(livePhase, now, workerLiveness.get(t.id)) : isStarved ? undefined : activity.cells.get(t.id);
+        const summary = projection.summaries.get(t.id);
+        // Attempt labels can restart at zero in legacy engagements. Pair the preparing caption's
+        // counter and timestamp from the same dispatch, rather than retaining a prior higher label.
+        const dispatch = [...events].reverse().find(event => event.taskId === t.id && event.event === "task-dispatch");
+        const projectedPhrase = summary.blocker?.kind === "dependency-wait"
+            ? `dep-waiting on ${summary.blocker.prerequisites.join(", ")}`
+            : summary.phase === "terminal"
+                ? st === "human" ? `parked${failureKind ? ` (${failureKind})` : ""}` : undefined
+                : summary.phase === "preparing" && dispatch
+                    ? `preparing · attempt ${(Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0) + 1} since ${dispatch.ts.slice(11, 19)}`
+                    : summary.phase ?? undefined;
+        const rawPhrase = livePhase ? phaseDetail(livePhase, now, workerLiveness.get(t.id)) : projectedPhrase;
         const phrase = rawPhrase === undefined
             ? undefined
             : journalRowsOnly
@@ -1053,12 +1111,12 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             ? gateSnapshot(t, events, rehashAt)
             : { states: defaultGateStates(t), priorGraph: false };
         const pane = panes.get(t.id);
-        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, pane, ...gates };
+        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, pane, summary, ...gates };
     });
     if (!unicode) {
-        // machine/CI surface — journals without phase-start stay byte-identical; new phase-aware frames
-        // use an ASCII spinner so pipes never receive terminal-only braille/ANSI.
-        const rows = cells.flatMap(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane }) => {
+        // Keep the machine task-title columns intact; projection details occupy their own line.
+        // Phase-aware frames use ASCII spinners so pipes never receive terminal-only braille/ANSI.
+        const rows = cells.flatMap(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane, summary }) => {
             const chain = gateChain(states, false);
             const prefix = livePhase ? `  ${ASCII_SPINNER[animationFrame % ASCII_SPINNER.length]} ${t.id} ` : `  ${surfaceTaskBox(st, merged)} ${t.id} `;
             const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}${pane ? `  pane ${pane}` : ""}`;
@@ -1069,6 +1127,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             // (a pane name is 60 columns on its own), so the floor costs wrapping, never the graph.
             return [
                 `${prefix}${shortGoal(t.title, Math.max(MACHINE_TITLE_FLOOR, width - prefix.length - suffix.length))}${suffix}`,
+                `    ${summaryText(summary)}`,
                 ...recoveryLinesForTask(t.id).map((line) => `    ${line}`),
             ];
         });
@@ -1142,7 +1201,8 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         besideLockup(fillLockup(dim(versionText), versionCells), factLines[1]),
         ...factLines.slice(2).map((line) => `${" ".repeat(lockupCells + lockupGapCells)}${line}`),
     ];
-    const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
+    const lastEvent = comparable ? events.at(-1) : undefined;
+    const nowLine = lastEvent ? [legend(`   now: ${formatJournalNarration(lastEvent)}`)] : [];
     const supervisionLegend = legend(`   ${supervisionText(supervision)}`);
     const taskSectionSummary = `${done} of ${total} merged · rows in graph order · gates left→right in pipeline order`;
     const taskSection = `  ${ok("▌")} ${title("TASKS")}   ${dim(taskSectionSummary)}`;
@@ -1220,6 +1280,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                     `    ${tone(cell.t.id)}  ${dim(taskArea(cell.t))}  ${sanitizeTaskText(cell.t.title)}`,
                     ...wrapCells(`    ${dim(machinery)}`, boardColumns, { continuationPrefix: "      " }),
                     ...wrapCells(`    ${dim(noteFor(cell))}`, boardColumns, { continuationPrefix: "      " }).filter((line) => line.trim()),
+                    ...wrapCells(`    ${dim(summaryText(cell.summary))}`, boardColumns, { continuationPrefix: "      " }),
                     "",
                 ];
             });
@@ -1249,15 +1310,15 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                             ? running
                             : dim;
             const titleTone = cell.redTier || cell.livePhase || (effort?.parks ?? 0) >= 3 ? title : dim;
-            return Array.from({ length: height }, (_, index) => `    ${idTone(fitColumn(columns[0][index] ?? "", idWidth, 1))}`
-                + dim(fitColumn(columns[1][index] ?? "", areaWidth))
-                + dim(fitColumn(columns[2][index] ?? "", depsWidth))
-                + titleTone(fitColumn(columns[3][index] ?? "", taskWidth))
-                + fitCells(columns[4][index] ?? "", gatesWidth)
-                + "  "
-                + dim(fitColumn(columns[5][index] ?? "", channelWidth))
-                + dim(fitColumn(columns[6][index] ?? "", attemptWidth, 1))
-                + dim(fitCells(columns[7][index] ?? "", noteWidth)));
+            return [...Array.from({ length: height }, (_, index) => `    ${idTone(fitColumn(columns[0][index] ?? "", idWidth, 1))}`
+                    + dim(fitColumn(columns[1][index] ?? "", areaWidth))
+                    + dim(fitColumn(columns[2][index] ?? "", depsWidth))
+                    + titleTone(fitColumn(columns[3][index] ?? "", taskWidth))
+                    + fitCells(columns[4][index] ?? "", gatesWidth)
+                    + "  "
+                    + dim(fitColumn(columns[5][index] ?? "", channelWidth))
+                    + dim(fitColumn(columns[6][index] ?? "", attemptWidth, 1))
+                    + dim(fitCells(columns[7][index] ?? "", noteWidth))), ...wrapCells(`    ${dim(summaryText(cell.summary))}`, boardColumns, { continuationPrefix: "      " })];
         });
         return [legend(headerRow), dim(ruleRow), ...rows];
     };
@@ -1305,7 +1366,7 @@ const oneLine = (cwd, namedRunId) => {
     const record = readRunRecord(cwd, graph, namedRunId);
     if (!record)
         return sanitizeTaskText(`tickmarkr · no runs yet · 0/${graph.tasks.length} done`);
-    const rows = recordTaskRows(record, graph);
+    const { rows } = recordProjection(record, graph);
     const claims = record.comparable
         ? [
             `${recordedDone(recordedTasks(graph, rows), rows)}/${graph.tasks.length} done`,

package/dist/cli/commands/verify.js

@@ -150,10 +150,12 @@ export async function verify(argv, cwd = process.cwd()) {
         allowPositionals: false,
     });
     const stateRoot = await verifyStateRoot(cwd);
+    const fileRoot = (file) => existsSync(join(cwd, ".tickmarkr", file)) ? cwd : stateRoot;
     if (resolve(stateRoot) !== resolve(cwd)) {
-        console.error(`verify: state files graph.json, doctor.json and config.yaml resolved read-only from ${join(stateRoot, ".tickmarkr")} (linked worktree)`);
+        console.error(`verify: state files resolved read-only from ${join(stateRoot, ".tickmarkr")} (linked worktree; per-file origins: `
+            + STATE_FILES.map(file => `${file}: ${join(fileRoot(file), ".tickmarkr", file)} (${fileRoot(file) === cwd ? "local" : "common root"})`).join("; ") + ")");
     }
-    const cfg = loadConfig(stateRoot);
+    const cfg = loadConfig(fileRoot("config.yaml"));
     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`);
@@ -167,7 +169,7 @@ export async function verify(argv, cwd = process.cwd()) {
     let files = values.files ?? [];
     let goal = `independent verification of the ${values.base}..HEAD diff`;
     if (values.task) {
-        const t = getTask(loadGraph(stateRoot), values.task);
+        const t = getTask(loadGraph(fileRoot("graph.json")), values.task);
         acceptance = t.acceptance;
         if (!files.length)
             files = t.files;
@@ -223,7 +225,7 @@ export async function verify(argv, cwd = process.cwd()) {
     let author = HUMAN_AUTHOR;
     const adapters = allAdapters();
     if (wantAcceptance || wantReview) {
-        const health = readDoctor(stateRoot) ?? (await probeAll(adapters));
+        const health = readDoctor(fileRoot("doctor.json")) ?? (await probeAll(adapters));
         const pools = rolePools(cfg, adapters, health);
         judgeChannels = pools.judge;
         channels = pools.review;

package/dist/compile/native.js

@@ -69,7 +69,51 @@ const NESTED_RE = /^\s+- (.+)$/;
 // v1.19: a typed acceptance oracle line — "command: ...", "test: ...", or "judge: ...". Anything
 // without one of these prefixes is a plain-string judge criterion (compat path, emits a warning).
 const ORACLE_RE = new RegExp(`^(${ORACLES.join("|")}):\\s*(.*)$`);
-const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout"]);
+const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout", "pins"]);
+const listItems = (draft) => draft.list === "acceptance" ? draft.acceptanceRaw : draft.list === "pins" ? draft.pinsRaw : draft.gates;
+// v2.5.8 T7: one declared pin item — "literal: <exact text> | glob: <search glob>" (split at the LAST
+// " | glob: " so the text may itself hold a bar) or "fixture: <path set>". A declaration missing the
+// payload its own kind requires refuses the compile naming the task and the item.
+const PIN_GLOB_SEP = "| glob:";
+// v2.5.8 T8 (OBS-1064): "test: <title> | suite: <path>" — split at the LAST " | suite: " so the title
+// stays the verbatim leaf the gate matches and the landing path never enters it.
+const LANDING_SEP = "| suite:";
+function parsePin(task, raw, index, pathSet) {
+    const bad = (detail) => invalid(task, "pins", `item ${index + 1} (${JSON.stringify(raw)}) ${detail}`);
+    const typed = raw.match(/^(\w+):\s*(.*)$/);
+    if (typed?.[1] === "fixture") {
+        const paths = pathSet(typed[2]);
+        if (!paths.length)
+            bad("is a fixture pin missing its path set");
+        return { kind: "fixture", paths };
+    }
+    if (typed?.[1] === "literal") {
+        const at = typed[2].lastIndexOf(PIN_GLOB_SEP);
+        const text = (at < 0 ? typed[2] : typed[2].slice(0, at)).trim();
+        const glob = at < 0 ? "" : typed[2].slice(at + PIN_GLOB_SEP.length).trim();
+        if (!text)
+            bad("is a literal pin missing its text");
+        if (!glob)
+            bad(`is a literal pin missing its search glob — write "literal: <text> ${PIN_GLOB_SEP} <glob>"`);
+        return { kind: "literal", text, glob };
+    }
+    return bad('must be "literal: <text> | glob: <glob>" or "fixture: <path set>"');
+}
+function parseTestOracle(task, body, index) {
+    const at = body.lastIndexOf(LANDING_SEP);
+    if (at < 0)
+        return { oracle: "test", test: body.trim() };
+    const test = body.slice(0, at).trim();
+    const landing = body.slice(at + LANDING_SEP.length).trim();
+    const bad = (detail) => invalid(task, "acceptance", `item ${index + 1} (${JSON.stringify(body)}) ${detail}`);
+    if (!test)
+        bad("is a test oracle missing its title before the landing");
+    if (!landing)
+        bad(`is a test oracle missing its landing path — write "test: <title> ${LANDING_SEP} <path>"`);
+    if (!picomatch(COLLECTABLE_TESTS, { dot: true })(landing))
+        bad(`declares landing ${JSON.stringify(landing)} which no runner collects (${COLLECTABLE_TESTS})`);
+    return { oracle: "test", test, landing };
+}
 function invalid(task, field, detail) {
     throw new CompileError(`Task ${task} field "${field}" ${detail}`);
 }
@@ -376,7 +420,7 @@ export function compileNative(file, options = {}) {
     for (const [index, line] of content.split("\n").entries()) {
         const heading = line.match(HEAD_RE);
         if (heading) {
-            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptanceRaw: [], acceptance: [], gates: [], hasGates: false, list: null, itemOpen: false, continuationField: null });
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptanceRaw: [], acceptance: [], gates: [], hasGates: false, pinsRaw: [], list: null, itemOpen: false, continuationField: null });
             continue;
         }
         const draft = drafts.at(-1);
@@ -411,7 +455,7 @@ export function compileNative(file, options = {}) {
                 invalid(draft.id, field[1], "is unknown");
             const value = field[2].trim();
             draft.itemOpen = false;
-            if (name === "acceptance" || name === "gates") {
+            if (name === "acceptance" || name === "gates" || name === "pins") {
                 if (value)
                     invalid(draft.id, field[1], "must be a nested list");
                 draft.list = name;
@@ -459,7 +503,7 @@ export function compileNative(file, options = {}) {
             const value = nested[1].trim();
             if (!value)
                 invalid(draft.id, draft.list, "must not contain empty entries");
-            (draft.list === "acceptance" ? draft.acceptanceRaw : draft.gates).push(value);
+            listItems(draft).push(value);
             draft.itemOpen = true;
             continue;
         }
@@ -468,7 +512,7 @@ export function compileNative(file, options = {}) {
         // 1.87.0 dropped these lines silently: 53/78 of run-551's criteria compiled to first-line
         // stubs and every falsifier tail was invisible to the judge.
         if (draft.list && draft.itemOpen && (line.startsWith(" ") || line.startsWith("\t")) && line.trim()) {
-            const items = draft.list === "acceptance" ? draft.acceptanceRaw : draft.gates;
+            const items = listItems(draft);
             items[items.length - 1] += ` ${line.trim()}`;
             continue;
         }
@@ -489,14 +533,14 @@ export function compileNative(file, options = {}) {
     // OBS-488: typed-oracle prefixes parse on the COMPLETE joined item text, never its first
     // physical line — a wrapped `command:` body or falsifier tail is part of the criterion.
     for (const draft of drafts) {
-        for (const raw of draft.acceptanceRaw) {
+        for (const [index, raw] of draft.acceptanceRaw.entries()) {
             const typed = raw.match(ORACLE_RE);
             if (typed) {
                 const [, kind, body] = typed;
                 if (!body.trim())
                     invalid(draft.id, "acceptance", `${kind} oracle must carry a value`);
                 draft.acceptance.push(kind === "command" ? { oracle: "command", command: body.trim() }
-                    : kind === "test" ? { oracle: "test", test: body.trim() }
+                    : kind === "test" ? parseTestOracle(draft.id, body, index)
                         : { oracle: "judge", text: body.trim() });
             }
             else {
@@ -561,6 +605,9 @@ export function compileNative(file, options = {}) {
         return trimmed;
     };
     const csv = (value) => value && value.toLowerCase() !== "none" ? splitTop(value).map((item) => stripAnnotation(item.trim())).filter(Boolean) : [];
+    // A fixture pin's path set is split only — never annotation-stripped: "fixtures/output (old)" is a
+    // filename, and csv() would silently retarget the declared obligation to "fixtures/output".
+    const pinPaths = (value) => splitTop(value).map((item) => item.trim()).filter(Boolean);
     // OBS-97: a typed test: oracle needs a collectable home. vitest only collects COLLECTABLE_TESTS
     // paths, so a task whose non-empty files[] cannot host one makes scope-green and acceptance-green
     // mutually exclusive by construction — run-20260719-210434 burned two dispatch attempts before a
@@ -677,6 +724,7 @@ export function compileNative(file, options = {}) {
             ...(timeoutMinutes !== undefined ? { timeoutMinutes } : {}),
             ...(routingHints ? { routingHints } : {}),
             ...(draft.hasGates ? { gates: draft.gates } : {}),
+            ...(draft.pinsRaw.length ? { pins: draft.pinsRaw.map((raw, i) => parsePin(draft.id, raw, i, pinPaths)) } : {}),
         };
     });
     const result = validateGraph({
@@ -780,9 +828,19 @@ acceptance is required on every task (a nested list of observable outcomes).
     acceptance:  nested list (REQUIRED, non-empty). Each item is either a typed oracle or plain text:
                  - command: <shell>   (oracle: command — exit code)
                  - test: <name>       (oracle: test — named test)
+                 - test: <name> | suite: <path>   (same, plus the tests/**/*.test.ts file it lands in;
+                                       the path lives in the item's landing field, never in the title)
                  - judge: <rubric>    (oracle: judge — LLM-judged, free text)
                  A judge criterion carries ONE claim; a semicolon-joined criterion warns — split its clauses.
                  - <plain text>       (compat: compiles as judge oracle, warns)
+    pins:        nested list (optional) of retired-literal and fixture pin obligations:
+                 - literal: <exact text> | glob: <search glob>   (every file matching the glob that holds
+                                                                  the text is an obligated file)
+                 - fixture: <comma-separated path set>           (every matching file is itself obligated:
+                                                                  byte-pinned output the change will move;
+                                                                  it carries no literal text)
+                 LAW: a pins declaration is a LIMITED AUTHORING CONTRACT, not an assertion analyzer —
+                 tickmarkr holds you to the obligations you DECLARE; it does not discover the pins you forgot.
 
   HARD BOUNDS — these FAIL the compile, they do not warn:
     - at most 6 acceptance items per task (no exception path)
@@ -799,6 +857,9 @@ acceptance is required on every task (a nested list of observable outcomes).
       describe() is allowed (OBS-511: the gate matches the criterion as the trailing segment of the
       runner-visible full name), but the leaf title itself must equal the criterion: a shortened,
       decorated, or paraphrased leaf selects ZERO tests and the gate parks even though the suite is green.
+      To say WHICH suite the test lands in, append " | suite: <tests/**/*.test.ts path>" — the path is
+      parsed off into the item's landing field and the title stays the bare leaf; a landing outside the
+      collectable glob refuses the compile.
       Measured before the widening: two parks across two runs, one full attempt lost in each.
     - NO criterion may be satisfiable by an absence, a rename, a source-text grep, or an empty collection.
       "no file references X" is not a criterion — it passes in a repo where the feature was never built.