tickmarkr 1.46.0 → 1.48.0

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 {};

package/dist/config/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parse } from "yaml";
+import { parse, stringify } from "yaml";
 import { z } from "zod";
 import { stateDirName } from "../graph/graph.js";
 import { SHAPES, TIERS } from "../graph/schema.js";
@@ -20,6 +20,8 @@ export const TierEntrySchema = z.object({
     vendor: z.string(),
     channel: z.enum(["sub", "api"]),
     models: z.record(z.string(), TierEnum),
+    // v1.47 T3: optional per-model context-window sizes (tokens). Absent block ⇒ no doctor column, no plan lint.
+    windows: z.record(z.string(), z.number().int().positive()).optional(),
 });
 // v1.10 FLEET-06: optional routing.allow/deny fleet preference; absent blocks ⇒ byte-identical routing/discovery.
 // deny wins on conflict; presence of allow (even {} / empty arrays) activates allowlist (fail-closed).
@@ -87,6 +89,15 @@ export const TickmarkrConfigSchema = z.object({
             halfLifeRuns: z.number().positive().optional(),
             availWeight: z.number().nonnegative().optional(),
         }).optional(),
+        // E3 (v1.45-T3): optional exploration fence — absent block ⇒ byte-identical to pre-v1.45 routing.
+        explore: z.object({
+            mode: z.enum(["on", "off"]).optional(),
+            excludeShapes: z.array(z.string()).optional(),
+            excludeComplexityAtOrAbove: z.number().int().min(1).max(10).nullable().optional(),
+            cap: z.number().int().positive().optional(),
+        }).optional(),
+        // v1.47 T4: per-shape time SLA in minutes — advisory plan lint only; absent ⇒ byte-identical routing.
+        sla: z.record(z.string(), z.number().positive()).optional(),
         // Pre-v1.21 doctor.json lacks per-model verdicts. Keep legacy unknown-is-routable behavior opt-in.
         allowUnverifiedModels: z.boolean(),
         allow: PrefBlockSchema.optional(),
@@ -233,6 +244,18 @@ export const DEFAULT_CONFIG = {
             vendor: "xai", channel: "sub",
             models: { "grok-4.5": "mid", "grok-composer-2.5-fast": "cheap" },
         },
+        // Native kimi CLI (Phase 48). kimi-code/k3 → frontier: 81.2 FrontierSWE, 88.3 Terminal-Bench 2.1,
+        // top-3 across six coding benchmarks (research 2026-07-17, K3 released 2026-07-16).
+        // kimi-code/kimi-for-coding → mid (K2.7 Coding, 262k ctx). kimi-code/kimi-for-coding-highspeed →
+        // cheap (fast K2.7 variant). Ids live-verified `kimi provider list --json` 2026-07-17, kimi 0.27.0.
+        kimi: {
+            vendor: "moonshot", channel: "sub",
+            models: {
+                "kimi-code/k3": "frontier",
+                "kimi-code/kimi-for-coding": "mid",
+                "kimi-code/kimi-for-coding-highspeed": "cheap",
+            },
+        },
     },
     pricing: { cheap: 0.1, mid: 0.5, frontier: 2.5 },
     gates: { diffCap: DEFAULT_DIFF_CAP },
