tickmarkr 1.46.0 → 1.48.0

package/dist/adapters/kimi.d.ts

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

package/dist/adapters/kimi.js

@@ -0,0 +1,79 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { probeVersion } from "./claude-code.js";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, MODEL_ID_RE, shq } from "./types.js";
+// KIMI-03: collectUsage is DELIBERATELY ABSENT — documented won't-implement, consistent with the
+// metering-honesty invariant (adapters/types.ts). Sessions live under ~/.kimi-code/sessions/ with
+// kimi export (ZIP) + session_index.jsonl; no harness-readable per-attempt token counter was found
+// in the session store (research F-6, 2026-07-17). Consequence: kimi channels report honestly
+// `unmetered` — same class as grok (grok.ts:11-39). Revisit if kimi ships usage in the
+// `-p --output-format stream-json` envelope or a counter in the session store.
+const CREDENTIALS_PATH = join(homedir(), ".kimi-code", "credentials", "kimi-code.json");
+// KIMI-01. Auth verdict from ~/.kimi-code/credentials/kimi-code.json ONLY — flat JSON, never a
+// network call. expires_at is epoch SECONDS (not ISO like grok). Non-empty refresh_token dominates
+// an expired expires_at (device-code flow auto-refreshes). Missing/unreadable/garbage ⇒ authed:false.
+export function kimiAuthed(credentialsText, nowMs) {
+    try {
+        const j = JSON.parse(credentialsText);
+        if (typeof j.refresh_token === "string" && j.refresh_token.length > 0)
+            return true;
+        const exp = typeof j.expires_at === "number" ? j.expires_at * 1000 : Number(j.expires_at) * 1000;
+        return Number.isFinite(exp) && exp > nowMs;
+    }
+    catch {
+        return false;
+    }
+}
+// KIMI-04 listModels parse: `kimi provider list --json` models map keys. Fail-open to [].
+export function parseKimiModels(raw) {
+    try {
+        const j = JSON.parse(raw);
+        if (!j.models || typeof j.models !== "object")
+            return [];
+        return Object.keys(j.models).filter((id) => id.length > 0 && MODEL_ID_RE.test(id));
+    }
+    catch {
+        return [];
+    }
+}
+// KIMI-02 parse: kimi -p text output prefixes thinking/answer lines with `• `. Strip before trailer
+// scan so JSON.parse succeeds (research F-4 fixture). Resume line after the trailer is ignored by
+// last-valid-trailer-wins in parseWorkerResult.
+export function parseKimiResult(raw, nonce) {
+    const stripped = raw.split("\n").map((l) => l.replace(/^[\s]*[•*-]\s+/, "")).join("\n");
+    return parseWorkerResult(stripped, nonce);
+}
+export const kimi = {
+    id: "kimi",
+    vendor: "moonshot",
+    probeCwd: "neutral",
+    probe: async () => {
+        const h = probeVersion("kimi");
+        if (!h.installed)
+            return h;
+        let authed = false;
+        try {
+            authed = kimiAuthed(readFileSync(CREDENTIALS_PATH, "utf8"), Date.now());
+        }
+        catch { /* missing/unreadable ⇒ truthfully unauthed */ }
+        return authed
+            ? { ...h, note: "auth verified via ~/.kimi-code/credentials/kimi-code.json (free, no network)" }
+            : { ...h, authed: false, note: "no valid ~/.kimi-code/credentials/kimi-code.json (kimi login to fix)" };
+    },
+    channels: (cfg) => channelsFromConfig("kimi", cfg),
+    // KIMI-02 headless. -p prompt mode + -y yolo + explicit model. kimi 0.27.0 rejects -p combined
+    // with -y at parse time — tickmarkr still emits both per harness contract; interactive uses -y.
+    headlessCommand: (promptFile, model) => `kimi -p "$(cat ${shq(promptFile)})" -y --model ${shq(model)} --output-format text`,
+    interactiveCommand: (promptFile, model) => `kimi -y --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseKimiResult,
+    listModels: async () => {
+        const r = spawnSync("kimi", ["provider", "list", "--json"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parseKimiModels(r.stdout || "");
+    },
+};

package/dist/adapters/model-lints.d.ts

@@ -1,8 +1,21 @@
 import { type TickmarkrConfig } from "../config/config.js";
+import type { Task } from "../graph/schema.js";
 import { type AuthHealth, type WorkerAdapter } from "./types.js";
 export declare const SEED_STAMPED = "2026-07-09";
 export declare const MODEL_STALE_DAYS = 30;
 export declare const ttyVisual: () => boolean;
+/** True when any tier entry declares at least one model window. */
+export declare function hasWindowsConfig(cfg: TickmarkrConfig): boolean;
+export declare function declaredModelWindow(cfg: TickmarkrConfig, adapter: string, model: string): number | undefined;
+/** Best-effort plan-time payload estimate: prompt shell + context + files[] byte sizes. */
+export declare function estimateTaskPayloadTokens(task: Task, repoRoot: string, feedback?: string): number;
+export type RoutedAssignment = {
+    taskId: string;
+    adapter: string;
+    model: string;
+};
+/** Advisory only — absent windows config or undeclared model window ⇒ no lint. */
+export declare function contextWindowLints(tasks: ReadonlyArray<Task>, assignments: ReadonlyArray<RoutedAssignment>, cfg: TickmarkrConfig, repoRoot: string): string[];
 export declare function seedPreferLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
 export declare function modelLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;
@@ -15,3 +28,9 @@ export declare function formatModelAuthLine(excluded: {
     probedAt: string;
 }[], tty?: boolean, stateDir?: string): string;
 export declare function suggestOverlay(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], stateDir?: string): string;
+/** Unclassified models surfaced for fleet screen 2 (doctor matrix math, no tier fabrication). */
+export declare function fleetUnclassifiedModels(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): {
+    adapter: string;
+    model: string;
+    detectedAt?: string;
+}[];

package/dist/adapters/model-lints.js

@@ -1,6 +1,8 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { DEFAULT_CONFIG, TIER_RANK } from "../config/config.js";
+import { buildTaskPrompt } from "./prompt.js";
 import { MODEL_ID_RE } from "./types.js";
-// date the tiers seeds were last live-verified (Phase 6/7 reseed) — surfaced when an adapter has no list surface.
 export const SEED_STAMPED = "2026-07-09";
 // knowledge past this age gets a "rerun tickmarkr doctor" nudge (BLOCKED_POLL_MS-style named constant).
 export const MODEL_STALE_DAYS = 30;
@@ -14,6 +16,57 @@ const TTY_LINT_CAP = 3;
 const DEFAULT_STATE_DIR = ".tickmarkr";
 const doctorJsonRef = (stateDir) => ` — see ${stateDir}/doctor.json`;
 export const ttyVisual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+// ponytail: chars/4 token heuristic — good enough for advisory plan lint; no tokenizer dep.
+const CHARS_PER_TOKEN = 4;
+/** True when any tier entry declares at least one model window. */
+export function hasWindowsConfig(cfg) {
+    return Object.values(cfg.tiers).some((t) => t.windows && Object.keys(t.windows).length > 0);
+}
+export function declaredModelWindow(cfg, adapter, model) {
+    return cfg.tiers[adapter]?.windows?.[model];
+}
+function fileBytes(repoRoot, rel) {
+    if (rel.includes("*") || rel.includes("?") || rel.includes("{"))
+        return 0; // glob — not measurable at plan time
+    try {
+        const p = join(repoRoot, rel);
+        if (!existsSync(p))
+            return 0;
+        return statSync(p).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Best-effort plan-time payload estimate: prompt shell + context + files[] byte sizes. */
+export function estimateTaskPayloadTokens(task, repoRoot, feedback = "") {
+    let bytes = buildTaskPrompt(task, feedback).length;
+    for (const p of task.context)
+        bytes += fileBytes(repoRoot, p);
+    for (const p of task.files)
+        bytes += fileBytes(repoRoot, p);
+    return Math.ceil(bytes / CHARS_PER_TOKEN);
+}
+/** Advisory only — absent windows config or undeclared model window ⇒ no lint. */
+export function contextWindowLints(tasks, assignments, cfg, repoRoot) {
+    if (!hasWindowsConfig(cfg))
+        return [];
+    const byId = new Map(assignments.map((a) => [a.taskId, a]));
+    const lints = [];
+    for (const t of tasks) {
+        const a = byId.get(t.id);
+        if (!a)
+            continue;
+        const window = declaredModelWindow(cfg, a.adapter, a.model);
+        if (window === undefined)
+            continue;
+        const est = estimateTaskPayloadTokens(t, repoRoot);
+        if (est > window) {
+            lints.push(`${t.id}: payload ~${est} tokens exceeds ${a.adapter}:${a.model} window ${window}`);
+        }
+    }
+    return lints;
+}
 const adapterHasAuthedChannel = (adapterId, shape, cfg, health, adapters) => {
     const entry = cfg.routing.map[shape];
     const minTier = entry?.tier ?? cfg.routing.floors[shape] ?? "cheap";
@@ -175,3 +228,23 @@ function referenceWarning(cfg, adapterId, model) {
         refs.push("consult");
     return refs.length ? `  # WARNING: still referenced by ${refs.join(", ")} — remap before removing` : "";
 }
