tickmarkr 2.5.9 → 2.6.1

package/dist/adapters/claude-code.js

@@ -101,6 +101,14 @@ export const CLAUDE_INPUT_BOX = declareInputBox("claude-code", {
 export function claudeSlug(real) {
     return real.replace(/[^A-Za-z0-9]/g, "-");
 }
+// Shared resolution for context and resume identity: never scan a neighbouring session.
+function sessionTranscriptPath(session) {
+    const real = realpathSync(session.cwd);
+    const sid = session.id.replace(/\.jsonl$/i, "");
+    if (!sid || sid.includes("/") || sid.includes("\\") || sid.includes(".."))
+        return null;
+    return join(homedir(), ".claude", "projects", claudeSlug(real), `${sid}.jsonl`);
+}
 // newest-first by mtime, bounded — mtime picks WHICH files to scan, never a record's cursor.
 // Shared by collectUsage (spend) and readClaudeAliasIdentity (OBS-145): same store, same bounds.
 function newestSessionFiles(dir) {
@@ -318,19 +326,24 @@ export const claudeCode = {
             return undefined; // missing dir / any throw ⇒ fail open
         }
     },
+    readSessionTranscript(session) {
+        try {
+            const file = sessionTranscriptPath(session);
+            return file ? { bytes: readFileSync(file).byteLength } : null;
+        }
+        catch {
+            return null;
+        }
+    },
     // v1.23 T1: last-turn context fill from ~/.claude/projects/<slug>/<sessionId>.jsonl ONLY.
     // tokens = input_tokens + cache_creation_input_tokens + cache_read_input_tokens of the LAST
     // assistant usage record (not a sum over turns — ctx-watch.sh class; overseer wake signal).
     // Disk read only: no claude spawn, no pane, no network. null = unknown.
     contextUsage(session) {
         try {
-            const real = realpathSync(session.cwd);
-            const slug = claudeSlug(real);
-            // session id is a filename stem (herdr agent_session.value); refuse path traversal.
-            const sid = session.id.replace(/\.jsonl$/i, "");
-            if (!sid || sid.includes("/") || sid.includes("\\") || sid.includes(".."))
+            const file = sessionTranscriptPath(session);
+            if (!file)
                 return null;
-            const file = join(homedir(), ".claude", "projects", slug, `${sid}.jsonl`);
             let text;
             try {
                 text = readFileSync(file, "utf8").slice(0, MAX_SESSION_BYTES);

package/dist/adapters/prompt.d.ts

@@ -1,6 +1,6 @@
 import { type Task } from "../graph/schema.js";
 import { type VerdictUnparseableCause } from "../gates/verdict-cause.js";
-import type { WorkerResult } from "./types.js";
+import { type WorkerResult } from "./types.js";
 export declare function buildTaskPrompt(task: Task, feedback?: string, nonce?: string): string;
 export declare function writePrompt(dir: string, task: Task, attempt: number, feedback?: string, nonce?: string): string;
 export declare function trailerPattern(nonce: string): string;
@@ -11,4 +11,5 @@ export type ClassifiedWorkerResult = WorkerResult & {
 };
 export declare function parseWorkerResult(raw: string, nonce: string): ClassifiedWorkerResult;
 export type DeadChannelReason = "auth-required" | "setup-required" | "provider-outage" | "timeout";
+export declare function classifyTransientCapacity(result: WorkerResult): RegExpExecArray | null;
 export declare function classifyDeadChannel(result: WorkerResult): DeadChannelReason | undefined;

package/dist/adapters/prompt.js

@@ -2,6 +2,7 @@ import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
+import { CAPACITY_RE } from "./types.js";
 // v1.87 T5: the scope rule states only what the runtime enforces, and no more. What it enforces:
 // `scope.allowDeviations` comes from the operator's config, is snapshotted and frozen when a gate
 // round starts (run-gates.ts `allowDeviations`), and is never written back — so a worker has no
@@ -18,7 +19,7 @@ Goal: ${task.goal}
 
 ## Acceptance criteria (you will be judged against these, verbatim)
 ${list(task.acceptance.map(renderAcceptanceItem))}
-${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(task.files)}\n` : ""}${task.context.length ? `\n## Context (read these first)\n${list(task.context)}\n` : ""}
+${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(task.files)}\n` : ""}${task.context.length ? `\n## Context (read these first)\n${list(task.context)}\n` : ""}${task.outOfScope?.length ? `\n## Out of scope\nStay within the task’s declared bounds; do not pursue these items:\n${list(task.outOfScope)}\n` : ""}
 ## Rules
 - Work only inside the current directory (your isolated worktree). Never push. Never switch branches.
 - Make small atomic git commits as you go (git add + git commit, conventional messages).
@@ -133,6 +134,15 @@ const AUTH_RE = /not logged in|please (?:log ?in|sign in)|please run [^\n]{0,30}
 const SETUP_RE = /command not found|not recognized as an internal or external command|spawn \S+ ENOENT|missing required config|workspace trust (?:required|not granted)/i;
 const OUTAGE_RE = /unable to reach the model provider|cannot reach the model provider|model provider.{0,40}(?:unavailable|unreachable)|service (?:is )?temporarily unavailable|upstream connect error|overloaded_error/i;
 const TIMEOUT_RE = /\bETIMEDOUT\b|request timed out|connection timed out|deadline exceeded|timed out waiting for/i;
+// OBS-1161: transient capacity is the fourth classification beside quota and the typed dead-channel
+// reasons, and it obeys the same boundary rule: a parsed trailer — ok:true OR ok:false — is the worker
+// speaking, so a verdict that QUOTES the capacity phrase stays ordinary work evidence. The caller
+// hands in the chrome-filtered banner rows as `raw`, exactly as it does for classifyDeadChannel.
+export function classifyTransientCapacity(result) {
+    if (result.ok || (result.summary !== NO_TRAILER_SUMMARY && result.summary !== UNPARSEABLE_TRAILER_SUMMARY))
+        return null;
+    return CAPACITY_RE.exec(result.raw);
+}
 export function classifyDeadChannel(result) {
     // A parsed trailer — ok:true OR ok:false — is the worker speaking: genuine work outcomes walk
     // the normal gate/ladder path even when their transcript mentions auth/outage/timeout text.

package/dist/adapters/types.d.ts

@@ -188,6 +188,9 @@ export interface WorkerAdapter {
     listModelsFetchedAt?(): string | undefined;
     collectUsage?(cwd: string, sinceMs: number): TokenUsage | undefined;
     contextUsage?(session: SessionRef): ContextUsage | null;
+    readSessionTranscript?(session: SessionRef): {
+        bytes: number;
+    } | null;
     trust?(repoRoot: string): TrustVerdict;
     trustDialog: TrustDialog;
     inputBox?: InputBox;
@@ -207,5 +210,6 @@ export declare const PROMPT_ARGV_CEILING_LINUX = 120000;
 export declare const PROMPT_ARGV_CEILING_DEFAULT = 900000;
 export declare function promptArgvCeiling(platform?: string): number;
 export declare function promptFitsArgv(promptFile: string, platform?: string): boolean;
+export declare const CAPACITY_RE: RegExp;
 export declare const QUOTA_RE: RegExp;
 export declare const MODEL_ID_RE: RegExp;

package/dist/adapters/types.js

@@ -294,6 +294,16 @@ export function promptFitsArgv(promptFile, platform = process.platform) {
 // ZAI coding-plan exhaustion text: "Insufficient balance or no resource package. Please recharge."
 // Anchor the distinctive full phrase, not the two-word "insufficient balance" fragment — that fires
 // on ordinary billing/wallet task output the harness edits (research Pitfall 3, 2026-07-10).
+// OBS-1161: transient provider capacity ("Selected model is at capacity") is NOT quota — the seat
+// comes back within minutes, so it takes bounded same-seat backoff before a same-floor failover and
+// never permanent demotion. Kept apart from QUOTA_RE so permanent quota policy stays untouched, and
+// anchored on the full phrase (the Pitfall-3 lesson: a bare "capacity" fires on ordinary work text).
+// A banner is the CLI speaking, so the phrase must OPEN its row — after at most an error glyph
+// (codex paints "■ Selected model is at capacity. …") or an "error:" label. Anything else in front —
+// a `>` quote, a quotation mark, a sentence — is the transcript QUOTING it: work evidence, never capacity.
+// ponytail: row-start grammar, not per-adapter fixtures — the ceiling is a worker whose own output
+// opens a row with the bare phrase inside the banner tail; widen the glyph set only from a captured frame.
+export const CAPACITY_RE = /^[ \t■⚠✗✘×!]*(?:(?:stream )?error:[ \t]*)?(?:(?:selected |the )?model is (?:currently |temporarily )?at capacity|(?:provider|service|server) is (?:currently )?at capacity)/im;
 export const QUOTA_RE = /rate.?limit|quota|usage limit|out of credits|insufficient credit|insufficient balance or no resource|\b429\b/i;
 // v1.5 MODEL-01: charset gate for detected model ids (research Pitfall 4, verified 2026-07-10).
 // Ids come from CLI stdout / another program's JSON (models_cache.json) and are echoed into

package/dist/cli/commands/fleet.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { parseArgs } from "node:util";
-import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, modelAuthExclusions } from "../../adapters/registry.js";
+import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, modelAuthExclusions, PREFERENCE_ROLES } from "../../adapters/registry.js";
 import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, fleetUnclassifiedModels } from "../../adapters/model-lints.js";
 import { CATALOG_REFRESH_TIMEOUT_MS, formatCatalogRefreshLegs, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, readClaudeAliasIdentity } from "../../adapters/claude-code.js";
@@ -11,6 +11,7 @@ import { SHAPES, TIERS } from "../../graph/schema.js";
 import { doctor } from "./doctor.js";
 import { candidateRow, costSignal, shapeCandidates } from "./fleet-picker.js";
 import { route } from "../../route/router.js";
+import { pickRole } from "../../route/role-pick.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, entryMatchesChannel, exclusionCollector } from "../../route/preference.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { loadRoutingProfile } from "../../run/journal.js";
@@ -85,6 +86,8 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     const { values } = parseArgs({
         args: argv,
         options: {
+            pick: { type: "string" },
+            "exclude-vendor": { type: "string", multiple: true },
             print: { type: "boolean" },
             why: { type: "boolean" },
             "global-dir": { type: "string" },
@@ -92,6 +95,28 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         },
     });
     const globalDir = values["global-dir"] ?? globalConfigDir();
+    if (values.pick !== undefined) {
+        const role = PREFERENCE_ROLES.find((role) => role === values.pick);
+        const refuse = (reason) => ({ out: `tickmarkr fleet --pick ${values.pick}: ${reason}`, code: 1 });
+        if (!role)
+            return refuse("unsupported-role — expected worker, judge, review or consult; no role prefer resolved");
+        if (values.print || values.why || values.fresh)
+            return refuse("incompatible options — --pick cannot use --print, --why or --fresh");
+        const { cfg } = resolveRunMode(cwd, { globalDir });
+        const { reuse, health } = initDoctorReuse(cwd, false);
+        const selection = pickRole(role, cfg, adapters, reuse && health ? health : {}, {
+            excludeVendors: new Set(values["exclude-vendor"] ?? []),
+        });
+        if (!selection.ok) {
+            return refuse(selection.reason === "missing-prefer" ? `${role}.prefer: missing-prefer`
+                : !reuse || !health ? `${role}.prefer: probe data missing or stale — run tickmarkr doctor first`
+                    : `${role}.prefer: ${selection.reason}`);
+        }
+        const { adapter, model, vendor, channel } = selection.channel;
+        return JSON.stringify({ role, adapter, model, vendor, channel });
+    }
+    if (values["exclude-vendor"]?.length)
+        return { out: "tickmarkr fleet: --exclude-vendor requires --pick <role>", code: 1 };
     const print = values.print ?? false;
     const why = values.why ?? false;
     const input = io.input ?? process.stdin;

package/dist/cli/commands/init.js

@@ -115,7 +115,7 @@ A run is green only when ALL of these hold: the run-end event exists in the jour
 
 ### Verified handoffs
 
-When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the TARGET composer afterward; if the sent text still sits unsubmitted after ~15 s, send-keys enter to that pane once and read again (OBS-975); never report "relayed" without read-back.
+When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the TARGET composer afterward; if the sent text still sits unsubmitted after ~15 s, retry the Enter only when that composer read shows the staged text and no permission prompt or numbered choice holds focus — an Enter sent onto an active prompt approves it or picks a choice instead of submitting the message (OBS-1119). Under that guard, send-keys enter to that pane once and read again (OBS-975); when a prompt or choice holds focus instead, resolve it first and re-read before retrying. Never report "relayed" without read-back.
 
 ### Orient before you act — this block may be the ONLY guidance your host loaded
 

package/dist/cli/commands/plan.js

@@ -7,10 +7,10 @@ import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 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 { batteryPriority, 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 { pendingDaemonApprovalActions, resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
 import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
@@ -372,7 +372,11 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     // OBS-1018: depth and wave come from the same functions the daemon admits by, so the plan shows the
     // critical path the run will actually follow at this concurrency.
     const depths = chainDepth(g);
-    const waves = dispatchWaves(g, cfg.concurrency);
+    // OBS-1158: waves simulate the graph the daemon would admit on resume — the journal's replayed
+    // statuses (an approval releases its park to pending) and its pending recheck approvals ranked
+    // through the same seam the daemon admits by.
+    const projected = { ...g, tasks: g.tasks.map((t) => ({ ...t, status: taskStatuses.get(t.id) ?? t.status })) };
+    const waves = dispatchWaves(projected, cfg.concurrency, batteryPriority(pendingDaemonApprovalActions(matchingEvents ?? []).values()));
     const byId = new Map(g.tasks.map((t) => [t.id, t]));
     const chainLine = (t) => {
         const wave = waves.get(t.id);

package/dist/cli/commands/report.js

@@ -11,6 +11,7 @@ import { estimateCosts } from "../../report/cost.js";
 import { assignmentChannel, buildOperatorRecord, formatChannelMoney, formatChannelTokens, formatTokenUsage as fields, totalTokens as total, } from "../../report/operator-record.js";
 import { cellsOf, cellSummary } from "../../route/profile.js";
 import { Journal, loadRoutingProfile } from "../../run/journal.js";
+import { formatTipProof, runEndTipProof } from "../../run/daemon.js";
 import { deriveRunCockpitData } from "../../tui/cockpit/derive.js";
 const n = (x) => x.toLocaleString("en-US"); // explicit locale — CI/darwin flake guard
 const EM = "—";
@@ -169,6 +170,15 @@ const VERIFICATION_READING = {
     failed: "FAILED — the run did not verify its own tip",
     absent: "absent — no tip verification recorded: neither passed nor failed",
 };
+function verificationReading(runId, events) {
+    const state = verificationOf(runId, events);
+    const proof = runEndTipProof(closedCycle(events));
+    if ((state === "passed" || state === "cached") && proof.gates?.length) {
+        const allCarried = proof.gates.every(({ kind }) => kind === "reused");
+        return `${allCarried ? "cached" : "passed"} — ${formatTipProof(proof)}`;
+    }
+    return VERIFICATION_READING[state];
+}
 // VIS-07 / REC-01: derived only from the run journal, telemetry, and local configuration.
 export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
     const runStart = events.find((e) => e.event === "run-start");
@@ -205,7 +215,7 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         `- **done:** ${count("done")}`,
         `- **failed:** ${count("failed")}`,
         `- **human:** ${count("human")}`,
-        `- **verification:** ${VERIFICATION_READING[verificationOf(runId, events)]}`,
+        `- **verification:** ${verificationReading(runId, events)}`,
         "",
         "## Usage & efficiency",
         "",

package/dist/cli/commands/status.js

@@ -8,6 +8,7 @@ import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { projectActivity } from "../../run/activity.js";
+import { authorsNote, doneAuthors } from "../../run/operator-state.js";
 import { projectOperatorSummary } from "../../run/operator-summary.js";
 import { trackJournalRows } from "../../run/protocol.js";
 import { newestPark, permittedDecisionVerbs } from "./approve.js";
@@ -988,6 +989,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const comparable = record?.comparable ?? false;
     const rehashAt = record?.rehashAt;
     const assignments = new Map();
+    const authorsByTask = new Map();
     const contexts = new Map();
     // v1.53 T5: this run is dead — a newer run replaced it
     const supersededBy = [...events].reverse()
@@ -1000,6 +1002,11 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                     assignments.set(e.taskId, `${a.adapter}:${a.model}`);
                 }
             }
+            if (e.event === "task-done" && e.taskId) {
+                const authors = doneAuthors(e.data);
+                if (authors)
+                    authorsByTask.set(e.taskId, authors);
+            }
             if (e.event === "context-sample" && e.taskId && typeof e.data.tokens === "number" && Number.isFinite(e.data.tokens)) {
                 contexts.set(e.taskId, e.data.tokens); // last write wins
             }
@@ -1106,12 +1113,14 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         const label = isStarved ? " starved" : phrase ? ` ${phrase}` : "";
         const channel = journalRowsOnly ? folded?.actor ?? "-" : assignments.get(t.id) ?? "-";
         const ctx = contexts.get(t.id);
-        const assignCol = ctx !== undefined ? `${channel}${divider}ctx ${ctx}` : channel;
+        // Merged authors are their own fact beside the last dispatch: a carry-only seat authored nothing.
+        const authors = authorsNote(authorsByTask.get(t.id), channel);
+        const assignCol = [channel, ctx !== undefined ? `ctx ${ctx}` : "", authors ?? ""].filter(Boolean).join(divider);
         const gates = comparable
             ? 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, summary, ...gates };
+        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, authors, livePhase, pane, summary, ...gates };
     });
     if (!unicode) {
         // Keep the machine task-title columns intact; projection details occupy their own line.
@@ -1215,7 +1224,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     }).join("");
     const gateHeader = GATE_NAMES.map((gate) => fitCells(gate.slice(0, 2), 3)).join("");
     const noteFor = (cell) => {
-        const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, ctx, livePhase, pane } = cell;
+        const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, ctx, livePhase, pane, authors } = cell;
         const effort = effortByTask.get(t.id);
         const blocking = graphTaskStatus(st, t.status) === "done" ? [] : dependents.get(t.id) ?? [];
         const failed = failedGates(states);
