tickmarkr 1.78.0 → 1.80.0

package/dist/adapters/claude-code.d.ts

@@ -1,5 +1,16 @@
 import { type AuthHealth, type TrustDialog, type WorkerAdapter } from "./types.js";
+export declare const CLAUDE_ALIAS_IDENTITY_STAMPS: {
+    readonly fable: "claude-fable-5";
+    readonly opus: "claude-opus-4-8";
+    readonly sonnet: "claude-sonnet-5";
+    readonly haiku: "claude-haiku-4-5-20251001";
+};
+export type ClaudeAlias = keyof typeof CLAUDE_ALIAS_IDENTITY_STAMPS;
+export type ClaudeAliasIdentityProbe = (cwd: string, alias: ClaudeAlias) => string | undefined;
 export declare const CLAUDE_TRUST_DIALOG: TrustDialog;
 export declare function claudeSlug(real: string): string;
+export declare function readClaudeAliasIdentity(cwd: string, alias: ClaudeAlias): string | undefined;
+export declare function probeClaudeAliasIdentity(cwd: string, alias: ClaudeAlias): string | undefined;
+export declare function resolveClaudeAliasIdentity(cwd: string, alias: ClaudeAlias, probe?: ClaudeAliasIdentityProbe): string | undefined;
 export declare function probeVersion(bin: string): AuthHealth;
 export declare const claudeCode: WorkerAdapter;

package/dist/adapters/claude-code.js

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
 // SPEND-01/SPEND-11: claude writes a per-session JSONL to ~/.claude/projects/<slug>/ where slug is the
 // realpath'd cwd with every non-alphanumeric char replaced by "-" (verified 114/114 — 36-DIAGNOSIS.md).
 // The old `/`-only formula missed the "." in `.tickmarkr/worktrees/…` — ENOENT on every worktree dispatch.
@@ -20,6 +20,20 @@ import { channelsFromConfig, shq, TokenUsageSchema } from "./types.js";
 // Phase 18's operator-price × tokens derivation, not a CLI claim.
 const MAX_SESSION_FILES = 20; // newest-first; a long-lived project dir can hold many sessions
 const MAX_SESSION_BYTES = 8_000_000; // per-file cap; a runaway JSONL cannot make the read unbounded
