tickmarkr 1.46.0 → 1.47.0

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/cli/commands/doctor.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { allAdapters, 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";
@@ -121,6 +121,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 +139,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)

package/dist/cli/commands/run.js

@@ -4,7 +4,7 @@ import { loadConfig } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
-import { route } from "../../route/router.js";
+import { route, QUALITY_ENV, NO_EXPLORE_ENV } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
@@ -15,6 +15,8 @@ export async function run(argv, cwd = process.cwd()) {
             concurrency: { type: "string" },
             driver: { type: "string" },
             "route-strict": { type: "boolean" },
+            "no-explore": { type: "boolean" },
+            quality: { type: "boolean" },
         },
     });
     if (values.concurrency !== undefined) {
@@ -23,21 +25,36 @@ export async function run(argv, cwd = process.cwd()) {
             throw new Error(`--concurrency must be a positive integer (got ${values.concurrency})`);
     }
     const cfg = loadConfig(cwd);
-    if (values["route-strict"]) {
-        const adapters = allAdapters();
-        const health = readDoctor(cwd) ?? (await probeAll(adapters));
-        const channels = discoverChannels(cfg, adapters, health);
-        // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
-        const profile = loadRoutingProfile(cwd, cfg);
-        const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile).lints);
-        if (lints.length)
-            throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
+    const quality = !!values.quality;
+    const noExplore = !!values["no-explore"] || quality;
+    const exploreCtx = noExplore || quality ? { noExplore, quality } : undefined;
+    if (noExplore)
+        process.env[NO_EXPLORE_ENV] = "1";
+    if (quality)
+        process.env[QUALITY_ENV] = "1";
+    try {
+        if (values["route-strict"]) {
+            const adapters = allAdapters();
+            const health = readDoctor(cwd) ?? (await probeAll(adapters));
+            const channels = discoverChannels(cfg, adapters, health);
+            // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
+            const profile = loadRoutingProfile(cwd, cfg);
+            const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile, undefined, undefined, exploreCtx).lints);
+            if (lints.length)
+                throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
+        }
+        const s = await runDaemon(cwd, {
+            concurrency: values.concurrency ? Number(values.concurrency) : undefined,
+            driver: pickDriver(cfg, values.driver),
+            narrate: (event) => console.log(formatJournalNarration(event)),
+        });
+        const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+        return { out, code: summaryGreen(s) ? 0 : 2 };
+    }
+    finally {
+        if (noExplore)
+            delete process.env[NO_EXPLORE_ENV];
+        if (quality)
+            delete process.env[QUALITY_ENV];
     }
-    const s = await runDaemon(cwd, {
-        concurrency: values.concurrency ? Number(values.concurrency) : undefined,
-        driver: pickDriver(cfg, values.driver),
-        narrate: (event) => console.log(formatJournalNarration(event)),
-    });
-    const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
-    return { out, code: summaryGreen(s) ? 0 : 2 };
 }

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  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  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

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 import { approve } from "./commands/approve.js";
 import { compile } from "./commands/compile.js";
 import { doctor } from "./commands/doctor.js";
+import { fleet } from "./commands/fleet.js";
 import { init } from "./commands/init.js";
 import { plan } from "./commands/plan.js";
 import { profile } from "./commands/profile.js";
@@ -16,7 +17,7 @@ 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, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -25,6 +26,7 @@ export const USAGE = `tickmarkr — spec-driven orchestration harness for AI cod
 usage: tickmarkr <command>
   init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs
   doctor        re-probe adapters, herdr, auth; print capability matrix
+  fleet         interactive fleet editor (fleet --print for CI drift checks)
   compile <src> spec → .tickmarkr/graph.json (fails without acceptance criteria)
   scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)
   plan          dry-run routing table + cost estimate + floor lints

package/dist/compile/native.js

@@ -23,7 +23,7 @@ export function compileNative(file) {
     for (const line of content.split("\n")) {
         const heading = line.match(HEAD_RE);
         if (heading) {
-            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptance: [], gates: [], hasGates: false, list: null });
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptance: [], gates: [], hasGates: false, list: null, goalContinuation: false });
             continue;
         }
         const draft = drafts.at(-1);
@@ -41,15 +41,30 @@ export function compileNative(file) {
                 draft.list = name;
                 if (name === "gates")
                     draft.hasGates = true;
+                draft.goalContinuation = false;
             }
             else {
                 if (name === "goal" && !value)
                     invalid(draft.id, field[1], "must not be empty");
                 draft.fields[name] = value;
+                // OBS-60: carry every indented continuation line after `- goal:` into the compiled goal.
+                draft.goalContinuation = name === "goal";
                 draft.list = null;
             }
             continue;
         }
+        // OBS-60: multiline goals — indented prose after `- goal:` is appended until the next field.
+        if (draft.goalContinuation) {
+            if ((line.startsWith(" ") || line.startsWith("\t")) && !NESTED_RE.test(line)) {
+                draft.fields.goal += `\n${line.trim()}`;
+                continue;
+            }
+            if (!line.trim()) {
+                draft.fields.goal += "\n";
+                continue;
+            }
+            draft.goalContinuation = false;
+        }
         const nested = line.match(NESTED_RE);
         if (nested && draft.list) {
             const value = nested[1].trim();

package/dist/config/config.d.ts

@@ -32,6 +32,7 @@ export declare const TierEntrySchema: z.ZodObject<{
         mid: "mid";
         frontier: "frontier";
     }>>;
+    windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strip>;
 export type TierEntry = z.infer<typeof TierEntrySchema>;
 export declare const ModelPricingSchema: z.ZodObject<{
@@ -85,6 +86,16 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             halfLifeRuns: z.ZodOptional<z.ZodNumber>;
             availWeight: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        explore: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+            excludeShapes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            excludeComplexityAtOrAbove: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cap: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        sla: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         allowUnverifiedModels: z.ZodBoolean;
         allow: z.ZodOptional<z.ZodObject<{
             adapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -106,6 +117,7 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             mid: "mid";
             frontier: "frontier";
         }>>;
+        windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strip>>;
     pricing: z.ZodRecord<z.ZodString, z.ZodNumber>;
     cost: z.ZodOptional<z.ZodObject<{
@@ -194,4 +206,34 @@ export type InitConfigOverlay = {
     };
 };
 export declare function configTemplate(overlay?: InitConfigOverlay): string;
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export declare const FLEET_OVERLAY_KEYS: readonly ["routing", "tiers"];
+export type FleetTierAssignment = {
+    tier: Tier;
+    provenance?: string;
+};
+export type FleetEditable = {
+    denyAdapters: string[];
+    denyModels: string[];
+    tiers: Record<string, Record<string, FleetTierAssignment | null>>;
+    map: Record<string, MapEntry>;
+    floors: Record<string, Tier>;
+};
+export declare function repoOverlayPath(repoRoot: string): string;
+export declare function readOverlayFile(path: string): Record<string, unknown>;
+export declare function fleetEditableFromConfig(cfg: TickmarkrConfig): FleetEditable;
+/** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
+export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
+    globalDir?: string;
+}): "defaults" | "global" | "repo";
+/** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
+export declare function formatFleetPrint(repoRoot: string, opts?: {
+    globalDir?: string;
+}): string;
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>): Record<string, unknown>;
+export declare function repoOverlayYaml(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
+export declare function serializeFleetOverlay(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
+export declare function unifiedYamlDiff(before: string, after: string, label?: string): string;
+export declare function fleetEditableEquals(a: FleetEditable, b: FleetEditable): boolean;
 export {};