tickmarkr 1.71.0 → 1.73.0

package/dist/run/daemon.js

@@ -14,11 +14,12 @@ import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
 import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
+import { GATE_NAMES } from "../graph/schema.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { runEnvironment } from "./environment.js";
-import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
-import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
+import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId, phaseForGate, recordedTaskFailureKind } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
 import { nextChannel, route } from "../route/router.js";
@@ -229,6 +230,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // GATE-08 lesson at the humanGate guard: condition on the data, not the code path). Dead-code
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
+        const satisfiedGates = opts.resume ? journal.replaySatisfiedGates() : new Map();
         const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
         if (opts.resume) {
             // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
@@ -259,7 +261,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 });
             }
             baseline = JSON.parse(readFileSync(join(journal.dir, "baseline.json"), "utf8"));
+            const replayEvents = journal.read();
             for (const [id, st] of journal.replayStatuses()) {
+                if (opts.retryFailed && st === "failed" && recordedTaskFailureKind(replayEvents, id) === "dispatch") {
+                    graph = setStatus(graph, id, "pending");
+                    resume.delete(id);
+                    continue;
+                }
                 // operator release: a graph.json edit back to "pending" beats a replayed human/failed park (locked decision 12)
                 if ((st === "human" || st === "failed") && getTask(graph, id).status === "pending")
                     continue;
@@ -268,6 +276,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             journal.append("run-resume", undefined, {
                 pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
                 ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
+                ...(opts.retryFailed ? { retryFailed: true } : {}),
             });
         }
         else {
@@ -366,7 +375,10 @@ export async function runDaemon(repoRoot, opts = {}) {
         // merges are serialized — two concurrent `git merge`s in one worktree would corrupt each other
         let mergeChain = Promise.resolve();
         const mergeSerial = (taskBranch, t, gated) => {
-            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated));
+            const next = mergeChain.then(() => {
+                journal.phaseStart(t.id, "merge");
+                return mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated);
+            });
             mergeChain = next.catch(() => undefined);
             return next;
         };
@@ -526,6 +538,114 @@ export async function runDaemon(repoRoot, opts = {}) {
                 await park(t, `consult verdict: ${v.action} — ${v.notes}`, trigger, assignment, attempts, startMs, gateFails, consults, tokens, metered, retryMode); // decompose|human
                 return false;
             };
