tickmarkr 1.52.0 → 1.53.0

package/dist/adapters/kimi.d.ts

@@ -2,4 +2,5 @@ import { type WorkerAdapter, type WorkerResult } from "./types.js";
 export declare function kimiAuthed(credentialsText: string, nowMs: number): boolean;
 export declare function parseKimiModels(raw: string): string[];
 export declare function parseKimiResult(raw: string, nonce: string): WorkerResult;
+export declare function kimiSessionId(output: string): string | undefined;
 export declare const kimi: WorkerAdapter;

package/dist/adapters/kimi.js

@@ -46,6 +46,21 @@ export function parseKimiResult(raw, nonce) {
     const stripped = raw.split("\n").map((l) => l.replace(/^[\s]*[•*-]\s+/, "")).join("\n");
     return parseWorkerResult(stripped, nonce);
 }
+// v1.53 T3: session-id capture from the run-output trailer — every `kimi -p` run (fresh or resumed)
+// ends with `To resume this session: kimi -r session_<uuid>` (live probe 2026-07-18). Anchored full
+// line only: prompt/model prose can contain lookalike text, and the anchored charset keeps a
+// captured id shell-safe by construction (shq in resumeCommand is the second layer). Last valid
+// line wins — a run may echo stale resume lines mid-transcript.
+const RESUME_TRAILER_RE = /^\s*To resume this session: kimi -r (session_[0-9a-f-]+)\s*$/;
+export function kimiSessionId(output) {
+    let id;
+    for (const line of output.split("\n")) {
+        const m = RESUME_TRAILER_RE.exec(line);
+        if (m)
+            id = m[1];
+    }
+    return id;
+}
 export const kimi = {
     id: "kimi",
     vendor: "moonshot",
@@ -73,6 +88,15 @@ export const kimi = {
     // ("unknown command '…'", live-verified 2026-07-17, OBS-67) and -p is non-interactive-only.
     // null → the daemon's print fallback (types.ts:101) keeps kimi workers visible without a TUI.
     interactiveCommand: () => null,
+    // v1.53 T3 resume — live-probed 2026-07-18: `-p` + `-S <id>` compose cleanly (no OBS-67-class
+    // flag rejection) and the resumed session carries prior conversation state. `-S <id>` is the
+    // deterministic form; `-c` rejected as primary — cwd-keyed, nondeterministic under worktree
+    // recreation (probe finding 4). Never bare `-S` (it launches the interactive session picker).
+    resumeCommand: (sessionId, promptFile, model) => `kimi -S ${shq(sessionId)} -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --output-format text`,
+    sessionIdFrom: kimiSessionId,
+    // KIMI-03: no contextUsage surface exists, so a known-context requirement would leave resume
+    // dead code — declare the unknown-context opt-in the daemon retry seam enforces.
+    resumeUnknownContext: true,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

package/dist/adapters/types.d.ts

@@ -79,6 +79,8 @@ export interface WorkerAdapter {
     headlessCommand(promptFile: string, model: string): string;
     interactiveCommand(promptFile: string, model: string): string | null;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;
+    sessionIdFrom?(output: string): string | undefined;
+    resumeUnknownContext?: boolean;
     invoke(task: Task, cwd: string, a: Assignment, ctx: {
         promptFile: string;
     }): Invocation;

package/dist/cli/commands/fleet.js

@@ -140,6 +140,9 @@ function openTerm(input, output) {
             finally {
                 rl.close();
                 setRaw(true);
+                // rl.close() pauses the input stream — without a resume the next key() await has
+                // nothing keeping the event loop alive and the process silently exits 0 (OBS-77)
+                input.resume();
                 queue.splice(typedFrom);
                 prevLines = 0;
             }

package/dist/cli/commands/plan.js

@@ -2,7 +2,7 @@ import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, probeA
 import { formatModelAuthLine, contextWindowLints, modelLints, ttyVisual } from "../../adapters/model-lints.js";
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { parseArgs } from "node:util";
-import { collateralLints } from "../../compile/collateral.js";
+import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { DEFAULT_CONFIG, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
 import { loadGraph } from "../../graph/graph.js";
 import { resolveRunMode } from "../../run/daemon.js";
@@ -170,8 +170,8 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters())
     const windowLints = contextWindowLints(g.tasks, routed, cfg, cwd);
     if (windowLints.length)
         lines.push("", "context window lints:", ...windowLints.map((l) => `  ! ${l}`));
-    // OBS-12/13/14/21: advisory only — never blocks --route-strict (run refuses on routing lints only)
-    const scopeLints = collateralLints(g.tasks, cwd);
+    // OBS-12/13/14/21 + OBS-76: advisory only — never blocks --route-strict (run refuses on routing lints only)
+    const scopeLints = [...collateralLints(g.tasks, cwd), ...sourceScopeLints(g.tasks, cwd)];
     if (scopeLints.length)
         lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
     return stylizePlan(lines.join("\n"));

package/dist/cli/commands/report.js

@@ -94,6 +94,14 @@ const wallClock = (start, end) => {
     return minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
 };
 const detail = (value) => typeof value === "string" || typeof value === "number" ? String(value) : EM;
+// v1.53 T5: supersession is derived from the run's OWN journal only — `superseded by` from the
+// appended superseded event (last wins), `supersedes` from the run-start stamp. No cross-run scan.
+const supersession = (events) => {
+    const by = [...events].reverse().find((e) => e.event === "superseded" && typeof e.data.by === "string")?.data.by;
+    const start = events.find((e) => e.event === "run-start");
+    const supersedes = typeof start?.data.supersedes === "string" ? start.data.supersedes : undefined;
+    return { ...(typeof by === "string" ? { supersededBy: by } : {}), ...(supersedes ? { supersedes } : {}) };
+};
 const taskIds = (events) => {
     const seen = new Set();
     const out = [];
@@ -152,10 +160,13 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
     usageLines.push(...journalUsage(events, new Set(prices.map((row) => `${row.channel}:${row.adapter}:${row.model}`))));
     if (!usageLines.length)
         usageLines.push("- **not recorded:** attempts/windows: not measurable; tokens: not measurable; price: not measurable");
+    const sup = supersession(events);
     const lines = [
         `# tickmarkr engagement`,
         "",
         `- **runId:** ${runId}`,
+        ...(sup.supersededBy ? [`- **superseded by:** ${sup.supersededBy}`] : []),
+        ...(sup.supersedes ? [`- **supersedes:** ${sup.supersedes}`] : []),
         `- **base ref:** ${baseRef}`,
         `- **branch:** ${branch}`,
         `- **done:** ${count("done")}`,
@@ -269,8 +280,11 @@ function textReport(runId, events, rows, cwd) {
     const escalations = events.filter((e) => e.event === "escalation").length;
     const consults = events.filter((e) => e.event === "consult-verdict").length;
     const failovers = events.filter((e) => e.event === "quota-failover").length;
+    const sup = supersession(events);
     return [
         `tickmarkr engagement — ${runId}`,
+        ...(sup.supersededBy ? [`superseded by ${sup.supersededBy}`] : []),
+        ...(sup.supersedes ? [`supersedes ${sup.supersedes}`] : []),
         "",
         "engagement summary — audit trail:",
         ...[...groups.entries()].map(([k, g]) => `  ${k.padEnd(30)} tasks ${g.rows.length}, attempts ${g.rows.reduce((s, r) => s + r.attempts, 0)}, done ${g.rows.filter((r) => r.outcome === "done").length}`),

package/dist/cli/commands/run.js

@@ -39,6 +39,7 @@ export async function run(argv, cwd = process.cwd()) {
             "no-explore": { type: "boolean" },
             mode: { type: "string" },
             quality: { type: "boolean" },
+            supersedes: { type: "string" },
         },
     });
     if (values.concurrency !== undefined) {
@@ -83,6 +84,7 @@ export async function run(argv, cwd = process.cwd()) {
             concurrency: values.concurrency ? Number(values.concurrency) : undefined,
             driver: pickDriver(cfg, values.driver),
             mode: flagMode,
+            supersedes: values.supersedes,
             narrate: (event) => console.log(narrationLine(event)),
         });
         const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;

package/dist/cli/commands/status.js

@@ -120,9 +120,12 @@ const renderFrame = (cwd) => {
     let events = [];
     const contexts = new Map();
     let comparable = false;
+    let supersededBy; // v1.53 T5: this run is dead — a newer run replaced it
     if (runId) {
         const j = Journal.open(cwd, runId);
         events = j.read();
+        const sup = [...events].reverse().find((e) => e.event === "superseded" && typeof e.data.by === "string");
+        supersededBy = sup?.data.by;
         // T3 (Sol #2 / Fable F2): the SAME comparator resume uses (engagementComparable) — one decision,
         // two consumers. graphDefinitionHash (compiled task definitions only) survives status/evidence
         // mutation but changes when a task definition changes, so a recompiled graph is detected here too.
@@ -164,7 +167,7 @@ const renderFrame = (cwd) => {
             return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
         });
         const header = runId
-            ? `tickmarkr status${divider}run ${runId}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
+            ? `tickmarkr status${divider}run ${runId}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
             : `tickmarkr status${divider}no runs yet${divider}${done}/${g.tasks.length} done`;
         const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
         return [header, legendLine, ...rows].join("\n");
@@ -186,7 +189,7 @@ const renderFrame = (cwd) => {
     const tally = `${done}/${g.tasks.length} done`;
     const header = ` ${title(runId ? `run ${runId}` : "tickmarkr")}${dot}` +
         (runId
-            ? `${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}`
+            ? `${supersededBy ? `${warn(`superseded by ${supersededBy}`)}${dot}` : ""}${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}`
             : `no runs yet${dot}`) +
         `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
     const hr = rule(Math.min(width, 100));

package/dist/compile/collateral.d.ts

@@ -1,6 +1,12 @@
-import type { Task } from "../graph/schema.js";
+import { type Task } from "../graph/schema.js";
 /**
  * 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.
  */
 export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
+/**
+ * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
+ * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
+ * Advisory plan output only, same contract as collateralLints.
+ */
+export declare function sourceScopeLints(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string): string[];

package/dist/compile/collateral.js

@@ -1,10 +1,11 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, relative } from "node:path";
 import picomatch from "picomatch";
-// Advisory plan-time scan only (OBS-12/13/14/21). NEVER expands files[], fails compile, or
-// feeds the scope gate — a warning the author acts on. Plain-text (no AST), capped + sorted.
-/** Max test files walked under tests/ (sorted walk; rest ignored). */
-const MAX_TEST_FILES = 400;
+import { renderAcceptanceItem } from "../graph/schema.js";
+// Advisory plan-time scan only (OBS-12/13/14/21, OBS-76). NEVER expands files[], fails compile,
+// or feeds the scope gate — a warning the author acts on. Plain-text (no AST), capped + sorted.
+/** Max files walked per root (sorted walk; rest ignored). */
+const MAX_WALK_FILES = 400;
 /** Max collateral test paths listed per task. */
 const MAX_HITS_PER_TASK = 20;
 /** Skip giant fixtures / snapshots. */
@@ -22,23 +23,23 @@ function needlesFor(srcPath) {
     // repo-relative import forms that appear in tests (ESM often uses .js)
     return [...new Set([noExt, `${noExt}.js`, `${noExt}.ts`, n])].filter((s) => s.length > 0);
 }
-function walkTests(repoRoot) {
-    const root = join(repoRoot, "tests");
+function walkCode(repoRoot, subdir) {
+    const root = join(repoRoot, subdir);
     const out = [];
     const walk = (dir) => {
-        if (out.length >= MAX_TEST_FILES)
+        if (out.length >= MAX_WALK_FILES)
             return;
         let entries;
         try {
             entries = readdirSync(dir, { withFileTypes: true });
         }
         catch {
-            return; // no tests/ or unreadable — zero lints
+            return; // no such root or unreadable — zero lints
         }
         // deterministic order
         entries.sort((a, b) => a.name.localeCompare(b.name));
         for (const e of entries) {
-            if (out.length >= MAX_TEST_FILES)
+            if (out.length >= MAX_WALK_FILES)
                 return;
             if (e.name === "node_modules" || e.name === ".git" || e.name.startsWith("."))
                 continue;
@@ -70,17 +71,10 @@ function mentions(content, needles) {
     }
     return false;
 }
-/**
- * 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.
- */
-export function collateralLints(tasks, repoRoot) {
-    const testFiles = walkTests(repoRoot);
-    if (!testFiles.length)
-        return [];
-    // cache file bodies (one read per test path)
+// cache file bodies (one read per path)
+function makeReader(repoRoot) {
     const body = new Map();
-    const read = (rel) => {
+    return (rel) => {
         if (body.has(rel))
             return body.get(rel);
         try {
@@ -98,6 +92,16 @@ export function collateralLints(tasks, repoRoot) {
             return null;
         }
     };
+}
+/**
+ * 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.
+ */
+export function collateralLints(tasks, repoRoot) {
+    const testFiles = walkCode(repoRoot, "tests");
+    if (!testFiles.length)
+        return [];
+    const read = makeReader(repoRoot);
     const lines = [];
     for (const t of tasks) {
         // OBS-22: scopeGate accepts picomatch globs; advisory collateral warnings must agree.
@@ -128,3 +132,56 @@ export function collateralLints(tasks, repoRoot) {
     }
     return lines;
 }
+// v1.53 T4 (OBS-76): needles are code-shaped tokens only (camelCase / snake_case) — plain prose
+// words never match, so prose-only criteria yield zero needles instead of alarm-fatigue noise.
+// ponytail: token heuristic, not AST symbol resolution — promote after a version of precision data.
+function criteriaSymbols(acceptance) {
+    const out = new Set();
+    for (const item of acceptance) {
+        for (const tok of renderAcceptanceItem(item).match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []) {
+            if (tok.includes("_") || /[a-z][A-Z]/.test(tok))
+                out.add(tok);
+        }
+    }
+    return [...out].sort();
+}
+/**
+ * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
+ * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
+ * Advisory plan output only, same contract as collateralLints.
+ */
+export function sourceScopeLints(tasks, repoRoot) {
+    const perTask = tasks
+        .map((t) => ({ t, needles: criteriaSymbols(t.acceptance) }))
+        .filter((x) => x.needles.length);
+    if (!perTask.length)
+        return [];
+    const srcFiles = walkCode(repoRoot, "src");
+    if (!srcFiles.length)
+        return [];
+    const read = makeReader(repoRoot);
+    const lines = [];
+    for (const { t, needles } of perTask) {
+        // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.
+        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        // needles are word-chars by construction — no regex escaping needed; whole-word match only
+        const res = needles.map((n) => new RegExp(`\\b${n}\\b`));
+        const hits = [];
+        for (const sf of srcFiles) {
+            if (scoped(sf))
+                continue;
+            const text = read(sf);
+            if (text === null)
+                continue;
+            if (res.some((re) => re.test(text)))
+                hits.push(sf);
+        }
+        if (!hits.length)
+            continue;
+        hits.sort();
+        const listed = hits.slice(0, MAX_HITS_PER_TASK).join(", ");
+        const tail = hits.length > MAX_HITS_PER_TASK ? " (capped)" : "";
+        lines.push(`${t.id}: criteria implicate out-of-scope source not in files[]: ${listed}${tail}`);
+    }
+    return lines;
+}

package/dist/config/config.d.ts

@@ -168,6 +168,7 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
     review: z.ZodObject<{
         complexityThreshold: z.ZodNumber;
         required: z.ZodBoolean;
+        prefer: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     consult: z.ZodObject<{
         adapter: z.ZodString;

package/dist/config/config.js

@@ -152,7 +152,9 @@ export const TickmarkrConfigSchema = z.object({
         allowDeviations: z.array(z.string()),
     }).partial().optional(),
     judge: z.object({ adapter: z.string(), model: z.string() }),
-    review: z.object({ complexityThreshold: z.number(), required: z.boolean() }),
+    // v1.53 T2: prefer — ordered reviewer preference (entry grammar: adapter | adapter:model, same as
+    // routing.map.prefer). Reorders diversity-eligible channels only; never widens or narrows eligibility.
+    review: z.object({ complexityThreshold: z.number(), required: z.boolean(), prefer: z.array(z.string()).optional() }),
     consult: z.object({ adapter: z.string(), model: z.string(), stallMinutes: z.number().positive() }),
     visibility: z.object({
         llm: z.enum(["pane", "headless"]),
@@ -474,7 +476,9 @@ export function configTemplate(overlay) {
 #   test: npm test
 #   byShape:
 #     docs: { acceptance: false, review: false }  # baseline, evidence, and scope are mandatory
-# review: { complexityThreshold: 7, required: true }
+# review: { complexityThreshold: 7, required: true, prefer: [codex:gpt-5.6-sol, kimi] }
+#                         # prefer: ordered reviewer seat preference (adapter | adapter:model); ranks
+#                         # diversity-eligible channels only — never admits a same-vendor/same-model reviewer
 # consult: { adapter: claude-code, model: fable, stallMinutes: 15 }
 # cost:                   # v1.20 REC-02 — OPTIONAL price table for the usage/cost report. Absent ⇒ every
 #                         # channel reports "not measurable" (never a crash or a fake $0). Two economics,

package/dist/gates/review.d.ts

@@ -15,5 +15,6 @@ export declare function checkDiffCap(gate: string, measured: number, cap: number
 export declare function isDiffCapPark(result: GateResult): boolean;
 export declare function diffCapParkReason(results: GateResult[]): string | null;
 export declare function modelId(model: string): string;
-export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[]): BillingChannel | null;
+export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[], // v1.1 failover: reviewer channels that already produced garbage for this task
+prefer?: string[]): BillingChannel | null;
 export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[]): Promise<GateResult>;

package/dist/gates/review.js

@@ -39,7 +39,15 @@ export function diffCapParkReason(results) {
 export function modelId(model) {
     return model.slice(model.lastIndexOf("/") + 1);
 }
-export function pickReviewer(author, channels, exclude = []) {
+// v1.53 T2: same entry grammar as routing.map.prefer (router.ts preferIndex — router is out of this
+// module's dependency direction for a private fn, so the 3 lines live here too): `adapter` matches
+// every channel of that adapter, `adapter:model` exactly one; unmatched channels sort after all entries.
+function reviewPreferIndex(c, prefer) {
+    const i = prefer.findIndex((p) => p === c.adapter || p === channelKey(c));
+    return i === -1 ? prefer.length : i;
+}
+export function pickReviewer(author, channels, exclude = [], // v1.1 failover: reviewer channels that already produced garbage for this task
+prefer = []) {
     // FLEET-05 success criterion 2: an author not resolvable in the channel list yields NO reviewer.
     // The old `?? author.adapter` fallback compared an adapter id to vendor names, matched nothing, and
     // admitted every reviewer — including the author's own channel (fail-OPEN). null lands on reviewGate's
@@ -49,15 +57,16 @@ export function pickReviewer(author, channels, exclude = []) {
         return null;
     return (channels
         // two independent axes: different vendor AND different base-model identity (ADDED TO the vendor
-        // rule, never replacing it — a future edit can't silently drop either).
+        // rule, never replacing it — a future edit can't silently drop either). The diversity filter runs
+        // BEFORE preference ranking: prefer sorts survivors only, so no entry can resurrect an excluded channel.
         .filter((c) => c.vendor !== authorChannel.vendor && modelId(c.model) !== modelId(author.model) && !exclude.includes(channelKey(c)))
-        .sort((a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b))[0] ?? null);
+        .sort((a, b) => reviewPreferIndex(a, prefer) - reviewPreferIndex(b, prefer) || TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b))[0] ?? null);
 }
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers) {
     if (task.complexity < cfg.review.complexityThreshold) {
         return { gate: "review", pass: true, details: `skipped — complexity ${task.complexity} < threshold ${cfg.review.complexityThreshold}`, meta: { skipped: true } };
     }
-    const reviewer = pickReviewer(author, channels, excludeReviewers ?? []);
+    const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? []);
     if (!reviewer) {
         return cfg.review.required
             ? { gate: "review", pass: false, details: "no cross-vendor reviewer available (diversity rule); set review.required:false to waive" }

package/dist/run/daemon.d.ts

@@ -5,6 +5,7 @@ import { type JournalEvent } from "./journal.js";
 export interface RunOptions {
     runId?: string;
     resume?: boolean;
+    supersedes?: string;
     graphChanged?: boolean;
     concurrency?: number;
     driver?: ExecutorDriver;

package/dist/run/daemon.js

@@ -98,6 +98,10 @@ export async function runDaemon(repoRoot, opts = {}) {
     // HARD-01/02: hold the run lock across the whole read-modify-write of graph.json. Acquire
     // BEFORE loadGraph; release in the finally below (every exit path, incl. throws).
     const runId = opts.runId ?? newRunId();
+    // v1.53 T5: an unknown --supersedes id must fail BEFORE any run starts — Journal.open throws and
+    // no lock, journal, or baseline for the new run has been created yet. Opened without a narrate
+    // sink: the prior journal append below is silent bookkeeping, not this run's narration.
+    const prior = opts.supersedes !== undefined ? Journal.open(repoRoot, opts.supersedes) : undefined;
     // T6 narrator: one live status surface per run (herdr only — driver.narrator is undefined on
     // subprocess, so the optional-chain open below is a no-op there). Cosmetic-only: any failure is
     // swallowed (never affects the run); the operator closes a surviving watch pane.
@@ -140,6 +144,11 @@ export async function runDaemon(repoRoot, opts = {}) {
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
         if (opts.resume) {
+            // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
+            // two-concurrent-runs hazard supersession exists to prevent. Fail closed, naming the successor.
+            const superseded = [...journal.read()].reverse().find((e) => e.event === "superseded" && typeof e.data.by === "string");
+            if (superseded)
+                throw new Error(`refusing to resume ${runId}: superseded by ${superseded.data.by}`);
             const start = journal.read().find((e) => e.event === "run-start");
             if (!start)
                 throw new Error(`journal for ${runId} has no run-start event`);
@@ -175,7 +184,10 @@ export async function runDaemon(repoRoot, opts = {}) {
             baseRef = await gitHead(repoRoot);
             baseline = await captureBaseline(repoRoot, commands);
             writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
-            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2
+            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
+            // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
+            // names a successor that has no journal. Append-only — the prior journal is never rewritten.
+            prior?.append("superseded", undefined, { by: runId });
         }
         // T6: open the narrator AFTER run-start/run-resume is journaled so the watch surface has a run to
         // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
@@ -412,13 +424,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                 }
                 // v1.29: consume the prior gate-failed session once. Same channel + known under-threshold context
                 // + adapter capability resumes; every other path is today's fresh dispatch.
+                // v1.53 T3: an adapter with no context surface at all (kimi, KIMI-03) may declare
+                // resumeUnknownContext to loosen ONLY the contextTokens-known requirement — a KNOWN
+                // over-threshold context still forces fresh, and the escalation ladder bounds the chain.
                 const priorSession = retrySession;
                 retrySession = undefined;
+                const retryAdapter = adapters.find((a) => a.id === assignment.adapter);
                 retryMode = priorSession
                     && priorSession.channel === channelKey(assignment)
-                    && priorSession.contextTokens !== undefined
-                    && priorSession.contextTokens < cfg.contextWarnTokens
-                    && adapters.find((a) => a.id === assignment.adapter)?.resumeCommand
+                    && (priorSession.contextTokens !== undefined
+                        ? priorSession.contextTokens < cfg.contextWarnTokens
+                        : retryAdapter?.resumeUnknownContext === true)
+                    && retryAdapter?.resumeCommand
                     ? "resume"
                     : "fresh";
                 // v1.23 T3: over-threshold context still forces fresh at the retry boundary; never interrupt a
@@ -854,7 +871,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                     break gateLoop;
                 }
                 gateFails++; // this attempt's gates failed — the one place quality degradation is verified (never inferred from attempts)
-                retrySession = { channel: channelKey(assignment), id: sessionId, contextTokens };
+                // v1.53 T3: prefer the CLI's own session id captured from this attempt's output (kimi's resume
+                // trailer) over the harness slot name; absent hook or no capture keeps today's slot-name id.
+                retrySession = { channel: channelKey(assignment), id: adapter.sessionIdFrom?.(output) ?? sessionId, contextTokens };
                 feedback = results.filter((g) => !g.pass).map((g) => `${g.gate}: ${g.details}`).join("\n\n");
                 const step = r.ladder[Math.min(ladderIdx++, r.ladder.length - 1)];
                 journal.append("escalation", t.id, { step, attempt: attempt + 1 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.52.0",
+  "version": "1.53.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",