@@ -305,6 +328,8 @@ export function configTemplate(overlay) {
 #     migration: frontier
 #   learned: on            # default ON (ROUTE-14); cold profile = exact v1.5 static routing, warms per workspace. Set 'off' to pin static routing; preview with 'tickmarkr plan'
 #   learnedTuning: { halfLifeRuns: 5, availWeight: 0.05 }  # optional; defaults byte-identical
+#   explore: { mode: on, excludeShapes: [], excludeComplexityAtOrAbove: null, cap: 5 }  # optional; absent ⇒ byte-identical
+#   sla: { implement: 15 }  # optional per-shape minutes — advisory plan lint only; absent ⇒ no lint
 #   allow: { adapters: [claude-code, codex] }   # optional fleet allowlist; presence activates even if empty (fail-closed)
 #   deny: { models: [codex:gpt-5.5] }           # optional fleet denylist; deny beats allow on conflict
 #   # entry grammar: adapter id | model id | adapter:model (entries in either list accept all three forms)
@@ -365,3 +390,277 @@ export function configTemplate(overlay) {
     const nl = base.indexOf("\n");
     return `${base.slice(0, nl + 1)}${lines.join("\n")}\n${base.slice(nl + 1)}`;
 }
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
+export function repoOverlayPath(repoRoot) {
+    return join(repoRoot, stateDirName(repoRoot), "config.yaml");
+}
+export function readOverlayFile(path) {
+    const raw = readYaml(path);
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== "object" || Array.isArray(raw))
+        throw new ConfigError(`invalid overlay at ${path}`);
+    return raw;
+}
+export function fleetEditableFromConfig(cfg) {
+    const tiers = {};
+    for (const [adapter, entry] of Object.entries(cfg.tiers)) {
+        tiers[adapter] = {};
+        for (const [model, tier] of Object.entries(entry.models))
+            tiers[adapter][model] = { tier };
+    }
+    return {
+        denyAdapters: [...(cfg.routing.deny?.adapters ?? [])].sort(),
+        denyModels: [...(cfg.routing.deny?.models ?? [])].sort(),
+        tiers,
+        map: structuredClone(cfg.routing.map),
+        floors: { ...cfg.routing.floors },
+    };
+}
+function fleetSubset(obj) {
+    const out = {};
+    for (const k of FLEET_OVERLAY_KEYS) {
+        if (obj[k] !== undefined)
+            out[k] = obj[k];
+    }
+    return out;
+}
+/** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
+export function fleetKeyLayer(repoRoot, dotted, opts = {}) {
+    const gdir = opts.globalDir ?? globalConfigDir();
+    const globalRaw = readOverlayFile(join(gdir, "config.yaml"));
+    const repoRaw = readOverlayFile(repoOverlayPath(repoRoot));
+    const parts = dotted.split(".");
+    const at = (layer) => {
+        let cur = layer;
+        for (const p of parts) {
+            if (cur === undefined || cur === null || typeof cur !== "object" || Array.isArray(cur))
+                return undefined;
+            cur = cur[p];
+        }
+        return cur;
+    };
+    if (at(repoRaw) !== undefined)
+        return "repo";
+    if (at(globalRaw) !== undefined)
+        return "global";
+    return "defaults";
+}
+/** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
+export function formatFleetPrint(repoRoot, opts = {}) {
+    const gdir = opts.globalDir ?? globalConfigDir();
+    const effective = loadConfig(repoRoot, { globalDir: gdir });
+    const editable = fleetEditableFromConfig(effective);
+    const lines = ["# tickmarkr fleet — effective state (repo > global > defaults)"];
+    const annotate = (dotted, yaml) => `${yaml}  # ${fleetKeyLayer(repoRoot, dotted, opts)}`;
+    const denyAdapters = editable.denyAdapters;
+    const denyModels = editable.denyModels;
+    if (denyAdapters.length || denyModels.length) {
+        lines.push("routing:");
+        lines.push("  deny:");
+        if (denyAdapters.length)
+            lines.push(annotate("routing.deny.adapters", `    adapters: ${stringify(denyAdapters).trim()}`));
+        if (denyModels.length)
+            lines.push(annotate("routing.deny.models", `    models: ${stringify(denyModels).trim()}`));
+    }
+    const mapKeys = Object.keys(editable.map).sort();
+    if (mapKeys.length) {
+        if (!lines.some((l) => l === "routing:"))
+            lines.push("routing:");
+        lines.push("  map:");
+        for (const shape of mapKeys) {
+            const entry = editable.map[shape];
+            const body = stringify(entry, { indent: 4 }).trim().split("\n").map((l) => `    ${l}`).join("\n");
+            lines.push(annotate(`routing.map.${shape}`, `    ${shape}:`));
+            lines.push(body.split("\n").slice(1).join("\n"));
+        }
+    }
+    const floorKeys = Object.keys(editable.floors).sort();
+    if (floorKeys.length) {
+        if (!lines.some((l) => l === "routing:"))
+            lines.push("routing:");
+        lines.push(annotate("routing.floors", `  floors: ${stringify(Object.fromEntries(floorKeys.map((k) => [k, editable.floors[k]]))).trim().replace(/^/gm, "  ")}`));
+    }
+    const tierAdapters = Object.keys(editable.tiers).sort();
+    if (tierAdapters.length) {
+        lines.push("tiers:");
+        for (const adapter of tierAdapters) {
+            const models = editable.tiers[adapter];
+            const modelIds = Object.keys(models).sort();
+            if (!modelIds.length)
+                continue;
+            lines.push(`  ${adapter}:`);
+            lines.push("    models:");
+            for (const model of modelIds) {
+                const v = models[model];
+                if (v === null)
+                    lines.push(`      ${model}: null`);
+                else
+                    lines.push(annotate(`tiers.${adapter}.models.${model}`, `      ${model}: ${v.tier}`));
+            }
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function sortedUnique(xs) {
+    return [...new Set(xs)].sort();
+}
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}) {
+    if (fleetEditableEquals(initial, edited))
+        return {};
+    const out = structuredClone(existingRepo);
+    const routing = { ...out.routing };
+    let routingTouched = false;
+    const denyChanged = sortedUnique(initial.denyAdapters).join() !== sortedUnique(edited.denyAdapters).join()
+        || sortedUnique(initial.denyModels).join() !== sortedUnique(edited.denyModels).join();
+    if (denyChanged) {
+        routing.deny = {
+            adapters: edited.denyAdapters.length ? edited.denyAdapters : null,
+            models: edited.denyModels.length ? edited.denyModels : null,
+        };
+        routingTouched = true;
+    }
+    const mapDelta = {};
+    for (const shape of new Set([...Object.keys(initial.map), ...Object.keys(edited.map)])) {
+        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape]))
+            mapDelta[shape] = edited.map[shape];
+    }
+    if (Object.keys(mapDelta).length) {
+        routing.map = { ...routing.map, ...mapDelta };
+        routingTouched = true;
+    }
+    const floorDelta = {};
+    for (const shape of new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)])) {
+        if (initial.floors[shape] !== edited.floors[shape])
+            floorDelta[shape] = edited.floors[shape];
+    }
+    if (Object.keys(floorDelta).length) {
+        routing.floors = { ...routing.floors, ...floorDelta };
+        routingTouched = true;
+    }
+    if (routingTouched)
+        out.routing = routing;
+    const tiersOut = {
+        ...out.tiers,
+    };
+    let tiersTouched = false;
+    const adapters = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
+    for (const adapter of adapters) {
+        const models = new Set([
+            ...Object.keys(initial.tiers[adapter] ?? {}),
+            ...Object.keys(edited.tiers[adapter] ?? {}),
+        ]);
+        const modelDelta = {};
+        for (const model of models) {
+            const a = initial.tiers[adapter]?.[model];
+            const b = edited.tiers[adapter]?.[model];
+            if (JSON.stringify(a) !== JSON.stringify(b)) {
+                modelDelta[model] = b === null || b === undefined ? null : b.tier;
+            }
+        }
+        if (Object.keys(modelDelta).length) {
+            tiersOut[adapter] = { models: { ...tiersOut[adapter]?.models, ...modelDelta } };
+            tiersTouched = true;
+        }
+    }
+    if (tiersTouched)
+        out.tiers = tiersOut;
+    return out;
+}
+export function repoOverlayYaml(overlay, provenance = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const fleet = fleetSubset(overlay);
+    const fleetBody = serializeFleetOverlay(fleet, provenance);
+    const rest = { ...overlay };
+    for (const k of FLEET_OVERLAY_KEYS)
+        delete rest[k];
+    if (!Object.keys(rest).length)
+        return fleetBody;
+    const head = stringify(rest).trimEnd();
+    return fleetBody ? `${head}\n${fleetBody}` : `${head}\n`;
+}
+export function serializeFleetOverlay(overlay, provenance = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const lines = [];
+    const today = new Date().toISOString().slice(0, 10);
+    const routing = overlay.routing;
+    if (routing) {
+        lines.push("routing:");
+        const deny = routing.deny;
+        if (deny) {
+            lines.push("  deny:");
+            if (deny.adapters)
+                lines.push(`    adapters: ${stringify(deny.adapters).trim()}`);
+            if (deny.models)
+                lines.push(`    models: ${stringify(deny.models).trim()}`);
+        }
+        if (routing.map) {
+            lines.push("  map:");
+            for (const [shape, entry] of Object.entries(routing.map)) {
+                lines.push(`    ${shape}:`);
+                const body = stringify(entry, { indent: 2 }).trim().split("\n");
+                lines.push(...body.map((l) => `      ${l}`));
+            }
+        }
+        if (routing.floors)
+            lines.push(`  floors: ${stringify(routing.floors).trim().replace(/^/gm, "  ")}`);
+    }
+    const tiers = overlay.tiers;
+    if (tiers) {
+        lines.push("tiers:");
+        for (const [adapter, entry] of Object.entries(tiers)) {
+            lines.push(`  ${adapter}:`);
+            if (entry.vendor)
+                lines.push(`    vendor: ${entry.vendor}`);
+            if (entry.channel)
+                lines.push(`    channel: ${entry.channel}`);
+            lines.push("    models:");
+            for (const [model, tier] of Object.entries(entry.models ?? {})) {
+                if (tier === null)
+                    lines.push(`      ${model}: null`);
+                else {
+                    const note = provenance[adapter]?.[model];
+                    const suffix = note ? `  # ${note} — fleet ${today}` : "";
+                    lines.push(`      ${model}: ${tier}${suffix}`);
+                }
+            }
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function unifiedYamlDiff(before, after, label = "config overlay") {
+    const a = before.split("\n");
+    const b = after.split("\n");
+    if (before === after)
+        return "";
+    const header = [`--- ${label} (current)`, `+++ ${label} (proposed)`];
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        const startI = i;
+        const startJ = j;
+        while (i < a.length && (j >= b.length || a[i] !== b[j]))
+            i++;
+        while (j < b.length && (i >= a.length || a[i] !== b[j]))
+            j++;
+        hunks.push("@@");
+        for (let k = startI; k < i; k++)
+            hunks.push(`-${a[k]}`);
+        for (let k = startJ; k < j; k++)
+            hunks.push(`+${b[k]}`);
+    }
+    return `${header.join("\n")}\n${hunks.join("\n")}\n`;
+}
+export function fleetEditableEquals(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/dist/gates/acceptance.js

@@ -61,14 +61,19 @@ const isTest = (a) => typeof a === "object" && a.oracle === "test";
 const isJudge = (a) => typeof a === "string" || (typeof a === "object" && a.oracle === "judge");
 // npm/yarn/pnpm/npx script wrappers need `--` to forward -t to the underlying vitest/jest runner; a bare
 // runner (vitest/jest) takes -t directly. -t is the shared testNamePattern shorthand both honor.
+// OBS-62: vitest -t treats the name as a regex — escape metachars so a verbatim-titled test matches.
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 // OBS-55: when the base command already contains `--`, append -t after forwarded args — a second `--`
 // makes vitest treat -t as a positional file filter and the name filter is dropped.
 export function testFiltered(testCmd, name) {
+    const pattern = escapeRegExp(name);
     const wrapped = /^\s*(npm|yarn|pnpm|npx)\b/.test(testCmd);
     if (wrapped && /\s--\s/.test(testCmd))
-        return `${testCmd} -t ${shq(name)}`;
+        return `${testCmd} -t ${shq(pattern)}`;
     const fwd = wrapped ? "-- " : "";
-    return `${testCmd} ${fwd}-t ${shq(name)}`;
+    return `${testCmd} ${fwd}-t ${shq(pattern)}`;
 }
 // vitest/jest summary: "Tests  N passed | M skipped (T)" — count passed+failed as actually ran.
 function testsRan(output) {

package/dist/gates/scope.d.ts

@@ -1,8 +1,9 @@
 import type { WorkerResult } from "../adapters/types.js";
 import type { GateResult } from "./types.js";
+export declare function scopeDiffBase(worktree: string, integrationTip: string): Promise<string>;
 /** Pure offender split — corpus-replay oracle exercises this exact decision logic. */
 export declare function dispositionOffenders(offenders: string[], allowDeviations: string[]): {
     hard: string[];
     allowed: string[];
 };