+/** Unclassified models surfaced for fleet screen 2 (doctor matrix math, no tier fabrication). */
+export function fleetUnclassifiedModels(cfg, health, adapters) {
+    const out = [];
+    for (const id of Object.keys(cfg.tiers)) {
+        if (!adapters.some((a) => a.id === id))
+            continue;
+        const h = health[id];
+        const detected = h?.models ?? [];
+        if (!detected.length)
+            continue;
+        const configured = new Set(Object.keys(cfg.tiers[id].models));
+        const date = h?.modelsDetectedAt?.split("T")[0];
+        for (const model of detected) {
+            if (configured.has(model) || LINT_VARIANT_RE.test(model))
+                continue;
+            out.push({ adapter: id, model, detectedAt: date });
+        }
+    }
+    return out;
+}

package/dist/adapters/registry.d.ts

@@ -1,6 +1,17 @@
 import { type TickmarkrConfig } from "../config/config.js";
 import { type RoutingProfile } from "../route/profile.js";
 import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
+export declare const CANDIDATE_CLI_CATALOG: readonly ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
+export declare const REGISTERED_ADAPTER_BINARIES: readonly ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+export type CandidateCliDetection = {
+    binary: string;
+    version: string | undefined;
+};
+export declare function probeCandidateVersion(bin: string): string | undefined;
+export declare function detectCandidateClis(opts?: {
+    pathEnv?: string;
+}): CandidateCliDetection[];
+export declare function formatCandidateCliRow({ binary, version }: CandidateCliDetection): string;
 export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
 }): WorkerAdapter[];