+// OBS-145: these aliases float at the Claude CLI layer, while their tier/pricing decisions were
+// made for the dated identities below (claude-code seeds stamped 2026-07-09 — doctor's own lint).
+// Updating a stamp is a deliberate benchmark-policy act; doctor only compares against it and never
+// edits tiers, pricing, learned scores, or routing. `opus` is deliberately left at 4-8: the OBS-145
+// drill probed the alias at claude-opus-4-8 matching its stamp, then captured it re-pointing to
+// claude-opus-5 ~30 min later with zero events fired. The 2026-07-24 fit added an EXPLICIT
+// claude-opus-5 channel to the repo overlay — it did not re-date this alias's stamps, so the
+// alias channel still carries 4-8-dated tier/pricing while serving 5. That warning is true.
+export const CLAUDE_ALIAS_IDENTITY_STAMPS = {
+    fable: "claude-fable-5",
+    opus: "claude-opus-4-8",
+    sonnet: "claude-sonnet-5",
+    haiku: "claude-haiku-4-5-20251001",
+};
 // v1.75 T2 / OBS-137: current Claude Code workspace-trust prompt (2.1.218). The full question
 // distinguishes this startup gate from routine agent text; Enter accepts the selected trust option.
 export const CLAUDE_TRUST_DIALOG = {
@@ -29,6 +43,95 @@ export const CLAUDE_TRUST_DIALOG = {
 export function claudeSlug(real) {
     return real.replace(/[^A-Za-z0-9]/g, "-");
 }
+// 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) {
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => {
+        try {
+            return { f, m: statSync(join(dir, f)).mtimeMs };
+        }
+        catch {
+            return undefined; // a stat failure just drops that file
+        }
+    })
+        .filter((x) => x !== undefined)
+        .sort((a, b) => b.m - a.m)
+        .slice(0, MAX_SESSION_FILES)
+        .map((x) => x.f);
+}
+const belongsToAliasFamily = (identity, alias) => identity === alias || identity.split(/[^A-Za-z0-9]+/).includes(alias);
+// Zero-token first choice: Claude assistant records state the resolved message.model. The newest
+// matching family record in this cwd wins. Every failure is advisory/unknown, never an exception.
+export function readClaudeAliasIdentity(cwd, alias) {
+    try {
+        const real = realpathSync(cwd);
+        const dir = join(homedir(), ".claude", "projects", claudeSlug(real));
+        let newest;
+        for (const f of newestSessionFiles(dir)) {
+            let text;
+            try {
+                text = readFileSync(join(dir, f), "utf8").slice(0, MAX_SESSION_BYTES);
+            }
+            catch {
+                continue;
+            }
+            for (const line of text.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let raw;
+                try {
+                    raw = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const rec = raw;
+                if (rec.cwd !== real || typeof rec.message?.model !== "string")
+                    continue;
+                const identity = rec.message.model;
+                const timestamp = Date.parse(String(rec.timestamp));
+                if (!MODEL_ID_RE.test(identity) || !belongsToAliasFamily(identity, alias) || !Number.isFinite(timestamp))
+                    continue;
+                if (!newest || timestamp > newest.timestamp)
+                    newest = { identity, timestamp };
+            }
+        }
+        return newest?.identity;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Store silence earns one minimal stated-identity turn. The output contract is intentionally strict:
+// one safe model id from the requested alias family, otherwise unknown/fail-open. Vitest never spawns
+// a real agent CLI; tests inject the probe callback at resolveClaudeAliasIdentity instead.
+export function probeClaudeAliasIdentity(cwd, alias) {
+    if (process.env.VITEST)
+        return undefined;
+    try {
+        const r = spawnSync("claude", [
+            "-p",
+            "State the exact model identifier serving this request. Reply with only that identifier.",
+            "--model", alias,
+            "--permission-mode", "bypassPermissions",
+            "--strict-mcp-config",
+            "--mcp-config", '{"mcpServers":{}}',
+            "--output-format", "text",
+        ], { cwd, encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"] });
+        if (r.error || r.status !== 0)
+            return undefined;
+        const identity = (r.stdout || "").trim();
+        return MODEL_ID_RE.test(identity) && belongsToAliasFamily(identity, alias) ? identity : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveClaudeAliasIdentity(cwd, alias, probe = probeClaudeAliasIdentity) {
+    return readClaudeAliasIdentity(cwd, alias) ?? probe(cwd, alias);
+}
 export function probeVersion(bin) {
     const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 10000 });
     if (r.error || r.status !== 0)
@@ -75,24 +178,10 @@ export const claudeCode = {
             const real = realpathSync(cwd); // resolve symlinks (darwin /tmp → /private/tmp)
             const slug = claudeSlug(real);
             const dir = join(homedir(), ".claude", "projects", slug);
-            // newest-first by mtime, bounded — mtime picks WHICH files to scan, never a record's cursor.
-            const files = readdirSync(dir)
-                .filter((f) => f.endsWith(".jsonl"))
-                .map((f) => {
-                try {
-                    return { f, m: statSync(join(dir, f)).mtimeMs };
-                }
-                catch {
-                    return undefined; // a stat failure just drops that file
-                }
-            })
-                .filter((x) => x !== undefined)
-                .sort((a, b) => b.m - a.m)
-                .slice(0, MAX_SESSION_FILES);
             let input = 0, output = 0, kept = false;
             let cacheRead, cacheWrite;
             const seen = new Set(); // message.id is globally unique across session files in one call
-            for (const { f } of files) {
+            for (const f of newestSessionFiles(dir)) {
                 let text;
                 try {
                     text = readFileSync(join(dir, f), "utf8").slice(0, MAX_SESSION_BYTES);

package/dist/adapters/kimi.d.ts

@@ -13,9 +13,15 @@ export declare function kimiBannerModel(banner: string): string | undefined;
 export declare function kimiBannerSessionId(banner: string): string | undefined;
 export type KimiBannerConfirm = {
     ok: true;
+    status: "confirmed";
+    sessionId?: string;
+} | {
+    status: "unknown";
+    printedModel?: string;
     sessionId?: string;
 } | {
     ok: false;
+    status: "mismatch";
     error: string;
 };
 export declare function confirmKimiSeedBanner(banner: string, assignedModel: string): KimiBannerConfirm;

package/dist/adapters/kimi.js

@@ -96,11 +96,26 @@ export async function probeKimiDoctorTurn(cwd) {
 // Prefer a banner Session line when present so seed-mode captures the id from the launch banner
 // itself rather than waiting for a completion-time resume trailer (which the TUI may never emit).
 const RESUME_TRAILER_RE = /^\s*To resume this session: kimi -r (session_[0-9a-f-]+)\s*$/;
-const BANNER_SESSION_LINE_RE = /^\s*Session:\s*(session_[0-9a-f-]+)\s*$/;
+const BANNER_SESSION_RE = /^Session:\s*(session_[0-9a-f-]+)$/;
+const BANNER_MODEL_RE = /^Model:\s*(.+)$/;
+function kimiBannerLines(banner) {
+    // The live TUI renders banner fields as indented rows inside `│ ... │`. Strip only that
+    // per-line margin/chrome, following prompt.ts's pane-text precedent; preserve field content.
+    return banner.split("\n")
+        .map((line) => line.replace(/^[\s│|]+/, "").replace(/[\s│|]+$/, ""));
+}
+function kimiBannerPrintedModel(banner) {
+    for (const line of kimiBannerLines(banner)) {
+        const printedModel = BANNER_MODEL_RE.exec(line)?.[1]?.trim();
+        if (printedModel)
+            return printedModel;
+    }
+    return undefined;
+}
 export function kimiSessionId(output) {
     let id;
-    for (const line of output.split("\n")) {
-        const banner = BANNER_SESSION_LINE_RE.exec(line);
+    for (const line of kimiBannerLines(output)) {
+        const banner = BANNER_SESSION_RE.exec(line);
         if (banner) {
             id = banner[1];
             continue;
@@ -113,44 +128,84 @@ export function kimiSessionId(output) {
 }
 // v1.69 T7: the cold-start banner prints the model alias and session id. Parse them from the
 // banner text already captured for the readiness match — no new probe, no extra dispatch. Kimi
-// 0.29.0 may print either the full config key or its display suffix; normalize both idempotently
-// to the full channel identifier routing uses.
-const BANNER_MODEL_RE = /^Model:\s*(.+)$/m;
-const BANNER_SESSION_RE = /^Session:\s*(session_[0-9a-f-]+)$/m;
+// may print a display name, the full config key, or its legacy suffix. Resolve only names with a
+// known channel mapping: inventing `kimi-code/<future display>` would turn unknown into mismatch.
+const KIMI_BANNER_MODEL_CHANNELS = new Map([
+    ["K3", "kimi-code/k3"],
+    ["k3", "kimi-code/k3"],
+    ["kimi-code/k3", "kimi-code/k3"],
+    ["K2.7 Coding", "kimi-code/kimi-for-coding"],
+    ["kimi-for-coding", "kimi-code/kimi-for-coding"],
+    ["kimi-code/kimi-for-coding", "kimi-code/kimi-for-coding"],
+    ["K2.7 Coding Highspeed", "kimi-code/kimi-for-coding-highspeed"],
+    ["kimi-for-coding-highspeed", "kimi-code/kimi-for-coding-highspeed"],
+    ["kimi-code/kimi-for-coding-highspeed", "kimi-code/kimi-for-coding-highspeed"],
+]);
 export function kimiBannerModel(banner) {
-    const m = BANNER_MODEL_RE.exec(banner);
-    if (!m)
-        return undefined;
-    const printedModel = m[1].trim();
-    if (!printedModel)
-        return undefined;
-    return printedModel.startsWith("kimi-code/") ? printedModel : `kimi-code/${printedModel}`;
+    const printedModel = kimiBannerPrintedModel(banner);
+    return printedModel === undefined ? undefined : KIMI_BANNER_MODEL_CHANNELS.get(printedModel);
 }
 export function kimiBannerSessionId(banner) {
-    return BANNER_SESSION_RE.exec(banner)?.[1];
+    for (const line of kimiBannerLines(banner)) {
+        const sessionId = BANNER_SESSION_RE.exec(line)?.[1];
+        if (sessionId)
+            return sessionId;
+    }
+    return undefined;
 }
-// Fail closed on a named-model mismatch; a missing Model line is not a mismatch (banner partial).
+// Fail closed on a mapped-model mismatch. Unknown/missing names remain non-blocking for forward
+// compatibility, but carry an explicit unknown status rather than masquerading as confirmation.
 export function confirmKimiSeedBanner(banner, assignedModel) {
+    const sessionId = kimiBannerSessionId(banner);
+    const printedModel = kimiBannerPrintedModel(banner);
     const saw = kimiBannerModel(banner);
-    if (saw !== undefined && saw !== assignedModel) {
-        return { ok: false, error: `model mismatch: expected ${assignedModel}, saw ${saw}` };
+    if (printedModel === undefined || saw === undefined) {
+        return {
+            status: "unknown",
+            ...(printedModel === undefined ? {} : { printedModel }),
+            ...(sessionId === undefined ? {} : { sessionId }),
+        };
+    }
+    if (saw !== assignedModel) {
+        return { ok: false, status: "mismatch", error: `model mismatch: expected ${assignedModel}, saw ${saw}` };
     }
-    return { ok: true, sessionId: kimiBannerSessionId(banner) };
+    return { ok: true, status: "confirmed", ...(sessionId === undefined ? {} : { sessionId }) };
 }
 const kimiTuiLaunch = (model) => `kimi -y -m ${shq(model)}`;
 const KIMI_ANSI_SGR_RE = /\u001B\[[0-9;]*m/g;
 const KIMI_EDITOR_TOP_RE = /^╭─+╮$/;
 const KIMI_EDITOR_INPUT_RE = /^│ > .*│$/;
 const KIMI_EDITOR_EMPTY_RE = /^│ > +│$/;
+// OBS-181: any interior row of the box. An editor carrying a prompt renders one or more blank
+// continuation rows beneath it, so the bottom border is not always the very next line.
+const KIMI_EDITOR_ROW_RE = /^│.*│$/;
 const KIMI_EDITOR_BOTTOM_RE = /^╰─+╯$/;
 function matchesKimiEditorBox(paneText, empty) {
-    const lines = paneText.replace(KIMI_ANSI_SGR_RE, "").split("\n");
+    // OBS-152: kimi renders its whole TUI indented one column, so `^`-anchored row matches never fire
+    // on a LIVE editor box — probe 6 timed out readiness against a frame whose box was fully painted
+    // and interactive. Trim per line: the left margin is chrome, and what actually distinguishes the
+    // editor from the welcome panel (also a bordered box) is the border adjacency asserted below.
+    //
+    // `match` means THE EDITOR BOX IS PAINTED (readiness), and is deliberately true for an empty box.
+    // `emptyMatch` is the stricter "painted AND carrying nothing". Callers deciding submission must
+    // therefore test emptyMatch FIRST — see HerdrDriver.submissionRegistered.
+    //
+    // OBS-181: the adjacency used to demand the bottom border on the line directly below the prompt.
+    // A wedged worker pane rendered FOUR rows — top, prompt, a blank continuation row, bottom — so
+    // NEITHER matcher fired, and the driver's submission check fell through to a fallback that always
+    // answers "delivered". Walk the interior to the border instead of assuming a three-row box.
+    const lines = paneText.replace(KIMI_ANSI_SGR_RE, "").split("\n").map((line) => line.trim());
     const input = empty ? KIMI_EDITOR_EMPTY_RE : KIMI_EDITOR_INPUT_RE;
-    return lines.some((line, index) => input.test(line)
-        && index > 0
-        && index + 1 < lines.length
-        && KIMI_EDITOR_TOP_RE.test(lines[index - 1])
-        && KIMI_EDITOR_BOTTOM_RE.test(lines[index + 1]));
+    return lines.some((line, index) => {
+        if (!input.test(line))
+            return false;
+        if (index === 0 || !KIMI_EDITOR_TOP_RE.test(lines[index - 1]))
+            return false;
+        let below = index + 1;
+        while (below < lines.length && KIMI_EDITOR_ROW_RE.test(lines[below]))
+            below++;
+        return below < lines.length && KIMI_EDITOR_BOTTOM_RE.test(lines[below]);
+    });
 }
 // v1.75 T1 / OBS-136: Kimi's actual editor is a three-line bordered box whose content row starts
 // `│ > `. The welcome panel separately contains "Send /help..." and is only launch-liveness
@@ -170,7 +225,14 @@ const KIMI_SEED = {
     launch: kimiTuiLaunch,
     readinessMatch: "Send /help for help information.",
     seedLine: (promptFile) => `Read ${promptFile} and do exactly what it says.`,
-    confirmBanner: confirmKimiSeedBanner,
+    confirmBanner: (banner, assignedModel) => {
+        const confirmation = confirmKimiSeedBanner(banner, assignedModel);
+        // The generic seed contract is binary: unknown display names remain admissible while the
+        // Kimi-specific result above truthfully keeps them distinct from a confirmed identity.
+        return confirmation.status === "unknown"
+            ? { ok: true, status: confirmation.status, sessionId: confirmation.sessionId }
+            : confirmation;
+    },
 };
 // v1.69 T7 / v1.71 T2: thin wrapper over the daemon's generic dispatch path for kimi-only tests.
 export async function runKimiInteractiveSeed(opts) {

package/dist/adapters/registry.js

@@ -203,7 +203,12 @@ const MODEL_PROBE_PROMPT = "Reply with exactly OK and nothing else.";
 // 60s: a healthy MCP-free codex probe measured 29.9s round-trip (2026-07-15) — 30s had zero headroom.
 const MODEL_PROBE_TIMEOUT_MS = 60000;
 // Auth-words only match when tied to a failure word; bare "auth"/"OAuth"/"authored" never fail (v1.27 T2).
-const AUTH_FAILURE_RE = /\b4\d\d\b|\bauth(?:entication|orization)?\s+(?:error|failed|failure|denied)|unauthori[sz]ed|forbidden|access denied|credit(?:s)?\s+(?:exhausted|error|denied)/i;
+// OBS-150: the 4xx alternative must refuse digit-group context. Bare `\b4\d\d\b` matched "485" inside the
+// token footer "tokens used 26,485" and failed a HEALTHY probe closed — a ~1-in-10 dice roll on EVERY model
+// probe of any adapter that prints a comma-grouped token count. Lookarounds reject a group that is part of a
+// larger number (26,485 · 1.400 · 400.5) while keeping real bare codes (401 · "error 429" · "403 Forbidden."
+// — trailing sentence punctuation still matches, only a following DIGIT means "decimal, not status code").
+const AUTH_FAILURE_RE = /\b(?<![\d.,])4\d\d\b(?![.,]\d)|\bauth(?:entication|orization)?\s+(?:error|failed|failure|denied)|unauthori[sz]ed|forbidden|access denied|credit(?:s)?\s+(?:exhausted|error|denied)/i;
 const PROBE_REASON_CAP = 240;
 // v1.55 T3: the tail must open at a word boundary — a mid-word slice ("odel 'grok-…'") reads as
 // corruption in operator-facing diagnostics. Input is already space-normalized, so " " is the only

package/dist/brand.d.ts

@@ -2,6 +2,10 @@ import type { OwnedName } from "./drivers/types.js";
 export declare const BANNER: string;
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export declare const PLAIN_BANNER: string;
+/** Two-line run-cockpit lockup, sliced from BANNER so its mark and product name cannot drift. */
+export declare const COMPACT_LOCKUP: string;
+/** ANSI-stripped, trailing-space-trimmed twin of COMPACT_LOCKUP for colourless surfaces. */
+export declare const PLAIN_COMPACT_LOCKUP: string;
 export declare const PANE_IDENTITY_ENV = "TICKMARKR_PANE_IDENTITY";
 /** One-line pane identity through the T1 ownership contract: role · task · attempt · run. */
 export declare function paneIdentityLine(o: OwnedName): string;

package/dist/brand.js

@@ -12,6 +12,10 @@ export const BANNER = [
 ].join("\n");
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export const PLAIN_BANNER = BANNER.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
+/** Two-line run-cockpit lockup, sliced from BANNER so its mark and product name cannot drift. */
+export const COMPACT_LOCKUP = BANNER.split("\n").slice(1, 3).join("\n");
+/** ANSI-stripped, trailing-space-trimmed twin of COMPACT_LOCKUP for colourless surfaces. */
+export const PLAIN_COMPACT_LOCKUP = COMPACT_LOCKUP.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
 // T5: the pane identity every visible pane announces under the logo. HerdrDriver seeds this env var
 // into each pane shell at slot() time (paneIdentityLine of the pane's T1 owned name); the banner's
 // identity line reads it at pane runtime, so every role — worker/judge/review/consult — wears the

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

@@ -1,7 +1,9 @@
+import { type ClaudeAlias } from "../../adapters/claude-code.js";
 import type { WorkerAdapter } from "../../adapters/types.js";
 import { type KimiDoctorTurnResult } from "../../adapters/kimi.js";
 export type DoctorOpts = {
     banner?: boolean;
     kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;
+    resolveClaudeAliasIdentity?: (cwd: string, alias: ClaudeAlias) => string | undefined;
 };
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;

package/dist/cli/commands/doctor.js

@@ -1,6 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { BANNER, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
@@ -120,6 +121,28 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // v1.65 T3: hardcoded-flag drift — advisory warn rows only. Runs AFTER writeDoctor so the verdicts
     // can never leak into doctor.json, and discoverChannels/routing never read them.
     rows.push(...flagDriftWarnings(adapters, health).map(attentionRow));
+    // OBS-145: resolved-identity drift is the same class of display-only doctor warning. Stamps live
+    // beside the alias-owning adapter; the comparison runs only for configured floating aliases and
+    // never enters health/doctor.json, config, channel discovery, learned profiles, or route().
+    const identityResolver = opts.resolveClaudeAliasIdentity
+        ?? (adapters.includes(claudeCode) ? resolveClaudeAliasIdentity : undefined);
+    if (identityResolver && health["claude-code"]?.installed) {
+        const configured = cfg.tiers["claude-code"]?.models ?? {};
+        for (const [alias, stampedIdentity] of Object.entries(CLAUDE_ALIAS_IDENTITY_STAMPS)) {
+            if (!(alias in configured))
+                continue;
+            let resolvedIdentity;
+            try {
+                resolvedIdentity = identityResolver(cwd, alias);
+            }
+            catch {
+                continue; // advisory source failure is unknown, never a doctor failure
+            }
+            if (resolvedIdentity && resolvedIdentity !== stampedIdentity) {
+                rows.push(attentionRow(`resolved-identity drift: claude-code:${alias} resolved to ${resolvedIdentity}, stamped identity ${stampedIdentity} — reclassify per benchmark policy (advisory — routing unchanged)`));
+            }
+        }
+    }
     // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, tickmarkr NEVER applies it.
     // TTY gets a one-line summary + the fragment as a file (the full dump drowned everything else,
     // v1.33.1 onboarding); machine/CI surface keeps the inline dump — layout is pinned by tests.

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

@@ -1,3 +1,4 @@
+import { type DecisionEvent, type DecisionWebhookPost } from "../../drivers/types.js";
 import { type Task, type TaskStatus } from "../../graph/schema.js";
 import { type JournalEvent } from "../../run/journal.js";
 export type StatusOpts = {
@@ -5,6 +6,8 @@ export type StatusOpts = {
     sleep?: (ms: number) => Promise<void>;
     now?: () => number;
     readWorkerOutput?: (taskId: string, attempt: number, runId: string) => Promise<string | undefined>;
+    webhookUrl?: string;
+    postWebhook?: DecisionWebhookPost;
 };
 export declare const GATE_KEYS: {
     readonly build: "B";
@@ -15,6 +18,7 @@ export declare const GATE_KEYS: {
     readonly acceptance: "A";
     readonly review: "R";
 };
+export declare const decisionEventsFromJournal: (events: JournalEvent[], runId: string, stateDir?: string) => DecisionEvent[];
 export declare const taskBox: (status: TaskStatus) => string;
 export declare const gateBox: (state: "open" | "pass" | "fail" | "skip", unicode: boolean) => string;
 export type GateState = "open" | "pass" | "fail" | "skip";