-export declare function scopeGate(worktree: string, baseRef: string, files: string[], result: WorkerResult, allowDeviations?: string[]): Promise<GateResult>;
+export declare function scopeGate(worktree: string, integrationTip: string, files: string[], result: WorkerResult, allowDeviations?: string[]): Promise<GateResult>;

package/dist/gates/scope.js

@@ -1,5 +1,14 @@
 import picomatch from "picomatch";
 import { shGitOk } from "../run/git.js";
+// OBS-61: the live integration tip can advance between attempts (sibling merge) while a resumed
+// worktree stays parented on the old base — merge-base(tip, HEAD) pins the diff to the worktree's
+// creation ancestor so sibling edits cannot leak into scope as false out-of-scope offenders.
+export async function scopeDiffBase(worktree, integrationTip) {
+    const head = (await shGitOk("git rev-parse HEAD", worktree)).trim();
+    if (head === integrationTip)
+        return integrationTip;
+    return (await shGitOk(`git merge-base '${integrationTip}' '${head}'`, worktree)).trim();
+}
 /** Pure offender split — corpus-replay oracle exercises this exact decision logic. */
 export function dispositionOffenders(offenders, allowDeviations) {
     const allowedMatch = allowDeviations.length ? picomatch(allowDeviations, { dot: true }) : () => false;
@@ -13,9 +22,10 @@ export function dispositionOffenders(offenders, allowDeviations) {
     }
     return { hard, allowed };
 }