@@ -1242,6 +1251,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             blocking.length ? `blocks ${blocking.join(", ")}` : "",
             pane ? `pane ${pane}` : "",
             ctx !== undefined ? `ctx ${ctx}` : "",
+            authors ?? "",
         ].filter(Boolean).join(" · ");
     };
     const staleWorker = (cell) => cell.livePhase?.phase === "worker"

package/dist/cli/commands/verify.js

@@ -307,6 +307,8 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
                 try {
                     linkNodeModules(cwd, baseDir, { force: true });
                     baseline = await captureBaseline(baseDir, commands);
+                    if (baseline.refusal)
+                        return { out: baseline.refusal, code: 1 };
                     const missing = verdictlessCommands(baseline, commands);
                     if (missing.length) {
                         writeFileSync(verdictlessMarker, JSON.stringify({ base: mergeBase, commands: missing }) + "\n");

package/dist/cli/help.d.ts

@@ -39,6 +39,8 @@ export declare const COMMAND_HELP: {
         usage: string;
         description: string;
         options: {
+            "--pick <role>": string;
+            "--exclude-vendor <vendor>": string;
             "--print": string;
             "--why": string;
             "--global-dir <path>": string;

package/dist/cli/help.js

@@ -30,6 +30,8 @@ export const COMMAND_HELP = {
     fleet: {
         usage: "fleet [options]", description: "Edit fleet configuration interactively, or print it for scripts.",
         options: {
+            "--pick <role>": "Resolve one role preference as JSON without launching a seat (review or consult; roles without prefer refuse).",
+            "--exclude-vendor <vendor>": "Exclude a vendor from --pick; repeat for multiple vendors.",
             "--print": "Print fleet configuration without opening the editor.",
             "--why": "Include routing eligibility explanations in printed output.",
             "--global-dir <path>": "Use this global configuration directory.",

package/dist/compile/native.js

@@ -69,8 +69,11 @@ 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", "pins"]);
-const listItems = (draft) => draft.list === "acceptance" ? draft.acceptanceRaw : draft.list === "pins" ? draft.pinsRaw : draft.gates;
+const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout", "pins", "outofscope"]);
+const listItems = (draft) => draft.list === "acceptance" ? draft.acceptanceRaw
+    : draft.list === "pins" ? draft.pinsRaw
+        : draft.list === "outofscope" ? draft.outOfScope
+            : 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.
@@ -420,7 +423,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, pinsRaw: [], list: null, itemOpen: false, continuationField: null });
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptanceRaw: [], acceptance: [], gates: [], hasGates: false, pinsRaw: [], outOfScope: [], list: null, itemOpen: false, continuationField: null });
             continue;
         }
         const draft = drafts.at(-1);
@@ -455,7 +458,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" || name === "pins") {
+            if (name === "acceptance" || name === "gates" || name === "pins" || name === "outofscope") {
                 if (value)
                     invalid(draft.id, field[1], "must be a nested list");
                 draft.list = name;
@@ -725,6 +728,9 @@ export function compileNative(file, options = {}) {
             ...(routingHints ? { routingHints } : {}),
             ...(draft.hasGates ? { gates: draft.gates } : {}),
             ...(draft.pinsRaw.length ? { pins: draft.pinsRaw.map((raw, i) => parsePin(draft.id, raw, i, pinPaths)) } : {}),
+            // OBS-1126: an absent list emits no key — a sealed graph's bytes must not move for tasks that
+            // never declared a bound.
+            ...(draft.outOfScope.length ? { outOfScope: draft.outOfScope } : {}),
         };
     });
     const result = validateGraph({
@@ -841,6 +847,23 @@ acceptance is required on every task (a nested list of observable outcomes).
                                                                   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.
+                 THE PIN SWEEP IS BY CALLERS OF EVERY RESHAPED TYPE, NOT BY THE LITERAL (OBS-1127): for each
+                 type, field or return shape the task changes, enumerate EVERY CALLER and EVERY BRIDGE — the
+                 command layer that re-serialises it, the live cockpit that renders it, the fixture that
+                 byte-pins it — and declare each one. A grep for the retired literal finds the sites that
+                 SPELL the old shape; it misses the sites that CONSUME it under another name. Measured in
+                 v2.5.9, twice: a deny-scope reshape swept by literal missed the Fleet command bridge that
+                 re-emitted the old scope set; a pane-status reshape missed the live cockpit caller that
+                 still read the retired field. Both compiled, both passed the declared pins, both shipped.
+    outOfScope:  nested list (optional) of bounds the task must NOT cross — carried onto the graph task
+                 and into its content identity (OBS-1126): a changed list retires prior-run findings.
+                 It is the DECLARED BOUND the reviewer and the repair worker are HELD TO, stated as EXPLICIT
+                 EXCLUSIONS ALONGSIDE the authoritative goal and acceptance criteria — it never displaces
+                 them. The review brief carries the goal (authoritative), the criteria and this list, so a
+                 finding inside the list is NOT MATERIAL and must not block approval (the reviewer may
+                 still raise it as minor); the repair worker receives the complete task prompt — goal,
+                 criteria and this list — not only the finding, so a repair that crosses the list fails
+                 even when it would silence the finding.
 
   HARD BOUNDS — these FAIL the compile, they do not warn:
     - at most 6 acceptance items per task (no exception path)
@@ -876,6 +899,15 @@ acceptance is required on every task (a nested list of observable outcomes).
       A criterion naming a CAPABILITY is satisfiable by a stub whose only caller is its own test, and the
       judge cannot catch it — it reads the DIFF, and a stub's hunks are real. Name the PRODUCTION CALLER
       that must exercise the capability, and the path it runs on; "X is supported" ships as dead code.
+    - A CRITERION RUNS END-TO-END THROUGH ITS PRODUCTION CALLER, STATED ONCE. Pin the observable at the
+      outermost production entry point — the CLI bridge, the rendered frame, the journal line — and let the
+      layers beneath it be exercised by that one claim. A criterion pinned at a helper is satisfied by the
+      helper alone while every layer above it is still wrong, and the fix then CLIMBS: each review round
+      moves the pin up one layer and burns a round. Measured in v2.5.9 (OBS-1127): a deny-scope criterion
+      first pinned the helper, then the production shape, then the Fleet state, then the CLI bridge — four
+      review rounds for one claim, "tkr fleet deny lists every scope the schema declares", that stated once
+      at the bridge would have failed at round one. Ask: WHAT DOES THE OPERATOR INVOKE, AND WHAT DO THEY
+      SEE? Pin that. A criterion satisfied one layer short of the operator is a criterion about plumbing.
     - Enumerating one axis exhaustively is what hides the others. A spec that guards PARTIAL coverage
       site-by-site, member-by-member, can be defeated wholesale by CONDITIONAL coverage, which leaves
       every enumeration satisfied. After you enumerate, ask what a single flag would do to the whole set.
@@ -922,6 +954,9 @@ acceptance is required on every task (a nested list of observable outcomes).
   PRE-SCOPE BY TEXT, ENUMERATE BLOCKERS BY EXECUTION:
     - Before assigning files[], sweep text across the repository tree for names, callers, tests and prose.
       A text sweep produces a candidate list; only running the change enumerates the real blocker set.
+      For every type the task RESHAPES, the sweep is by CALLER, not by literal: list each consumer and each
+      bridge of the type (command layer, cockpit, fixtures) and put every one in files[] or in a dep's —
+      the two v2.5.9 misses above were consumers that never spelled the retired literal (OBS-1127).
       Keep the candidates for scope, then execute the production path and full gates before declaring the
       set closed — this milestone paid a halted run to learn that the two populations are not identical.
     - SPIKE-THE-CONTRACT-THEN-SCOPE trigger question: COULD A TEST THIS TASK DOES NOT OWN BE ASSERTING THE

package/dist/drivers/orca.d.ts

@@ -81,7 +81,7 @@ export declare function terminalWorktree(term: Record<string, unknown>): string
  * it keeps its resolved spelling: deterministic, and still comparable to another spelling of itself.
  */
 export declare function canonicalWorktreePath(path: string): string;
-/** The proof line a worker terminal prints first: recovery and focus read it back (FX-N01). */
+/** The proof line a worker terminal prints first: create, recovery and focus read it back. */
 export declare const CHECKOUT_MARK = "TICKMARKR_CHECKOUT";
 /** The exact bytes the create command prints as its first line. */
 export declare function checkoutProofLine(checkout: string): string;

package/dist/drivers/orca.js

@@ -2,7 +2,7 @@ import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, readlinkSyn
 import { randomUUID } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { shq } from "../adapters/types.js";
-import { createWorktree, sh } from "../run/git.js";
+import { createWorktree, FORK_CAP_ENV, resolvedForkCap, sh } from "../run/git.js";
 import { Journal, parseRunId } from "../run/journal.js";
 import { stateDirName } from "../graph/graph.js";
 import { readWatchBoard, requestWatchBoardStop, stopWatchBoard, WATCH_OWNER_ENV } from "../run/supervision.js";
@@ -201,7 +201,7 @@ function enclosesCheckout(reported, checkout) {
     const tracked = canonicalWorktreePath(reported);
     return tracked === checkout || checkout.startsWith(`${tracked}/`);
 }
-/** The proof line a worker terminal prints first: recovery and focus read it back (FX-N01). */
+/** The proof line a worker terminal prints first: create, recovery and focus read it back. */
 export const CHECKOUT_MARK = "TICKMARKR_CHECKOUT";
 // FX-N05: the proof is a FRAMED value — `TICKMARKR_CHECKOUT <byteLength>:<utf8 bytes as hex>;` — so it
 // carries no whitespace or quotes, survives renderer wrapping (hex rows re-join losslessly), and is
@@ -209,6 +209,7 @@ export const CHECKOUT_MARK = "TICKMARKR_CHECKOUT";
 // never decode to this one; `A` versus `A B`, `…--T1` versus `…--T10` are different frames.
 const CHECKOUT_FRAME_RE = /TICKMARKR_CHECKOUT (\d+):([0-9a-f]*)(;?)/g;
 const PROOF_PAGES = 16; // pages read from the oldest cursor before the proof is declared absent
+const CHECKOUT_PROOF_TIMEOUT_MS = 2_000; // allow the wrapper shell to emit its startup proof
 /** The exact bytes the create command prints as its first line. */
 export function checkoutProofLine(checkout) {
     const bytes = Buffer.from(checkout, "utf8");
@@ -245,7 +246,12 @@ export function provesCheckout(text, checkout) {
  * subshell inside it all start in the checkout and its exit status is the payload's (FX-N02).
  */
 export function checkoutPrefix(checkout) {
-    return `cd ${shq(checkout)} && printf '%s\\n' ${shq(checkoutProofLine(checkout))} && sh -c `;
+    // OBS-1168: printf BUILDS the marker from two arguments, so the typed command never carries
+    // `TICKMARKR_CHECKOUT ` verbatim. The shell's echo of the typed line is repainted and truncated in
+    // the scrollback, which used to leave an INCOMPLETE frame beside the complete printed one and made
+    // provesCheckout refuse a correct launch. The printed bytes are exactly checkoutProofLine(checkout).
+    const head = CHECKOUT_MARK.slice(0, CHECKOUT_MARK.indexOf("_"));
+    return `cd ${shq(checkout)} && printf '%s%s\\n' ${head} ${shq(checkoutProofLine(checkout).slice(head.length))} && sh -c `;
 }
 /** The command a terminal on the tracked worktree runs so that it executes INSIDE the checkout. */
 export function inCheckout(checkout, cmd) {
@@ -764,9 +770,10 @@ export class OrcaDriver {
         // The selector names the TRACKED worktree enclosing this slot's checkout outright — never the
         // UI's active worktree (`active`/`current`) nor the daemon's cwd — and the command itself moves
         // into the checkout, because Orca cannot be asked to place a terminal in a path it does not
-        // track (OBS-1004). `--command` runs inside Orca's wrapper shell, so a `cd` prefix is honoured.
+        // track (OBS-1004). Shell startup can swallow that prefix; prove it from scrollback below.
+        const payload = `export ${FORK_CAP_ENV}=${shq(process.env[FORK_CAP_ENV] ?? resolvedForkCap())}; ${cmd}`;
         const env = await this.call("create", [
-            "terminal", "create", "--worktree", `path:${tracked}`, "--title", st.title, "--command", inCheckout(st.cwd, cmd),
+            "terminal", "create", "--worktree", `path:${tracked}`, "--title", st.title, "--command", inCheckout(st.cwd, payload),
         ], this.cliCwd(st));
         const term = requireTerminal("create", env);
         const handle = str(term.handle);
@@ -788,6 +795,21 @@ export class OrcaDriver {
             catch { /* already gone, or no longer provably ours — never a blind retry */ }
             throw this.latched("create", st, `create receipt bound to ${worktree ?? "no worktree"}, not the tracked ${tracked} enclosing ${st.cwd}`, env.raw);
         }
+        // A receipt only proves placement on the enclosing tracked checkout. Wait briefly for the
+        // startup command's proof before run() can resolve and the daemon can count a worker launch.
+        const deadline = this.time.now() + CHECKOUT_PROOF_TIMEOUT_MS;
+        let proof = await this.checkoutProven(handle, st.cwd, this.cliCwd(st), env.runtimeId);
+        while (!proof.proven && this.time.now() < deadline) {
+            await this.time.sleep(POLL_MS);
+            proof = await this.checkoutProven(handle, st.cwd, this.cliCwd(st), env.runtimeId);
+        }
+        if (!proof.proven) {
+            try {
+                await this.closeTerminal({ ...st, handle, runtimeId: env.runtimeId });
+            }
+            catch { /* best effort under the answering runtime; the latch prevents another launch */ }
+            throw this.latched("create", st, `terminal ${handle} does not prove checkout ${st.cwd} (${proof.reason})`, env.raw);
+        }
         st.handle = handle;
         // The handle is bound to the runtime identity that ANSWERED its create.
         st.runtimeId = env.runtimeId;

package/dist/gates/baseline.d.ts

@@ -128,6 +128,8 @@ export interface BaselineFileDuration {
     durationMs: number;
 }
 export interface Baseline {
+    /** No command ran because the dependency inventory could not establish isolation. */
+    refusal?: string;
     /** Observational capture receipts stay outside the forgiveness-bearing command entries. */
     evidenceReceipts?: Record<string, GateEvidenceReceipt>;
     commands: Record<string, BaselineCommand>;

package/dist/gates/baseline.js

@@ -3,7 +3,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync, rmdirSync } from "node:fs";
 import { availableParallelism, loadavg, tmpdir } from "node:os";
 import { join } from "node:path";
-import { DEFAULT_SHELL_TIMEOUT_MS, describeCapacity, sameCapacity, sh } from "../run/git.js";
+import { dependencyLinkRefusal, DEFAULT_SHELL_TIMEOUT_MS, describeCapacity, sameCapacity, sh } from "../run/git.js";
 import { executionSignal } from "../run/execution-budget.js";
 import { isVitestTestCommand, manifestFileCount } from "./test-manifest.js";
 export const EVIDENCE_TAIL_BYTES = 16 * 1024;
@@ -620,6 +620,14 @@ export function staleFileCountCommands(baseline, commands, cwd) {
 }
 export async function captureBaseline(cwd, commands, opts = {}) {
     const base = { commands: {} };
+    const refusal = dependencyLinkRefusal(cwd);
+    if (refusal) {
+        base.refusal = refusal;
+        for (const name of Object.keys(commands)) {
+            base.commands[name] = { infra: true, invalidCause: "infra", fingerprints: [], invalidatingLines: [refusal] };
+        }
+        return base;
+    }
     for (const [name, cmd] of Object.entries(commands)) {
         if (name === "tipTest" && commands.test !== undefined && cmd === commands.test) {
             continue;

package/dist/gates/cache.d.ts

@@ -36,9 +36,11 @@ export interface VerificationIdentity {
     gate?: string;
     /** which verifier produced it: a battery gate row or an integration-tip row (own report, own forgiveness rule) */
     scope?: VerificationScope;
-    /** Checkout location is diagnostic metadata; equal trees share verdicts across worktrees. */
+    /** Checkout location is diagnostic metadata; build outputs additionally require an incarnation. */
     worktree?: string;
     tree: string;
+    /** Build success also promises local outputs, which die with the checkout. */
+    checkoutIncarnation?: string;
     command: string;
     baseline: string;
     environment: string;
@@ -59,7 +61,15 @@ export declare function computeVerificationIdentity(params: {
 }): Promise<VerificationIdentity | undefined>;
 export declare function verificationIdentityKey(id: VerificationIdentity): string;
 export declare function formatReusedDetails(originalDetails: string, id: VerificationIdentity): string;
+declare module "./types.js" {
+    interface GateResult {
+        originRunRoot?: string;
+    }
+}
 export interface CachedVerdict {
+    evidenceReceipt?: GateResult["evidenceReceipt"];
+    evidenceReceipts?: GateResult["evidenceReceipts"];
+    originRunRoot?: string;
     gate: string;
     pass: boolean;
     details: string;