package/dist/adapters/registry.js

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -14,14 +15,49 @@ import { codex } from "./codex.js";
 import { cursorAgent } from "./cursor-agent.js";
 import { FakeAdapter } from "./fake.js";
 import { grok } from "./grok.js";
+import { kimi } from "./kimi.js";
 import { opencode } from "./opencode.js";
 import { pi } from "./pi.js";
 import { channelKey, modelAuthed, QUOTA_RE } from "./types.js";
+// Agent-CLI binary names with no tickmarkr adapter — doctor sweeps these advisory-only (v1.48 T1).
+export const CANDIDATE_CLI_CATALOG = ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
+// Binaries probed by registered adapters — kept beside the catalog so a test can forbid overlap.
+export const REGISTERED_ADAPTER_BINARIES = ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+function candidateOnPath(bin, pathEnv) {
+    const r = spawnSync("which", [bin], { encoding: "utf8", env: { ...process.env, PATH: pathEnv } });
+    return r.status === 0 && r.stdout.trim().length > 0;
+}
+// Fail open: a broken candidate binary never throws and never fails doctor.
+export function probeCandidateVersion(bin) {
+    try {
+        const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 10000 });
+        if (r.error || r.status !== 0)
+            return undefined;
+        return (r.stdout || r.stderr).trim().split("\n")[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function detectCandidateClis(opts = {}) {
+    const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
+    const out = [];
+    for (const bin of CANDIDATE_CLI_CATALOG) {
+        if (!candidateOnPath(bin, pathEnv))
+            continue;
+        out.push({ binary: bin, version: probeCandidateVersion(bin) });
+    }
+    return out;
+}
+export function formatCandidateCliRow({ binary, version }) {
+    const ver = version ?? "version unknown";
+    return `  ! ${binary.padEnd(14)} detected: ${ver} (no tickmarkr adapter — not routable)`;
+}
 export function allAdapters(opts = {}) {
-    // pi + grok 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 silently
-    // reassigns shapes on same-tier ties. grok is appended AFTER pi for the same reason.
-    const real = [claudeCode, codex, cursorAgent, opencode, pi, grok];
+    // 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
+    // silently reassigns shapes on same-tier ties. kimi is appended AFTER grok for the same reason.
+    const real = [claudeCode, codex, cursorAgent, opencode, pi, grok, kimi];
     const fakePath = opts.fakeScriptPath ?? process.env.TICKMARKR_FAKE_SCRIPT;
     return fakePath ? [new FakeAdapter(fakePath), ...real] : real;
 }
@@ -112,7 +148,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
         if (!h?.installed)
             return;
         // Tests inject FakeAdapter; never let an incidental default adapter spend a real token in the suite.
-        if (process.env.VITEST && [claudeCode, codex, cursorAgent, opencode, pi, grok].includes(a))
+        if (process.env.VITEST && [claudeCode, codex, cursorAgent, opencode, pi, grok, kimi].includes(a))
             return;
         const verdicts = {};
         const priorModelAuth = priorHealth?.[a.id]?.modelAuth;

package/dist/cli/commands/doctor.js

@@ -1,9 +1,9 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, detectCandidateClis, formatCandidateCliRow, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { BANNER } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
-import { modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
+import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
@@ -62,6 +62,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const state = !h.installed ? "not installed" : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
         return `  ${h.installed ? "✓" : "✗"} ${a.id.padEnd(14)} ${state}`;
     });