-export async function scopeGate(worktree, baseRef, files, result, allowDeviations = []) {
+export async function scopeGate(worktree, integrationTip, files, result, allowDeviations = []) {
     if (!files.length)
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
+    const baseRef = await scopeDiffBase(worktree, integrationTip);
     const changed = (await shGitOk(`git diff --name-only '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
     const inScope = picomatch(files, { dot: true }); // byte-identical options to assertWriteScope in src/compile/common.ts
     const offenders = changed.filter((f) => !inScope(f));

package/dist/route/profile.d.ts

@@ -49,7 +49,7 @@ export interface ProfileDiscount {
     reason: string;
 }
 export declare function resolveHygieneWeight(row: ProfileRow, discounts?: readonly ProfileDiscount[]): HygieneWeight;
-export declare function explorationBonus(cell: ProfileCell | undefined): number;
+export declare function explorationBonus(cell: ProfileCell | undefined, cap?: number): number;
 export declare function classify(r: ProfileRow): 1 | 0.5 | 0 | null;
 export declare function buildProfile(rows: ProfileRow[], opts?: {
     halfLifeRuns?: number;
@@ -81,7 +81,9 @@ export interface LearnedScoreTerms {
 }
 export declare function learnedScoreTerms(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
+    slaMinutes?: number;
 }): LearnedScoreTerms;
 export declare function learnedScore(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
+    slaMinutes?: number;
 }): number;