tickmarkr 1.64.0 → 1.66.0

package/dist/adapters/claude-code.js

@@ -41,6 +41,9 @@ export const claudeCode = {
     probeCwd: "neutral",
     probe: async () => probeVersion("claude"),
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
+    // v1.65 T3: every flag the command builders below hardcode — doctor checks `claude --help` still
+    // lists each (all present on claude 2.x, verified 2026-07-22). Advisory only, never routing.
+    hardcodedFlags: { binary: "claude", flags: ["-p", "--model", "--permission-mode", "--strict-mcp-config", "--mcp-config", "--output-format", "-r"] },
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree
     // workers/gates don't load project .mcp.json servers (herdr scrapes dialogs as idle — v1.4 incident,
     // memory tickmarkr-worker-mcp-dialog-stall). Live-verified 2026-07-10 on claude 2.1.205 (operator check):

package/dist/adapters/codex.js

@@ -169,6 +169,9 @@ export const codex = {
     probeConcurrency: 1,
     probe: async () => probeVersion("codex"),
     channels: (cfg) => channelsFromConfig("codex", cfg),
+    // v1.65 T3: every flag the command builders below hardcode (incl. codexMcpSuppressionFlags' -c/
+    // --disable and GITDIR_WRITABLE's -c) — all listed by top-level `codex --help`, verified 2026-07-22.
+    hardcodedFlags: { binary: "codex", flags: ["--sandbox", "--model", "-a", "-s", "-c", "--disable"] },
     // --sandbox workspace-write is the autonomous sandbox mode (codex v0.144.1+)
     // MCP suppression built per dispatch (config can change between runs) — see codexMcpSuppressionFlags.
     headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,

package/dist/adapters/cursor-agent.js

@@ -36,6 +36,8 @@ export const cursorAgent = {
     vendor: "cursor",
     probe: async () => probeVersion("cursor-agent"),
     channels: (cfg) => channelsFromConfig("cursor-agent", cfg),
+    // v1.65 T3: every flag the command builders below hardcode — verified in `cursor-agent --help` 2026-07-22.
+    hardcodedFlags: { binary: "cursor-agent", flags: ["-p", "--model", "--force", "--output-format"] },
     headlessCommand: (promptFile, model) => `cursor-agent -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --force --output-format text`,
     // NO --trust here: cursor rejects it outside --print ("--trust can only be used with --print/headless
     // mode", exit 1 — v1.4 phase-1 incident). Fresh worktrees therefore show the trust dialog; v1.22 T5

package/dist/adapters/grok.js

@@ -98,6 +98,8 @@ export const grok = {
             : { ...h, authed: false, note: "no valid ~/.grok/auth.json entry (grok login to fix)" };
     },
     channels: (cfg) => channelsFromConfig("grok", cfg),
+    // v1.65 T3: every flag the command builders below hardcode — verified in `grok --help` 2026-07-22.
+    hardcodedFlags: { binary: "grok", flags: ["-p", "--model", "--permission-mode", "--output-format"] },
     // GROK-02 headless. --output-format plain is the default but pin it explicitly; live-verified
     // 2026-07-11 (40-RESEARCH F-3): trailer intact + unwrapped, exit 0. "$(cat file)" matches every
     // other adapter and is already quoting-proven. --permission-mode bypassPermissions is the

package/dist/adapters/kimi.js

@@ -96,6 +96,9 @@ export const kimi = {
             : { ...h, authed: false, note: "no valid ~/.kimi-code/credentials/kimi-code.json (kimi login to fix)" };
     },
     channels: (cfg) => channelsFromConfig("kimi", cfg),
+    // v1.65 T3: every flag the command builders below hardcode (-S is resumeCommand's) — verified in
+    // `kimi --help` 2026-07-22.
+    hardcodedFlags: { binary: "kimi", flags: ["-p", "--model", "--output-format", "-S"] },
     // KIMI-02 headless. -p prompt mode + explicit model, NO permission flag: kimi 0.26.0 rejects
     // -p combined with -y/--auto at argument parse time ("Cannot combine --prompt with --yolo",
     // OBS-67 — doctor probes all failed on it), and prompt mode is already non-interactive with

package/dist/adapters/opencode.js

@@ -19,6 +19,9 @@ export const opencode = {
     probeCwd: "neutral",
     probe: async () => probeVersion("opencode"),
     channels: (cfg) => channelsFromConfig("opencode", cfg),
+    // v1.65 T3: every flag the command builders below hardcode (-m on run, --prompt on the TUI) —
+    // per the 2026-07-10 live verification, opencode 1.17.15.
+    hardcodedFlags: { binary: "opencode", flags: ["-m", "--prompt"] },
     headlessCommand: (promptFile, model) => `opencode run -m ${shq(model)} "$(cat ${shq(promptFile)})"`,
     interactiveCommand: (promptFile, model) => `opencode -m ${shq(model)} --prompt "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {

package/dist/adapters/pi.js

@@ -48,6 +48,8 @@ export const pi = {
         return { ...h, servable: parsePiModels(r.stdout || ""), note: "auth verified via pi --list-models (free; auth-filtered by pi)" };
     },
     channels: (cfg) => channelsFromConfig("pi", cfg),
+    // v1.65 T3: every flag the command builders below hardcode — verified in `pi --help` 2026-07-22.
+    hardcodedFlags: { binary: "pi", flags: ["-p", "--approve", "--model"] },
     // --approve: pi's per-directory trust prompt would stall fresh worktrees (herdr scrapes the dialog
     // as idle — cursor/claude incident class, milestone PITFALLS #2). Global option, legal in BOTH modes
     // per pi --help v0.80.3 (2026-07-10) — NOT print-only like cursor's --trust. Chosen over the more

package/dist/adapters/prompt.d.ts

@@ -3,4 +3,8 @@ 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;
+export declare const NO_TRAILER_SUMMARY = "worker produced no TICKMARKR_RESULT trailer";
+export declare const UNPARSEABLE_TRAILER_SUMMARY = "unparseable TICKMARKR_RESULT trailer";
 export declare function parseWorkerResult(raw: string, nonce: string): WorkerResult;
+export type DeadChannelReason = "auth-required" | "setup-required" | "provider-outage" | "timeout";
+export declare function classifyDeadChannel(result: WorkerResult): DeadChannelReason | undefined;

package/dist/adapters/prompt.js

@@ -41,11 +41,15 @@ function trailerTokenPositions(raw, nonce) {
         positions.push(i);
     return positions;
 }
+// v1.65 T1: the parse boundary's own no-trailer sentinel summaries. classifyDeadChannel keys on
+// these — a result carrying any other summary is a PARSED trailer, i.e. the worker speaking.
+export const NO_TRAILER_SUMMARY = "worker produced no TICKMARKR_RESULT trailer";
+export const UNPARSEABLE_TRAILER_SUMMARY = "unparseable TICKMARKR_RESULT trailer";
 export function parseWorkerResult(raw, nonce) {
     const fail = (summary) => ({ ok: false, summary, deviations: [], raw });
     const positions = trailerTokenPositions(raw, nonce);
     if (positions.length === 0)
-        return fail("worker produced no TICKMARKR_RESULT trailer");
+        return fail(NO_TRAILER_SUMMARY);
     // TUIs echo the prompt template, redraw lines, and HARD-wrap the JSON with per-line margins
     // (cursor does; recent-unwrapped can't rejoin hard newlines). Scan occurrences backward — last
     // parseable wins — joining wrapped lines, stripping margin/box chrome, and growing the candidate
@@ -75,5 +79,27 @@ export function parseWorkerResult(raw, nonce) {
             }
         }
     }
-    return fail("unparseable TICKMARKR_RESULT trailer");
+    return fail(UNPARSEABLE_TRAILER_SUMMARY);
+}
+// Signatures anchor distinctive CLI-error phrasing — never bare fragments or bare status-code
+// numbers (the QUOTA_RE Pitfall-3 lesson): these run only over no-trailer output, but a stalled
+// worker's harvested pane can still contain ordinary work text.
+const AUTH_RE = /not logged in|please (?:log ?in|sign in)|please run [^\n]{0,30}log ?in|authentication[ _](?:required|failed|error)|invalid (?:api key|credentials)|api key (?:is )?(?:not set|missing|invalid|required)|credentials? (?:have )?expired|401 unauthorized/i;
+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;
+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.
+    if (result.ok || (result.summary !== NO_TRAILER_SUMMARY && result.summary !== UNPARSEABLE_TRAILER_SUMMARY))
+        return undefined;
+    if (AUTH_RE.test(result.raw))
+        return "auth-required";
+    if (SETUP_RE.test(result.raw))
+        return "setup-required";
+    if (OUTAGE_RE.test(result.raw))
+        return "provider-outage";
+    if (TIMEOUT_RE.test(result.raw))
+        return "timeout";
+    return undefined;
 }

package/dist/adapters/registry.d.ts

@@ -12,6 +12,9 @@ export declare function detectCandidateClis(opts?: {
     pathEnv?: string;
 }): CandidateCliDetection[];
 export declare function formatCandidateCliRow({ binary, version }: CandidateCliDetection): string;
+export declare function probeHelpText(bin: string): string | undefined;
+export declare function missingDeclaredFlags(helpText: string, flags: string[]): string[];
+export declare function flagDriftWarnings(adapters: WorkerAdapter[], health: Record<string, AuthHealth>, helpOf?: (bin: string) => string | undefined): string[];
 export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
 }): WorkerAdapter[];

package/dist/adapters/registry.js

@@ -53,6 +53,44 @@ export function formatCandidateCliRow({ binary, version }) {
     const ver = version ?? "version unknown";
     return `  ! ${binary.padEnd(14)} detected: ${ver} (no tickmarkr adapter — not routable)`;
 }
+// v1.65 T3: same guarded spawn pattern as probeCandidateVersion — bounded, error/status-checked,
+// fail-open. undefined = binary unavailable/broken ⇒ no drift verdict (the existing auth reporting
+// already names an uninstalled CLI; drift must never pile on).
+export function probeHelpText(bin) {
+    try {
+        const r = spawnSync(bin, ["--help"], { encoding: "utf8", timeout: 10000 });
+        if (r.error || r.status !== 0)
+            return undefined;
+        return `${r.stdout || ""}\n${r.stderr || ""}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Whole-token match only: "-p" must never count as present because "--print" contains it, and
+// "--output" must not match a listed "--output-format". Splitting on non-flag chars keeps each
+// help-listed flag intact as one token ("-p, --print <fmt>" → "-p", "--print", "fmt").
+export function missingDeclaredFlags(helpText, flags) {
+    const tokens = new Set(helpText.split(/[^A-Za-z0-9_-]+/));
+    return flags.filter((f) => !tokens.has(f));
+}
+// v1.65 T3: advisory hardcoded-flag drift check. Reads help, mutates nothing — health, doctor.json,
+// discoverChannels, and routing never see these strings; they are doctor display rows only.
+export function flagDriftWarnings(adapters, health, helpOf = probeHelpText) {
+    const out = [];
+    for (const a of adapters) {
+        const decl = a.hardcodedFlags;
+        if (!decl || !health[a.id]?.installed)
+            continue;
+        const help = helpOf(decl.binary);
+        if (help === undefined)
+            continue;
+        for (const flag of missingDeclaredFlags(help, decl.flags)) {
+            out.push(`flag drift: ${a.id} hardcodes ${flag} but ${decl.binary} --help no longer lists it (advisory — routing unchanged)`);
+        }
+    }
+    return out;
+}
 export function allAdapters(opts = {}) {
     // pi + grok + kimi appended LAST: same-tier ties resolve by discovery order (Phase 6 D2), so
     // appending keeps the Phase 6 shape→channel matrix byte-identical; inserting anywhere else

package/dist/adapters/types.d.ts

@@ -91,6 +91,10 @@ export interface WorkerAdapter {
     contextUsage?(session: SessionRef): ContextUsage | null;
     trust?(repoRoot: string): TrustVerdict;
     trustDialog?: TrustDialog;
+    hardcodedFlags?: {
+        binary: string;
+        flags: string[];
+    };
 }
 export declare function channelsFromConfig(adapterId: string, cfg: TickmarkrConfig): BillingChannel[];
 export declare function channelKey(c: {

package/dist/cli/commands/doctor.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, detectCandidateClis, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, detectCandidateClis, flagDriftWarnings, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.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";
@@ -85,6 +85,9 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const servable = servableExclusions(cfg, adapters, health);
     if (servable.length)
         rows.push(attentionRow(servabilityLine(servable)));
+    // 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));
     // 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.js

@@ -1,6 +1,7 @@
 import { BANNER, GLYPHS, dim, fail, legend, ok, rule, statusRow, title, warn } from "../../brand.js";
-import { blockedTasks, graphDefinitionHash, loadGraph, pendingTasks } from "../../graph/graph.js";
+import { blockedTasks, graphDefinitionHash, loadGraph } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
+import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable } from "../../run/journal.js";
 // ponytail: fixed 2s refresh; promote to config.visibility.* only when an operator asks.
 const REFRESH_MS = 2000;
@@ -171,14 +172,17 @@ const renderFrame = (cwd) => {
     }
     const effective = { ...g, tasks: g.tasks.map((t) => ({ ...t, status: replayed?.get(t.id) ?? t.status })) };
     const starved = new Set(blockedTasks(effective).map((t) => t.id));
-    const waiting = new Set(pendingTasks(effective).map((t) => t.id));
+    // OBS-104: ONE activity fold feeds both surfaces — never re-derived here. Comparable events only
+    // (a recompiled graph's journal must not animate the wrong tasks); with no or stale journal the
+    // dep-waiting cells still derive from the effective graph statuses.
+    const activity = foldActivity(comparable ? events : [], effective.tasks);
     const unicode = visual();
     const divider = unicode ? " · " : " / ";
     const width = process.stdout.columns ?? 120;
     const done = effective.tasks.filter((t) => t.status === "done").length;
     const cells = g.tasks.map((t) => {
         const st = replayed?.get(t.id) ?? t.status;
-        const label = starved.has(t.id) ? " starved" : waiting.has(t.id) ? " dep-waiting" : "";
+        const label = starved.has(t.id) ? " starved" : activity.cells.has(t.id) ? ` ${activity.cells.get(t.id)}` : "";
         const channel = assignments.get(t.id) ?? "-";
         const assignCol = contexts.has(t.id) ? `${channel}${divider}ctx ${contexts.get(t.id)}` : channel;
         return { t, st, label, assignCol, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
@@ -218,6 +222,10 @@ const renderFrame = (cwd) => {
             : `no runs yet${dot}`) +
         `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
     const hr = rule(Math.min(width, 100));
+    // OBS-104 run-level now line: names the most recent journal event. TTY frame only — the non-TTY
+    // machine surface is byte-pinned (status-brand golden) and must not drift. Rendered BELOW the task
+    // rows: the line names task ids, and rows must stay the first id-bearing lines for grep consumers.
+    const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
     const gatesLegend = legend(`   gates: ${GATE_NAMES.join(" · ")}`);
     const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
@@ -238,7 +246,7 @@ const renderFrame = (cwd) => {
             " ".repeat(stW - (String(st) + label + failedSuffix(states) + human).length);
         return `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`)}`;
     });
-    return [header, hr, gatesLegend, ...rows].join("\n");
+    return [header, hr, gatesLegend, ...rows, ...nowLine].join("\n");
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     // cockpit surface: banner + frame on a TTY (doctor's pattern); pipes get the bare frame

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

@@ -0,0 +1,5 @@
+import { type StudioOptions } from "../../tui/app.js";
+export declare function ui(_argv: string[], io?: Partial<StudioOptions>): Promise<string | {
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/ui.js

@@ -0,0 +1,13 @@
+import { StudioApp } from "../../tui/app.js";
+const NON_TTY_MSG = "tickmarkr ui: studio requires a TTY — use `tickmarkr fleet --print` or `tickmarkr status --watch` for line-mode output";
+export async function ui(_argv, io = {}) {
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    if (input.isTTY !== true || output.isTTY !== true) {
+        return { out: NON_TTY_MSG, code: 1 };
+    }
+    const app = new StudioApp({ input, output });
+    app.start();
+    await app.exited;
+    return "ui: closed";
+}

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -13,11 +13,12 @@ import { resume } from "./commands/resume.js";
 import { run } from "./commands/run.js";
 import { scope } from "./commands/scope.js";
 import { status } from "./commands/status.js";
+import { ui } from "./commands/ui.js";
 import { unlock } from "./commands/unlock.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -35,6 +36,7 @@ usage: tickmarkr <command>
   resume <id>   continue a run from its journal
   report <id>   cost/quality report (--md for committable execution record)
   profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)
+  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)
   unlock        remove a stale/garbage run lock (refuses if the holder is alive)
   approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume`;
 // pure, testable dispatcher: resolves a command, forwards argv, shapes the result — no side effects.

package/dist/config/config.js

@@ -468,7 +468,10 @@ export function configTemplate(overlay) {
 #   explore: { mode: on, excludeShapes: [], excludeComplexityAtOrAbove: null, cap: 5 }  # optional; absent ⇒ byte-identical
 #   sla: { implement: 15 }  # optional per-shape minutes — advisory plan lint only; absent ⇒ no lint
 #   allow: { adapters: [claude-code, codex] }   # optional fleet allowlist; presence activates even if empty (fail-closed)
-#   deny: { models: [codex:gpt-5.5] }           # optional fleet denylist; deny beats allow on conflict
+#   deny:                                      # optional fleet denylist; deny beats allow on conflict
+#     models:
+#       - pi:zai/glm-5.2  # OBS-57: pi passes run-start probe but hangs at finish without TICKMARKR_RESULT — remove after no-trailer demotion ships (v1.46 provider-outage taxonomy)
+#   # incident-born deny/pin entries MUST name OBS id + root cause + removal condition (see docs/codebase/CONVENTIONS.md)
 #   # entry grammar: adapter id | model id | adapter:model (entries in either list accept all three forms)
 #   # a hint pinning a denied channel FAILS at plan time (RoutingError) — never silent reroute
 #   # tombstone: deny: null in a repo overlay removes a global deny (arrays replace wholesale, never merge)

package/dist/run/activity.d.ts

@@ -0,0 +1,15 @@
+import { type JournalEvent } from "./journal.js";
+export interface ActivityTask {
+    id: string;
+    gates: readonly string[];
+    deps: readonly string[];
+    /** the surface's effective status for the task (replayed ?? graph) */
+    status: string;
+}
+export interface ActivitySnapshot {
+    /** run-level now line naming the most recent journal event; absent when there are no events */
+    now?: string;
+    /** taskId → current-activity phrase; absent = idle (terminal, or queued with met deps) */
+    cells: Map<string, string>;
+}
+export declare function foldActivity(events: JournalEvent[], tasks: readonly ActivityTask[]): ActivitySnapshot;

package/dist/run/activity.js

@@ -0,0 +1,96 @@
+import { formatJournalNarration } from "./journal.js";
+const channelOf = (assignment) => {
+    const a = assignment;
+    return typeof a?.adapter === "string" && typeof a.model === "string" ? `${a.adapter}:${a.model}` : "unknown channel";
+};
+const cellText = (st, task) => {
+    switch (st.kind) {
+        case "worker":
+            // since is the dispatch event's own ISO ts — sliced, never re-clocked (purity)
+            return `attempt ${st.attempt} in flight on ${st.channel} since ${st.since.slice(11, 19)}`;
+        case "gates": {
+            const next = task.gates.find((g) => !st.results.has(g));
+            if (next)
+                return `gate ${next} running`;
+            // every declared gate has a result: all pass ⇒ the daemon is merging; any fail ⇒ a retry decision is next
+            return [...st.results.values()].every(Boolean) ? "merging" : "retrying";
+        }
+        case "retrying":
+            return "retrying";
+        case "parked":
+            return st.note ? `parked (${st.note})` : "parked";
+    }
+};
+export function foldActivity(events, tasks) {
+    const live = new Map();
+    // a daemon (re)start or run-end means no attempt/gate is in flight — mirror reconcile.ts; parks persist
+    const clearTransient = () => {
+        // deleting the current entry mid-iteration is well-defined for Map
+        for (const [id, st] of live)
+            if (st.kind !== "parked")
+                live.delete(id);
+    };
+    for (const e of events) {
+        if (e.event === "run-start" || e.event === "run-resume" || e.event === "run-end") {
+            clearTransient();
+            continue;
+        }
+        const id = e.taskId;
+        if (!id)
+            continue;
+        switch (e.event) {
+            case "task-dispatch":
+                live.set(id, {
+                    kind: "worker",
+                    attempt: (Number.isInteger(e.data.attempt) ? e.data.attempt : 0) + 1,
+                    channel: channelOf(e.data.assignment),
+                    since: e.ts,
+                });
+                break;
+            case "worker-result":
+                // a clean trailer moves the task into gating; anything else is heading for a retry decision
+                live.set(id, e.data.ok === true && e.data.finished === true ? { kind: "gates", results: new Map() } : { kind: "retrying" });
+                break;
+            case "gate-result": {
+                const prev = live.get(id);
+                const results = prev?.kind === "gates" ? prev.results : new Map();
+                if (typeof e.data.gate === "string")
+                    results.set(e.data.gate, e.data.pass === true || e.data.skipped === true);
+                live.set(id, { kind: "gates", results });
+                break;
+            }
+            case "escalation":
+            case "consult-verdict":
+            case "quota-failover":
+            case "provider-death-requeue":
+            case "merge-conflict":
+                live.set(id, { kind: "retrying" });
+                break;
+            case "task-human":
+                live.set(id, { kind: "parked", ...(typeof e.data.kind === "string" ? { note: e.data.kind } : {}) });
+                break;
+            case "task-done":
+            case "task-failed":
+            case "task-approved":
+                live.delete(id);
+                break;
+        }
+    }
+    const status = new Map(tasks.map((t) => [t.id, t.status]));
+    const cells = new Map();
+    for (const t of tasks) {
+        const st = live.get(t.id);
+        if (st) {
+            cells.set(t.id, cellText(st, t));
+            continue;
+        }
+        if (t.status !== "pending")
+            continue;
+        // dep-waiting is reserved for genuinely unmet deps — a bare pending task gets no cell (OBS-104 fix 1)
+        const unmet = t.deps.filter((d) => status.get(d) !== "done");
+        if (unmet.length)
+            cells.set(t.id, `dep-waiting on ${unmet.join(", ")}`);
+    }
+    const last = events.at(-1);
+    return { ...(last ? { now: formatJournalNarration(last) } : {}), cells };
+}

package/dist/run/consult.js

@@ -5,6 +5,7 @@ import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { augmentFakeVerdictOutput, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
+import { filterLlmTranscript } from "./stall.js";
 const MAX_RETRY_GUIDANCE_LINES = 10;
 function guidanceParts(text) {
     return text.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((s) => s.trim()).filter(Boolean);
@@ -56,6 +57,8 @@ export function augmentRetryBrief(feedback, opts) {
     return parts.join("\n\n");
 }
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
+// v1.65 T2: transcript noise (spinner repaints, CR churn, pass-run spam) is squashed at build time —
+// the filtered form is what persists to the consults/ artifact AND what the model reads; fail-open.
 export function buildDossierPrompt(d, nonce) {
     return `TICKMARKR-CONSULT
 You are a senior engineering consult for the tickmarkr orchestrator. A worker task hit trouble.
@@ -70,7 +73,7 @@ ${d.gates.map((g) => `- [${g.pass ? "pass" : "FAIL"}] ${g.gate}: ${g.details}`).
 ${d.diff || "(none)"}
 
 ## Worker transcript (tail)
-${d.transcript || "(none)"}
+${filterLlmTranscript(d.transcript) || "(none)"}
 
 ## Journal (recent events)
 ${d.journalTail}

package/dist/run/daemon.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { stringify } from "yaml";
-import { trailerPattern, writePrompt } from "../adapters/prompt.js";
+import { classifyDeadChannel, trailerPattern, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
@@ -859,6 +859,40 @@ export async function runDaemon(repoRoot, opts = {}) {
                     await park(t, "quota exhausted on every eligible channel", "quota", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
                     return;
                 }
+                // v1.65 T1: typed dead-channel failure — the parse boundary classified this no-trailer result
+                // as auth-required / setup-required / provider-outage / timeout (classifyDeadChannel; the
+                // daemon consumes the type, never re-derives it from raw text). Same free failover as quota —
+                // no escalation-ladder step — plus run-wide exclusion via demotedChannels: unlike a quota
+                // window that may reset, a dead channel stays dead for this run (OBS-57 class). Strictly
+                // AFTER the quota check so quota behavior stays byte-identical (a quota hit returns/continues
+                // before reaching here); provider-outage lands here only once the v1.46 same-channel requeue
+                // cap above is spent, so a transient blip still recovers in place.
+                const dead = classifyDeadChannel(result);
+                if (dead) {
+                    const from = channelKey(assignment);
+                    demotedChannels.add(from); // excluded for later attempts AND later tasks in this run
+                    const next = failover("dead-channel");
+                    journal.append("dead-channel-failover", t.id, { reason: dead, from, to: next ? channelKey(next) : null });
+                    if (next) {
+                        await driver.notify(`tickmarkr ${runId}: ${t.id} dead channel (${dead}) failover`, { tier: "attention" });
+                        // OBS-17 T2 (quota parity): the superseded slot holds a dead-end, not failure context.
+                        if (!keepForever) {
+                            const idx = keptSlots.indexOf(slot);
+                            if (idx >= 0) {
+                                keptSlots.splice(idx, 1);
+                                try {
+                                    await closeSlot(slot);
+                                }
+                                catch { /* cosmetic — reconcile is the backstop */ }
+                            }
+                        }
+                        assignment = next;
+                        tried.push(channelKey(next));
+                        continue;
+                    }
+                    await park(t, `dead channel (${dead}) and no eligible channel remains`, "reroute-exhausted", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
+                    return;
+                }
                 if (!finished) {
                     // ROUTE-18 (OBS-04): the channel burned a window without emitting a trailer (no-trailer timeout
                     // OR trailer-less crash-exit — both finished:false). durationMs:0 marks a FACT row, not a timed

package/dist/run/stall.d.ts

@@ -1,4 +1,8 @@
-/** Normalize one pane snapshot for the stall-inactivity compare (and ONLY that compare — trailer
- * parsing, harvest, waitOutput, and paging read the raw text). Two snapshots that normalize equal
- * are the same frame modulo spinner presentation; any other byte difference is worker activity. */
+/** Normalize one pane snapshot for the stall-inactivity compare (trailer parsing, harvest,
+ * waitOutput, and paging read the raw text; the LLM transcript filter below reuses this to
+ * CLASSIFY presentation-only lines, never to rewrite kept bytes). Two snapshots that normalize
+ * equal are the same frame modulo spinner presentation; any other byte difference is activity. */
 export declare function normalizeStallSnapshot(text: string): string;
+/** Filter transcript text bound for an LLM prompt (consult dossiers, gate prompts). The classify
+ * seam exists for fault injection in tests only — production callers pass text alone. */
+export declare function filterLlmTranscript(text: string, classify?: (t: string) => string): string;

package/dist/run/stall.js

@@ -16,9 +16,77 @@ const SPINNER_RE = /[⠀-⣿]/g;
 // A digit run (optionally decimal) bound directly to a time-unit suffix, standing alone as a
 // word: 9s, 41s, 3m, 1h, 800ms. Never bare digits — "(6/7)" and "5 of 7" stay change-sensitive.
 const ELAPSED_RE = /(?<![\w.])\d+(?:\.\d+)?(?:ms|[hms])(?!\w)/g;
-/** Normalize one pane snapshot for the stall-inactivity compare (and ONLY that compare — trailer
- * parsing, harvest, waitOutput, and paging read the raw text). Two snapshots that normalize equal
- * are the same frame modulo spinner presentation; any other byte difference is worker activity. */
+/** Normalize one pane snapshot for the stall-inactivity compare (trailer parsing, harvest,
+ * waitOutput, and paging read the raw text; the LLM transcript filter below reuses this to
+ * CLASSIFY presentation-only lines, never to rewrite kept bytes). Two snapshots that normalize
+ * equal are the same frame modulo spinner presentation; any other byte difference is activity. */
 export function normalizeStallSnapshot(text) {
     return text.replace(ANSI_RE, "").replace(SPINNER_RE, "").replace(ELAPSED_RE, "");
 }
+// ─── v1.65 T2: LLM-bound transcript filter ──────────────────────────────────────────────────────
+// Consult dossiers and gate prompts pay tokens per transcript byte, so LLM-bound text runs through
+// a per-line classifier: carriage-return overwrite churn keeps only the final paint, lines that are
+// pure presentation (spinner/ANSI/elapsed only — classified via normalizeStallSnapshot above, never
+// a parallel normalizer) drop, consecutive repaint frames that normalize equal squash to the last,
+// and runs of passing-test lines collapse to a count line. Failure lines, exit codes, and summary
+// lines always survive verbatim. Fail-open by contract: any internal error — or trivial savings —
+// returns the original text; the filter may only ever cost noise, never evidence.
+// Signal that must never drop: failure markers, exit codes, run summaries. Substring matches on
+// purpose (AssertionError, FAILED) — over-keeping is the safe miss, same asymmetry as the allowlist.
+const KEEP_RE = /[✗✖]|fail|error|exception|fatal|panic|exit\s*code|exit(?:ed)?\s+with|non-?zero|traceback|^\s*(?:tests?\b|test\s+(?:files|suites)|suites?\b|snapshots?\b|duration\b|summary\b)/i;
+// Passing-test line shapes (vitest/jest/tap/go/pytest). Only KEEP-negative lines reach this class.
+const PASS_RE = /^\s*(?:[✓✔√]\s|ok\s+\d|PASS\b|---\s*PASS:)|\bPASSED\b/;
+const COLLAPSE_MIN = 3; // a 1–2 line run costs less than the count line that would replace it
+const MIN_SAVINGS_RATIO = 0.1; // below 10% shrink the rewrite is not worth its risk — pass through
+function classifyTranscript(text) {
+    const out = [];
+    let run = [];
+    let prevNorm = null;
+    const flush = () => {
+        if (run.length >= COLLAPSE_MIN)
+            out.push(`[${run.length} passing-test lines collapsed]`);
+        else
+            out.push(...run);
+        run = [];
+    };
+    for (const raw of text.split("\n")) {
+        // CR overwrite churn: the final paint wins; earlier paints carrying must-keep signal survive too.
+        const segs = raw.split("\r");
+        for (const line of segs.filter((s, i) => i === segs.length - 1 || KEEP_RE.test(s))) {
+            if (KEEP_RE.test(line)) {
+                flush();
+                out.push(line);
+                prevNorm = null;
+                continue;
+            }
+            if (PASS_RE.test(line)) {
+                run.push(line);
+                prevNorm = null;
+                continue;
+            }
+            flush();
+            const norm = normalizeStallSnapshot(line);
+            if (line.trim() !== "" && norm.trim() === "")
+                continue; // pure spinner/ANSI/elapsed frame
+            if (norm !== "" && norm === prevNorm) {
+                out[out.length - 1] = line;
+                continue;
+            } // repaint of the prior line — latest wins
+            out.push(line);
+            prevNorm = norm;
+        }
+    }
+    flush();
+    return out.join("\n");
+}
+/** Filter transcript text bound for an LLM prompt (consult dossiers, gate prompts). The classify
+ * seam exists for fault injection in tests only — production callers pass text alone. */
+export function filterLlmTranscript(text, classify = classifyTranscript) {
+    try {
+        const filtered = classify(text);
+        return text.length - filtered.length < text.length * MIN_SAVINGS_RATIO ? text : filtered;
+    }
+    catch {
+        return text; // fail open — a filter defect must never cost the consult its evidence
+    }
+}