+    // v1.48 T1: advisory sweep for known agent CLIs with no adapter — never written to doctor.json health.
+    rows.push(...detectCandidateClis().map(formatCandidateCliRow));
     rows.push(`  ${HerdrDriver.available() ? "✓" : "✗"} herdr          ${HerdrDriver.available() ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"}`);
     // v1.22 T5: workspace-trust pre-flight — per installed adapter: trusted | seeded | action-required | n/a.
     // action-required names the exact one-time command (or dialog) the operator must run once.
@@ -121,6 +123,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // per adapter — they aren't routable, so they don't earn table rows.
     const trunc = (s, n) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
     const dateOf = (iso) => iso.slice(0, 10);
+    const showWindows = hasWindowsConfig(cfg);
     const modelStatus = adapters.flatMap((a) => {
         const h = health[a.id];
         if (!h?.installed)
@@ -138,7 +141,10 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             const d = disallowedBy({ adapter: a.id, model: m }, cfg.routing);
             const denied = d?.by === "deny" ? d.entry : "—";
             const pref = preferRanks({ adapter: a.id, model: m }, cfg).map((p) => `${p.shape}#${p.rank}`).join(",") || "—";
-            rows.push(`    ${m.padEnd(w)} ${classified[m].padEnd(8)} ${auth}  denied=${denied}  prefer=${pref}`);
+            const windowCol = showWindows
+                ? ` ${String(declaredModelWindow(cfg, a.id, m) ?? "—").padEnd(8)}`
+                : "";
+            rows.push(`    ${m.padEnd(w)} ${classified[m].padEnd(8)}${windowCol} ${auth}  denied=${denied}  prefer=${pref}`);
         }
         if (unclassified.length)
             rows.push(`    (${unclassified.length} more listed, unclassified)`);

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

@@ -0,0 +1,5 @@
+import type { WorkerAdapter } from "../../adapters/types.js";
+export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAdapter[]): Promise<string | {
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/fleet.js

@@ -0,0 +1,249 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
+import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
+import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, loadConfig, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, unifiedYamlDiff, } from "../../config/config.js";
+import { SHAPES, TIERS } from "../../graph/schema.js";
+import { route } from "../../route/router.js";
+import { loadRoutingProfile } from "../../run/journal.js";
+const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
+const isDeniedAdapter = (id, editable) => editable.denyAdapters.includes(id);
+const isDeniedModel = (adapter, model, editable) => editable.denyModels.includes(`${adapter}:${model}`);
+function previewTask(shape) {
+    return {
+        id: "fleet-preview",
+        title: "fleet preview",
+        goal: "preview",
+        shape,
+        complexity: 3,
+        acceptance: ["done"],
+        deps: [],
+        files: [],
+        context: [],
+        gates: ["build", "test", "lint", "evidence", "scope", "acceptance", "review"],
+        humanGate: false,
+        status: "pending",
+        evidence: { commits: [], artifacts: [], gateResults: [] },
+    };
+}
+function formatAge(ageMs) {
+    if (ageMs === null)
+        return "no probe data";
+    const mins = Math.floor(ageMs / 60_000);
+    if (mins < 60)
+        return `${mins}m old`;
+    return `${Math.floor(mins / 60)}h old`;
+}
+function currentRepoOverlayText(repoRoot) {
+    const p = repoOverlayPath(repoRoot);
+    return existsSync(p) ? readFileSync(p, "utf8") : "";
+}
+function provenanceMap(editable) {
+    const out = {};
+    for (const [adapter, models] of Object.entries(editable.tiers)) {
+        for (const [model, v] of Object.entries(models)) {
+            if (v?.provenance) {
+                out[adapter] ??= {};
+                out[adapter][model] = v.provenance;
+            }
+        }
+    }
+    return out;
+}
+function proposedOverlayText(initial, editable, repoRoot) {
+    const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(repoRoot)));
+    return repoOverlayYaml(merged, provenanceMap(editable));
+}
+async function ask(rl, prompt) {
+    return (await rl.question(prompt)).trim();
+}
+export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters()) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            print: { type: "boolean" },
+            "global-dir": { type: "string" },
+            fresh: { type: "boolean" },
+        },
+    });
+    const globalDir = values["global-dir"] ?? globalConfigDir();
+    const print = values.print ?? false;
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    if (print)
+        return formatFleetPrint(cwd, { globalDir });
+    if (!interactive)
+        return { out: NON_TTY_MSG, code: 1 };
+    const fresh = values.fresh ?? false;
+    const { reuse, health: cached } = initDoctorReuse(cwd, fresh);
+    if (!reuse || !cached) {
+        return {
+            out: "tickmarkr fleet: probe data missing or stale — run `tickmarkr doctor` first (fleet never re-probes; doctor is the sensor)",
+            code: 1,
+        };
+    }
+    const cfg = loadConfig(cwd, { globalDir });
+    const initial = fleetEditableFromConfig(cfg);
+    const editable = structuredClone(initial);
+    const health = cached;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        // screen 0 — sensor freshness
+        const ageLine = formatAge(doctorAgeMs(cwd));
+        let step = await ask(rl, `tickmarkr fleet — scope your fleet\n  probe data: ${ageLine} (.tickmarkr/doctor.json)\n  [Enter] use it   [r] refresh via doctor   [q] quit\n> `);
+        if (/^q$/i.test(step))
+            return "fleet: quit without writing";
+        if (/^r$/i.test(step)) {
+            return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
+        }
+        // screen 1 — adapter membership (deny adapters)
+        const installed = adapters.filter((a) => health[a.id]?.installed);
+        const adapterLines = installed.map((a, i) => {
+            const h = health[a.id];
+            const on = !isDeniedAdapter(a.id, editable);
+            const mark = on ? "x" : " ";
+            const auth = h?.authed ? "authed" : "unauthed";
+            return `  ${i + 1}. [${mark}] ${a.id}  ${h?.version ?? "installed"}  ${auth}`;
+        });
+        step = await ask(rl, `screen 1/4 — agent CLIs  [number]=toggle  [Enter]=next\n${adapterLines.join("\n")}\n> `);
+        if (/^q$/i.test(step))
+            return "fleet: quit without writing";
+        if (step && step !== "") {
+            const n = Number.parseInt(step, 10);
+            if (Number.isInteger(n) && n >= 1 && n <= installed.length) {
+                const id = installed[n - 1].id;
+                const idx = editable.denyAdapters.indexOf(id);
+                if (idx === -1)
+                    editable.denyAdapters.push(id);
+                else
+                    editable.denyAdapters.splice(idx, 1);
+                editable.denyAdapters.sort();
+            }
+        }
+        // screen 2 — models per enabled adapter
+        const enabledAdapters = installed.filter((a) => !isDeniedAdapter(a.id, editable));
+        for (const a of enabledAdapters) {
+            const classified = editable.tiers[a.id] ?? {};
+            const models = Object.keys(classified);
+            const unclassified = fleetUnclassifiedModels(cfg, health, adapters).filter((u) => u.adapter === a.id);
+            const rows = [];
+            let row = 1;
+            const indexFor = new Map();
+            for (const m of models) {
+                const tier = classified[m];
+                const denied = isDeniedModel(a.id, m, editable) ? "deny" : "allow";
+                const mark = denied === "deny" ? " " : "x";
+                rows.push(`  ${row}. [${mark}] ${m}  ${tier?.tier ?? "???"}  ${denied === "deny" ? "denied" : "allowed"}`);
+                indexFor.set(String(row), { kind: "classified", model: m });
+                row++;
+            }
+            for (const u of unclassified) {
+                rows.push(`  ${row}. ( ) ${u.model}  ???  unclassified${u.detectedAt ? ` (${u.detectedAt})` : ""}`);
+                indexFor.set(String(row), { kind: "unclassified", model: u.model });
+                row++;
+            }
+            step = await ask(rl, `screen 2/4 — models · ${a.id}  [number]=toggle deny  [t <n> <tier>]=assign tier  [Enter]=next\n${rows.join("\n")}\n> `);
+            if (/^q$/i.test(step))
+                return "fleet: quit without writing";
+            if (step.startsWith("t ")) {
+                const [, numRaw, tierRaw] = step.split(/\s+/);
+                const tier = tierRaw;
+                if (!indexFor.has(numRaw) || !TIERS.includes(tier)) {
+                    return { out: "fleet: tier assignment requires a valid model number and tier (cheap|mid|frontier)", code: 1 };
+                }
+                const target = indexFor.get(numRaw);
+                if (target.kind !== "unclassified") {
+                    return { out: "fleet: tier reassignment on classified models is not supported in v1 — edit config directly", code: 1 };
+                }
+                const note = await ask(rl, "benchmark provenance note (required): ");
+                if (!note.trim())
+                    return { out: "fleet: assigning a tier to an unclassified model requires a typed benchmark-provenance note", code: 1 };
+                editable.tiers[a.id] ??= {};
+                editable.tiers[a.id][target.model] = { tier, provenance: note.trim() };
+            }
+            else if (step && /^\d+$/.test(step)) {
+                const target = indexFor.get(step);
+                if (target?.kind === "classified") {
+                    const key = `${a.id}:${target.model}`;
+                    const idx = editable.denyModels.indexOf(key);
+                    if (idx === -1)
+                        editable.denyModels.push(key);
+                    else
+                        editable.denyModels.splice(idx, 1);
+                    editable.denyModels.sort();
+                }
+            }
+        }
+        // screen 3 — per-shape routing
+        const channels = discoverChannels(cfg, adapters, health);
+        const profile = loadRoutingProfile(cwd, cfg, { preview: true });
+        const autoPrefer = readAutoPrefer(cwd);
+        const overlayShapes = overlayPreferShapes(cwd, { globalDir });
+        for (let si = 0; si < SHAPES.length; si++) {
+            const shape = SHAPES[si];
+            const entry = editable.map[shape] ?? {};
+            let now = "";
+            try {
+                const r = route(previewTask(shape), { ...cfg, routing: { ...cfg.routing, map: editable.map, floors: editable.floors } }, channels, profile);
+                now = `${r.provenance}\n       → ${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})`;
+            }
+            catch (e) {
+                now = e.message;
+            }
+            const autoNote = autoPrefer?.[shape] && !overlayShapes.has(shape)
+                ? `\n  auto-prefer active — explicit prefer overrides it`
+                : "";
+            step = await ask(rl, `screen 3/4 — shape routing · ${shape} (${si + 1}/${SHAPES.length})\n  now: ${now}\n  [1] auto within tier  [2] pin channel  [3] edit tier  [4] edit prefer  [Enter]=keep${autoNote}\n> `);
+            if (/^q$/i.test(step))
+                return "fleet: quit without writing";
+            if (!step)
+                continue;
+            if (step === "1") {
+                const next = { ...entry };
+                delete next.pin;
+                editable.map[shape] = next;
+            }
+            else if (step === "2") {
+                const pin = await ask(rl, "pin adapter:model> ");
+                const i = pin.indexOf(":");
+                if (i < 1)
+                    return { out: "fleet: pin must be adapter:model", code: 1 };
+                editable.map[shape] = { pin: { via: pin.slice(0, i), model: pin.slice(i + 1) } };
+            }
+            else if (step === "3") {
+                const tier = await ask(rl, `tier (${TIERS.join("|")})> `);
+                if (!TIERS.includes(tier))
+                    return { out: `fleet: invalid tier ${tier}`, code: 1 };
+                const next = { ...entry, tier };
+                delete next.pin;
+                editable.map[shape] = next;
+            }
+            else if (step === "4") {
+                const pref = await ask(rl, "prefer (comma-separated adapters or adapter:model)> ");
+                const prefer = pref.split(",").map((s) => s.trim()).filter(Boolean);
+                editable.map[shape] = { ...entry, prefer };
+            }
+        }
+        // review — unified diff + confirm
+        const before = currentRepoOverlayText(cwd);
+        const after = proposedOverlayText(initial, editable, cwd);
+        if (fleetEditableEquals(initial, editable) || before === after) {
+            return "fleet: no overlay changes (empty diff)";
+        }
+        const diff = unifiedYamlDiff(before, after, repoOverlayPath(cwd));
+        process.stdout.write(`\n${diff}\n`);
+        const confirm = await ask(rl, "write overlay? [y/N] ");
+        if (!/^y(?:es)?$/i.test(confirm))
+            return "fleet: discarded overlay changes";
+        const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(cwd)));
+        const body = repoOverlayYaml(merged, provenanceMap(editable));
+        const path = repoOverlayPath(cwd);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, body);
+        return `fleet: wrote ${path}`;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/commands/plan.js