+            // OBS-130: an operator-approved gate-fail resumes from the persisted task branch, after the exact
+            // satisfied gate. No worker dispatch and no earlier gate/judge invocation occur on this path.
+            // replaySatisfiedGates() admits only an explicit task-approved ledger event, scoped by task+gate.
+            const satisfiedGate = satisfiedGates.get(t.id);
+            if (satisfiedGate) {
+                const taskBase = await integrationHead(intWt);
+                const taskBranch = `${branch}--${t.id}`;
+                const priorWt = worktreePath(repoRoot, taskBranch);
+                if (!existsSync(priorWt)) {
+                    throw new Error(`approved gate ${satisfiedGate} cannot resume: task worktree is missing`);
+                }
+                const commitsToCarry = await commitsAheadOf(taskBase, priorWt);
+                const wt = await driver.worktree(repoRoot, taskBranch, taskBase);
+                const carriedCommits = await cherryPickCommits(wt, commitsToCarry);
+                journal.append("worktree-recreation", t.id, { attempted: commitsToCarry, carried: carriedCommits });
+                if (!linkNodeModules(repoRoot, wt, { force: true })) {
+                    await park(t, "environmental: node_modules link could not be re-asserted before gates (OBS-47)", "setup", assignment, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                    return;
+                }
+                if (await npmDependencyManifestChanged(wt, taskBase)) {
+                    const installCommand = npmDependencyInstallCommand(wt);
+                    const installed = await sh(installCommand, repoRoot, 10 * 60_000);
+                    if (installed.code !== 0) {
+                        throw new Error(`dependency install failed (exit ${installed.code}): ${installed.stderr || installed.stdout}`);
+                    }
+                }
+                const workerEvent = [...journal.read()].reverse()
+                    .find((e) => e.event === "worker-result" && e.taskId === t.id);
+                if (!workerEvent)
+                    throw new Error(`approved gate ${satisfiedGate} cannot resume: worker result is missing`);
+                const priorResult = {
+                    ok: workerEvent.data.ok === true,
+                    summary: typeof workerEvent.data.summary === "string" ? workerEvent.data.summary : "",
+                    deviations: Array.isArray(workerEvent.data.deviations)
+                        ? workerEvent.data.deviations.filter((d) => typeof d === "string")
+                        : [],
+                    raw: "",
+                };
+                const gateAuthor = rs?.lastAssignment ?? assignment;
+                const satisfiedIndex = GATE_NAMES.indexOf(satisfiedGate);
+                const remainingGates = t.gates.filter((gate) => GATE_NAMES.indexOf(gate) > satisfiedIndex);
+                const resumedTask = { ...t, gates: remainingGates };
+                gateLoop: while (true) {
+                    const gated = await gitHead(wt);
+                    journal.phaseStart(t.id, "gates");
+                    const { results } = await runGates(resumedTask, {
+                        worktree: wt, baseRef: taskBase, result: priorResult, author: gateAuthor,
+                        commands, baseline, channels, adapters, cfg,
+                        via: cfg.visibility.llm === "pane"
+                            ? {
+                                driver: trackedDriver,
+                                keep: keepLlm,
+                                onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined,
+                                nameFor: (role) => formatOwnedName({ role, taskId: t.id, attempt: 0, runId }),
+                                labelFor: (role) => `${role.toUpperCase()} ${t.id}`,
+                            }
+                            : undefined,
+                        excludeReviewers: badReviewers,
+                        onGate: async (e) => {
+                            if (e.phase === "start") {
+                                journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total });
+                                return;
+                            }
+                            const g = e.result;
+                            journal.append("gate-result", t.id, {
+                                gate: g.gate, pass: g.pass, details: g.details,
+                                ...(g.meta?.skipped === true ? { skipped: true } : {}),
+                            });
+                            if (g.gate === "review" && !g.pass && /unparseable/.test(g.details)
+                                && typeof g.meta?.reviewer === "string") {
+                                badReviewers.push(g.meta.reviewer);
+                            }
+                        },
+                    });
+                    const approvedCommits = await commitsAheadOf(taskBase, wt);
+                    graph = addEvidence(graph, t.id, { commits: approvedCommits, gateResults: results });
+                    saveGraph(repoRoot, graph);
+                    if (!results.every((g) => g.pass)) {
+                        gateFails++;
+                        await park(t, "post-approval gate failed", "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    const m = await mergeSerial(taskBranch, t, gated);
+                    if (m.tipMoved) {
+                        journal.append("tip-moved", t.id, m.tipMoved);
+                        if (tipMoves++ === 0)
+                            continue gateLoop;
+                        await park(t, "task branch tip moved twice after gating", "tip-moved", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    if (!m.ok) {
+                        journal.append("merge-conflict", t.id, { conflict: m.conflict });
+                        await park(t, `merge conflict after approved gate: ${m.conflict ?? "unknown conflict"}`, "merge-conflict", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    graph = setStatus(graph, t.id, "done");
+                    saveGraph(repoRoot, graph);
+                    journal.append("task-done", t.id, { attempts: rs?.attempts ?? 0, assignment: gateAuthor });
+                    journal.append("merge", t.id, { branch: taskBranch, commit: await integrationHead(intWt) });
+                    journal.telemetry({
+                        taskId: t.id, shape: t.shape, adapter: gateAuthor.adapter, model: gateAuthor.model,
+                        channel: gateAuthor.channel, attempts: rs?.attempts ?? 0, outcome: "done",
+                        durationMs: Date.now() - startMs, firstAttemptOk: false, gateFails, consults, retryMode,
+                    });
+                    await reconcile({ spareLiveLlm: true });
+                    return;
+                }
+            }
             // Phase 46 (RES-01): start at the replayed attempt count; a replayed count ≥ MAX_ATTEMPTS parks via
             // the existing attempt-cap check below with zero new code. Fresh path: rs is undefined ⇒ 0.
             // v1.24 OBS-18: after task-approved{release:attempt-cap}, replay zeros attempts so this loop
@@ -594,6 +714,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 graph = setStatus(graph, t.id, "running");
                 saveGraph(repoRoot, graph);
                 journal.append("task-dispatch", t.id, { assignment, attempt, provenance: dispatchProvenance(r.provenance), retryMode });
+                journal.phaseStart(t.id, "worker", { attempt, assignment });
                 const taskBase = await integrationHead(intWt); // deps are merged → visible to this task
                 const taskBranch = `${branch}--${t.id}`; // "--": a ref can't nest under the existing integration branch (locked decision 10)
                 const priorWt = worktreePath(repoRoot, taskBranch);
@@ -1044,9 +1165,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                     await park(t, "environmental: node_modules link could not be re-asserted before gates (OBS-47)", "setup", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
                     return;
                 }
+                // OBS-126: workers cannot write the provisioned node_modules target outside their sandbox.
+                // Once the link is known-good, the daemon installs only attempts whose npm manifest differs
+                // from the integration-tip baseline. Keep lock/package manifests untouched: the worker's
+                // committed files are the deliverable, while this step only provisions the gate-visible tree.
+                if (await npmDependencyManifestChanged(wt, taskBase)) {
+                    const installCommand = npmDependencyInstallCommand(wt);
+                    const installed = await sh(installCommand, repoRoot, 10 * 60_000);
+                    if (installed.code !== 0) {
+                        throw new Error(`dependency install failed (exit ${installed.code}): ${installed.stderr || installed.stdout}`);
+                    }
+                }
                 const onGate = async (e) => {
-                    if (e.phase === "start")
+                    if (e.phase === "start") {
+                        journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total });
                         return;
+                    }
                     const g = e.result;
                     // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
                     // which channel flaked, which channel retried — so `tickmarkr journal`/report can distinguish "judge
@@ -1075,6 +1209,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let commits = [];
                 gateLoop: while (true) {
                     const gated = await gitHead(wt);
+                    journal.phaseStart(t.id, "gates");
                     ({ results, commits } = await runGates(t, {
                         worktree: wt, baseRef: taskBase, result, author: assignment,
                         commands, baseline, channels, adapters, cfg,

package/dist/run/git.d.ts

@@ -12,6 +12,8 @@ export declare function sh(cmd: string, cwd: string, timeoutMs?: number): Promis
 export declare function shGit(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shOk(cmd: string, cwd: string): Promise<string>;
 export declare function shGitOk(cmd: string, cwd: string): Promise<string>;
+export declare function npmDependencyManifestChanged(cwd: string, baselineRef: string): Promise<boolean>;
+export declare function npmDependencyInstallCommand(cwd: string): string;
 export declare function gitHead(cwd: string): Promise<string>;
 export declare const sanitizeBranch: (branch: string) => string;
 export declare const WORKTREES_DIR = "worktrees.noindex";

package/dist/run/git.js

@@ -75,6 +75,61 @@ export async function shGitOk(cmd, cwd) {
         throw new Error(`command failed (${r.code}): ${cmd}\n${r.stderr || r.stdout}`);
     return r.stdout;
 }
+const NPM_DEPENDENCY_MANIFESTS = ["package.json", "package-lock.json", "npm-shrinkwrap.json"];
+// OBS-126: compare the whole attempt (committed, staged, unstaged, or newly added manifest) with
+// the task's integration-tip baseline. A committed package.json change is invisible to `git status`,
+// while an untracked manifest is invisible to `git diff`, so both views are required.
+export async function npmDependencyManifestChanged(cwd, baselineRef) {
+    const paths = NPM_DEPENDENCY_MANIFESTS.map(shq).join(" ");
+    const diff = await shGit(`git diff --quiet ${shq(baselineRef)} -- ${paths}`, cwd);
+    if (diff.code === 1)
+        return true;
+    if (diff.code !== 0) {
+        throw new Error(`dependency manifest comparison failed (${diff.code}): ${diff.stderr || diff.stdout}`);
+    }
+    const untracked = await shGit(`git ls-files --others --exclude-standard -- ${paths}`, cwd);
+    if (untracked.code !== 0) {
+        throw new Error(`dependency manifest comparison failed (${untracked.code}): ${untracked.stderr || untracked.stdout}`);
+    }
+    return untracked.stdout.trim().length > 0;
+}
+// npm reifies a worktree's node_modules symlink as a private directory, which makes a successful
+// install disappear at worktree cleanup. Build positional specs from the attempt manifest so the
+// daemon can install them at the main repo root (the provisioned link's target) without saving them
+// into that baseline manifest. `--install-links` packs file: dependencies before the attempt is removed.
+export function npmDependencyInstallCommand(cwd) {
+    const manifestPath = join(cwd, "package.json");
+    const manifest = existsSync(manifestPath)
+        ? JSON.parse(readFileSync(manifestPath, "utf8"))
+        : {};
+    const dependencyGroups = [
+        manifest.peerDependencies,
+        manifest.devDependencies,
+        manifest.dependencies,
+        manifest.optionalDependencies,
+    ];
+    const dependencies = {};
+    for (const group of dependencyGroups) {
+        if (!group || typeof group !== "object" || Array.isArray(group))
+            continue;
+        for (const [name, spec] of Object.entries(group)) {
+            if (typeof spec === "string")
+                dependencies[name] = spec;
+        }
+    }
+    const specs = Object.entries(dependencies).map(([name, rawSpec]) => {
+        let spec = rawSpec;
+        if (spec.startsWith("file:"))
+            spec = `file:${resolve(cwd, spec.slice("file:".length))}`;
+        else if (spec.startsWith("./") || spec.startsWith("../"))
+            spec = resolve(cwd, spec);
+        return shq(`${name}@${spec}`);
+    });
+    return [
+        "npm install --no-save --no-audit --no-fund --package-lock=false --install-links",
+        ...specs,
+    ].join(" ");
+}
 export async function gitHead(cwd) {
     return (await shGitOk("git rev-parse HEAD", cwd)).trim();
 }

package/dist/run/journal.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { type Assignment } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
-import { type TaskStatus } from "../graph/schema.js";
+import { type GateName, type TaskStatus } from "../graph/schema.js";
 import { type ProfileDiscount, type RoutingProfile } from "../route/profile.js";
 export interface JournalEvent {
     ts: string;
@@ -9,6 +9,8 @@ export interface JournalEvent {
     taskId?: string;
     data: Record<string, unknown>;
 }
+export type TaskPhase = "worker" | "gates" | `gate:${GateName}` | "judge" | "review" | "merge";
+export declare function phaseForGate(gate: GateName): TaskPhase;
 export declare function formatJournalNarration({ event, taskId, data }: JournalEvent): string;
 export interface ResumeState {
     attempts: number;
@@ -18,6 +20,7 @@ export interface ResumeState {
 export declare const CHANNEL_EXCLUSION_KINDS: readonly ["dead-channel"];
 export type ChannelExclusionKind = (typeof CHANNEL_EXCLUSION_KINDS)[number];
 export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
+export declare const GATE_SATISFIED_RELEASE: "gate-satisfied";
 export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh"];
@@ -143,9 +146,11 @@ export declare class Journal {
     }): string | null;
     private get journalPath();
     append(event: string, taskId?: string, data?: Record<string, unknown>): void;
+    phaseStart(taskId: string, phase: TaskPhase, data?: Record<string, unknown>): void;
     read(): JournalEvent[];
     replayStatuses(): Map<string, TaskStatus>;
     replayResumeState(): Map<string, ResumeState>;
+    replaySatisfiedGates(): Map<string, GateName>;
     replayExcludedChannels(): Set<string>;
     telemetry(row: TelemetryRow): void;
     readTelemetry(): TelemetryRow[];

package/dist/run/journal.js

@@ -3,9 +3,16 @@ import { join } from "node:path";
 import { z } from "zod";
 import { channelKey, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, tickmarkrDir } from "../graph/graph.js";
-import { TIERS } from "../graph/schema.js";
+import { GATE_NAMES, TIERS } from "../graph/schema.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { redactSecrets } from "./redact.js";
+export function phaseForGate(gate) {
+    if (gate === "acceptance")
+        return "judge";
+    if (gate === "review")
+        return "review";
+    return `gate:${gate}`;
+}
 export function formatJournalNarration({ event, taskId, data }) {
     const assignment = data.assignment;
     const direct = [data.summary, data.reason, data.error, data.step, data.action, data.lint, data.branch, data.from]
@@ -33,6 +40,9 @@ export const CHANNEL_EXCLUSION_KINDS = ["dead-channel"];
 // Approve stamps this; replayResumeState zeros the attempt counter (fresh budget) while keeping
 // tried (consult bans / burned channels). Absent on pre-v1.24 events ⇒ inert (corpus outcome-identical).
 export const ATTEMPT_CAP_RELEASE = "attempt-cap";
+// OBS-130: task-approved carries the exact failed gate the operator satisfied. The release tag keeps
+// ordinary humanGate and attempt-cap approvals byte-compatible while making this authority explicit.
+export const GATE_SATISFIED_RELEASE = "gate-satisfied";
 // Fail-closed shape for a dispatched assignment (journal.ts:75-90 posture): a malformed assignment in
 // one dispatch degrades that single task toward today's behavior — counts toward attempts, contributes
 // nothing to tried, poisons only lastAssignment — never crashes resume, never poisons other tasks.
@@ -360,6 +370,9 @@ export class Journal {
             // narration is observational; a broken sink must not affect the journal or run
         }
     }
+    phaseStart(taskId, phase, data = {}) {
+        this.append("phase-start", taskId, { ...data, phase });
+    }
     read() {
         return readJsonl(this.journalPath);
     }
@@ -461,6 +474,20 @@ export class Journal {
         }
         return m;
     }
+    // OBS-130: gate satisfaction is authority, not an inferred daemon state. Only an explicit
+    // task-approved event with the typed release marker and a known gate enters this fold. A daemon-made
+    // gate-satisfied event, a prior pass/fail result, malformed data, or another task's approval is inert.
+    replaySatisfiedGates() {
+        const satisfied = new Map();
+        for (const e of this.read()) {
+            if (e.event !== "task-approved" || !e.taskId || e.data.release !== GATE_SATISFIED_RELEASE)
+                continue;
+            if (typeof e.data.gate === "string" && GATE_NAMES.includes(e.data.gate)) {
+                satisfied.set(e.taskId, e.data.gate);
+            }
+        }
+        return satisfied;
+    }
     // v1.71 OBS-119: run-wide exclusion fold — same replay discipline as replayResumeState().
     // channel-exclusion is the typed event; dead-channel-failover.from is the pre-v1.71 compat seam.
     replayExcludedChannels() {

package/dist/tui/ink/components.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from "react";
+import { type SaveTarget } from "../save.js";
+export type FleetListRow = {
+    id: string;
+    content: ReactNode;
+};
+export declare function TextLines({ lines }: {
+    lines: string[];
+}): import("react").JSX.Element;
+export declare function ToggleMark({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;
+export declare function FleetListScreen({ title, legend, rows, cursor, details, }: {
+    title: string;
+    legend: string;
+    rows: FleetListRow[];
+    cursor: number;
+    details?: string[];
+}): import("react").JSX.Element;
+export declare function FleetReviewScreen({ title, legend, diff, }: {
+    title: string;
+    legend: string;
+    diff: string;
+}): import("react").JSX.Element;
+export type DiffConfirmationProps = {
+    target: SaveTarget;
+    targetPath: string;
+    diff: string;
+    liveRun: boolean;
+};
+export declare function DiffConfirmationScreen(props: DiffConfirmationProps): import("react").JSX.Element;
+export declare function StudioScreen({ tabs, active, lines, status, children, }: {
+    tabs: string[];
+    active: number;
+    lines: string[];
+    status?: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/tui/ink/components.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { GLYPHS } from "../../brand.js";
+import { RELOAD_GUARD_NOTICE } from "../save.js";
+function keyedLines(lines) {
+    const occurrences = new Map();
+    return lines.map((text) => {
+        const occurrence = occurrences.get(text) ?? 0;
+        occurrences.set(text, occurrence + 1);
+        return { id: `${text}:${occurrence}`, text };
+    });
+}
+export function TextLines({ lines }) {
+    return (_jsx(_Fragment, { children: keyedLines(lines).map(({ id, text }) => _jsx(Text, { children: text || " " }, id)) }));
+}
+export function ToggleMark({ active }) {
+    return active
+        ? _jsx(Text, { color: "ansi256(41)", children: GLYPHS.toggleActive })
+        : _jsx(Text, { dimColor: true, children: GLYPHS.toggleInactive });
+}
+export function FleetListScreen({ title, legend, rows, cursor, details = [], }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), _jsx(TextLines, { lines: details })] }));
+}
+export function FleetReviewScreen({ title, legend, diff, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));
+}
+export function DiffConfirmationScreen(props) {
+    return _jsx(TextLines, { lines: [
+            `Save overlay — ${props.targetPath} (${props.target === "repo" ? "repository" : "global"} target)`,
+            "t toggle target · y confirm · n/esc cancel",
+            ...(props.liveRun ? [RELOAD_GUARD_NOTICE] : []),
+            "─ diff ─",
+            props.diff || "(no overlay changes)",
+        ] });
+}
+export function StudioScreen({ tabs, active, lines, status = "no staged changes", children, }) {
+    const tabBar = [
+        "tickmarkr ui ──",
+        ...tabs.map((label, index) => `[${index + 1}]${index === active ? "*" : ""}${label}`),
+    ].join(" ");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: tabBar }), children ?? _jsx(TextLines, { lines: lines }), _jsx(Text, { dimColor: true, children: status })] }));
+}

package/dist/tui/ink/fleet-app.d.ts

@@ -0,0 +1,113 @@
+import type { AuthHealth, WorkerAdapter } from "../../adapters/types.js";
+import type { MapEntry, RoutingMode, Tier } from "../../config/config.js";
+import { type Shape } from "../../graph/schema.js";
+export type FleetSteeringKey = "review" | "consult";
+export type FleetEditorState = {
+    denyAdapters: string[];
+    denyModels: string[];
+    classifications: FleetClassification[];
+    selectedMode: RoutingMode;
+    map: Record<string, MapEntry>;
+    steering: Record<FleetSteeringKey, string[] | undefined>;
+};
+export type FleetOverlayReview = {
+    kind: "empty";
+} | {
+    kind: "diff";
+    before: string;
+    after: string;
+    diff: string;
+    path: string;
+};
+export type FleetEditorResult = {
+    kind: "write";
+    review: Extract<FleetOverlayReview, {
+        kind: "diff";
+    }>;
+} | {
+    kind: "discard";
+} | {
+    kind: "no-changes";
+} | {
+    kind: "quit";
+} | {
+    kind: "refresh";
+};
+type AgentCli = {
+    id: string;
+    version: string;
+    authed: boolean;
+};
+export type FleetModelGroup = {
+    adapter: string;
+    rows: Array<{
+        model: string;
+        tier?: Tier;
+        detectedAt?: string;
+    }>;
+};
+export type FleetClassification = {
+    adapter: string;
+    model: string;
+    tier: Tier;
+    note: string;
+};
+export type FleetModeOption = {
+    id: RoutingMode;
+    gloss: string;
+};
+export type FleetShapeRow = {
+    id: Shape;
+    label: string;
+};
+export type FleetCandidateOption = {
+    id: string;
+    label: string;
+    pin: {
+        via: string;
+        model: string;
+    };
+};
+export declare function formatDoctorAge(ageMs: number | null): string;
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, }: {
+    ageMs: number | null;
+    agents: AgentCli[];
+    initialDenyAdapters: string[];
+    initialDenyModels: string[];
+    modelGroups: FleetModelGroup[];
+    initialMode: RoutingMode;
+    modeOptions: FleetModeOption[];
+    initialMap: Record<string, MapEntry>;
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>) => FleetCandidateOption[];
+    preferOptionsForShape: (shape: Shape, current: string[]) => string[];
+    initialSteering: Record<FleetSteeringKey, string[] | undefined>;
+    steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
+    reloadGuard: (bytes: string) => string | null;
+}): import("react").JSX.Element;
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, initialInput, input, output, debug, }: {
+    ageMs: number | null;
+    adapters: WorkerAdapter[];
+    health: Record<string, AuthHealth>;
+    initialDenyAdapters: string[];
+    initialDenyModels: string[];
+    modelGroups: FleetModelGroup[];
+    initialMode: RoutingMode;
+    modeOptions: FleetModeOption[];
+    initialMap: Record<string, MapEntry>;
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>) => FleetCandidateOption[];
+    preferOptionsForShape: (shape: Shape, current: string[]) => string[];
+    initialSteering: Record<FleetSteeringKey, string[] | undefined>;
+    steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
+    reloadGuard: (bytes: string) => string | null;
+    initialInput?: string[];
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+    debug?: boolean;
+}): Promise<FleetEditorResult>;
+export {};