@@ -1,5 +1,5 @@
 import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, servableExclusions, servabilityLine } from "../../adapters/registry.js";
-import { formatModelAuthLine, modelLints, ttyVisual } from "../../adapters/model-lints.js";
+import { formatModelAuthLine, contextWindowLints, modelLints, ttyVisual } from "../../adapters/model-lints.js";
 import { collateralLints } from "../../compile/collateral.js";
 import { loadConfig } from "../../config/config.js";
 import { loadGraph } from "../../graph/graph.js";
@@ -71,9 +71,11 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
         lints.push("review: no cross-vendor reviewer pair in fleet — set review.required: false to waive");
     }
     let cost = 0;
+    const routed = [];
     for (const t of g.tasks) {
         try {
             const r = route(t, cfg, channels, profile);
+            routed.push({ taskId: t.id, adapter: r.assignment.adapter, model: r.assignment.model });
             for (const l of r.lints) {
                 const suf = exclusionReason(l);
                 lints.push(suf ? `${l}${suf}` : l);
@@ -104,6 +106,10 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     }
     if (lints.length)
         lines.push("", "routing lints:", ...lints.map((l) => `  ! ${l}`));
+    // v1.47 T3: advisory only — never blocks plan or --route-strict (run refuses on route().lints only)
+    const windowLints = contextWindowLints(g.tasks, routed, cfg, cwd);
+    if (windowLints.length)
+        lines.push("", "context window lints:", ...windowLints.map((l) => `  ! ${l}`));
     // OBS-12/13/14/21: advisory only — never blocks --route-strict (run refuses on routing lints only)
     const scopeLints = collateralLints(g.tasks, cwd);
     if (scopeLints.length)