tickmarkr 2.6.3 → 2.6.4

package/dist/compile/native.js

@@ -58,6 +58,121 @@ export function classifyContextPath(entry, tracked, repoDir) {
     const hits = [...tracked].filter((t) => basename(t) === base);
     return hits.length === 1 ? { kind: "missing", suggestion: hits[0] } : { kind: "missing" };
 }
+// v2.6.4 T9 (E): picomatch (the files[] matcher, graph/files-glob.ts) expands a brace group only when
+// it holds a top-level comma or a `..` range, which compiles to a character class — faithful only
+// between single characters: `{A..z}` is `[A-z]`, but `{1..10}` is the class `[1-10]`. Any other
+// unescaped group stays LITERAL braces: `docs/{a}.md` scopes a file named `docs/{a}.md`, never
+// `docs/a.md` (2.6.3 T10: six scope reds). Like picomatch, a `[...]` class (opened only when a `]`
+// follows; a `]` right after `[` or `[^` is a member) swallows braces and commas: `docs/{[a,b]}.md`
+// stays literal, `docs/[{a}].md` holds no group. A POSIX `[:name:]` inside a class is replayed as
+// picomatch's parser does it (the `:]` is consumed, the class stays open), so `docs/{[[:alpha:],]}.md`
+// stays literal and `docs/[[:alpha:]{a}].md` holds no group. Outside a class, picomatch reads `"..."` as
+// quoted literal text (an escape still applies inside it), so a quoted `[`, `{` or `,` opens nothing:
+// `docs/"["/{a}].md` still holds the group `{a}`, `docs/"{a}".md` holds none. A class picomatch never
+// closes (its only `]` is a member: `docs/[]/{a}.md`) has its opener escaped at the end, and everything
+// after that opener stays literal text — no quotes, no classes, braces literal — so that tail is
+// rescanned for groups with only escapes honoured: `docs/[]/{a}.md` holds `{a}`. Returns each literal
+// group and the pattern with those braces dropped — the literal path its author almost certainly meant.
+// A range is read with picomatch's escapes: its lexer drops a backslash before `.`, `/` or `;` (the char
+// stays live, so `{1\..3}` IS the range `{1..3}`) and keeps any other `\X` as one literal character. Each
+// end must be one such character, and the matcher itself must then match both ends: `{\d..z}` compiles
+// to the class `[\d-z]`, which never matches "d".
+const RANGE_END = String.raw `(\\[\s\S]|[^\\])`;
+const RANGE = new RegExp(`^${RANGE_END}\\.\\.${RANGE_END}$`);
+function supportedRange(group) {
+    const ends = RANGE.exec(group.replace(/\\([\s\S])/g, (pair, ch) => "./;".includes(ch) ? ch : pair));
+    if (!ends)
+        return false;
+    const match = filesGlob(`{${group}}`);
+    return ends.slice(1).every((end) => match(end.slice(-1)));
+}
+const POSIX_CLASS = picomatch.constants.POSIX_REGEX_SOURCE;
+function singletonBraces(pattern) {
+    const open = [];
+    const groups = [];
+    const drop = new Set();
+    let cls; // the open character class's text as picomatch accumulates it, undefined outside one
+    let clsAt = -1; // the open class's opener
+    let quoted = false; // inside a "..." run outside any class
+    let raw = false; // past an unterminated class's opener: literal text, only escapes and braces count
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (cls !== undefined) {
+            const at = cls.lastIndexOf("[");
+            if (ch === "\\")
+                cls += pattern.slice(i, ++i + 1);
+            else if (ch === "]" && cls !== "[" && cls !== "[^")
+                cls = undefined;
+            else if (ch === ":" && at > 0 && cls.includes(":", 1) && Object.hasOwn(POSIX_CLASS, cls.slice(at + 2))) {
+                cls = cls.slice(0, at) + POSIX_CLASS[cls.slice(at + 2)];
+                i++; // picomatch consumes the char after the closing `:` (the `]` of `[:name:]`) without closing the class
+            }
+            else
+                cls += ch;
+        }
+        else if (ch === "\\")
+            i++; // escaped: `\{a\}` is a literal filename
+        else if (ch === '"' && !raw)
+            quoted = !quoted;
+        else if (quoted)
+            continue;
+        else if (ch === "[" && !raw && pattern.includes("]", i + 1))
+            [cls, clsAt] = ["[", i];
+        else if (ch === "{")
+            open.push({ at: i, comma: false });
+        else if (ch === "," && open.length)
+            open[open.length - 1].comma = true;
+        else if (ch === "}" && open.length) {
+            const { at, comma } = open.pop();
+            if (comma || supportedRange(pattern.slice(at + 1, i)))
+                continue;
+            groups.push(pattern.slice(at, i + 1));
+            drop.add(at).add(i);
+        }
+        if (cls !== undefined && i + 1 >= pattern.length)
+            [i, cls, raw] = [clsAt, undefined, true]; // unterminated: rescan its tail raw
+    }
+    return { groups, bare: pattern.split("").filter((_, i) => !drop.has(i)).join("") };
+}
+// v2.6.4 T9 (E): a files[] path the SELECTED git tree (spec base, else HEAD — what a worker's worktree
+// is built from) stores as a symlink, mode 120000, scopes the link's own bytes: its stored target
+// text. An edit made THROUGH the link writes the file it points to, which the scope gate refuses. The
+// checkout is never the oracle — its links may be untracked or replaced. Advisory only; with no
+// repository (or no files[]) there is no tree to inspect and git is never spawned.
+function symlinkScopeWarnings(file, tasks, base) {
+    const scoped = tasks.filter((task) => task.files.length > 0)
+        .map((task) => ({ id: task.id, match: filesGlob(task.files.map((entry) => entry.replace(/^\.\//, ""))) }));
+    if (!scoped.length || !repositoryRoot(file))
+        return [];
+    const tree = base ?? "HEAD";
+    const git = (...args) => spawnSync("git", ["-C", dirname(file), ...args], { encoding: "utf8", maxBuffer: 1 << 28 });
+    const failed = (r) => r.error || r.signal || r.status !== 0 || typeof r.stdout !== "string";
+    const why = (r) => r.signal ? `signal ${r.signal}` : r.status === null ? "git did not run" : `git exit ${r.status}`;
+    const advisory = (what, r) => `tickmarkr: advisory: files[] symlink inspection could not read ${what} in the selected git tree ${JSON.stringify(tree)} (${why(r)}) — symlink scope is unverified for this compile.`;
+    const ls = git("ls-tree", "--full-tree", "-r", "-z", "--end-of-options", tree); // a base is never an option
+    if (failed(ls))
+        return [advisory("the tree", ls)];
+    const warnings = [];
+    for (const row of ls.stdout.split("\0")) {
+        const link = /^120000 blob ([0-9a-f]+)\t([\s\S]+)$/.exec(row);
+        if (!link)
+            continue;
+        const owners = scoped.filter((task) => task.match(link[2]));
+        if (!owners.length)
+            continue;
+        // ponytail: one cat-file per matched link; switch to `cat-file --batch` if a scope matches hundreds
+        const target = git("cat-file", "blob", link[1]);
+        if (failed(target)) {
+            warnings.push(advisory(`the stored target of ${JSON.stringify(link[2])}`, target));
+            continue;
+        }
+        for (const { id } of owners) {
+            warnings.push(`tickmarkr: task ${id} files[] path ${JSON.stringify(link[2])} is a symlink in the selected git tree ${JSON.stringify(tree)} storing target ${JSON.stringify(target.stdout)} — `
+                + `files[] owns only that stored target text; an edit made through the link changes the file it points to, which needs its own files[] entry.`);
+        }
+    }
+    return warnings;
+}
 // OBS-97: mirror of the vitest.config.ts suite include — the only path class vitest collects.
 export const COLLECTABLE_TESTS = "tests/**/*.test.ts";
 export const LEGACY_PREFIX = ["dro", "vr"].join("");
@@ -611,6 +726,19 @@ export function compileNative(file, options = {}) {
     // A fixture pin's path set is split only — never annotation-stripped: "fixtures/output (old)" is a
     // filename, and csv() would silently retarget the declared obligation to "fixtures/output".
     const pinPaths = (value) => splitTop(value).map((item) => item.trim()).filter(Boolean);
+    // v2.6.4 T9 (E): refused BEFORE the hosting probe below, which expands every brace group — so it
+    // would certify `tests/{native}.test.ts` as a test home while the scope gate never matches it.
+    for (const draft of drafts) {
+        for (const entry of csv(draft.fields.files)) {
+            const { groups, bare } = singletonBraces(entry);
+            if (groups.length) {
+                invalid(draft.id, "files", `entry ${JSON.stringify(entry)} holds single-item brace group${groups.length === 1 ? "" : "s"} ${groups.join(", ")}: `
+                    + `the scope gate matches ${groups.length === 1 ? "it" : "them"} as literal braces while test hosting expands ${groups.length === 1 ? "it" : "them"}, `
+                    + `so the declared scope disagrees with itself. Write the bare path ${JSON.stringify(bare)}, list two or more alternatives as {a,b}, `
+                    + `or escape the braces (\\{ \\}) if they are part of the filename (a range expands only between single characters, e.g. {1..3} or {a..c}).`);
+            }
+        }
+    }
     // OBS-97: a typed test: oracle needs a collectable home. vitest only collects COLLECTABLE_TESTS
     // paths, so a task whose non-empty files[] cannot host one makes scope-green and acceptance-green
     // mutually exclusive by construction — run-20260719-210434 burned two dispatch attempts before a
@@ -744,6 +872,8 @@ export function compileNative(file, options = {}) {
         },
         tasks,
     });
+    for (const warning of symlinkScopeWarnings(file, result.tasks, specBase))
+        console.warn(warning);
     const authoringFindings = authoringLintFindings(result.tasks, file);
     const blockingCodes = new Set(["criterion-scope", "fence-symbol-absent"]);
     const blockingFindings = authoringFindings.filter((finding) => options.strict || blockingCodes.has(finding.code));

package/dist/config/config.d.ts

@@ -394,19 +394,23 @@ export type ModeResolution = {
 export declare function loadConfigWithMode(repoRoot: string, opts?: {
     globalDir?: string;
     repoOverlayText?: string;
+    userOverlayText?: string;
 }): {
     cfg: TickmarkrConfig;
     mode: ModeResolution;
 };
-/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the repo overlay resolve them. */
+/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the written overlay resolve them. */
 export type LowerLayerModelOverrides = Record<string, Record<string, Record<string, unknown>>>;
-/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the repo overlay (defaults + global)
- *  merge them. Read raw, never schema-validated: a lower layer may only validate beside repo fields
- *  (global `vendor: null` completed by a repo vendor) and its override metadata is still inherited.
+/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the written overlay merge them —
+ *  defaults + global under the repo overlay; B2 `below: "user"`: the defaults alone under the USER
+ *  overlay, which is never read as its own lower layer. Read raw, never schema-validated: a lower
+ *  layer may only validate beside upper fields (global `vendor: null` completed by a repo vendor)
+ *  and its override metadata is still inherited.
  *  OBS-1188: an unparseable global file, or a non-map where this path expects a map, is an error —
  *  never an empty lower layer, which would silently drop the metadata a write must re-mask. */
 export declare function lowerLayerModelOverrides(opts?: {
     globalDir?: string;
+    below?: "repo" | "user";
 }): {
     ok: true;
     overrides: LowerLayerModelOverrides;
@@ -417,11 +421,14 @@ export declare function lowerLayerModelOverrides(opts?: {
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
 }): TickmarkrConfig;
-/** v1.52 T2 write-time reload guard: run candidate repo-overlay bytes through the SAME production
- *  loader path every later command uses (parse → merge → schema → mode resolution). Returns null
- *  when the bytes load, else the loader's failure message — the caller must refuse the write. */
+/** v1.52 T2 write-time reload guard: run candidate overlay bytes (the repo layer, or B2's USER layer)
+ *  through the SAME production loader path every later command uses (parse → merge → schema → mode
+ *  resolution). Returns null when the bytes load, else the loader's failure message — the caller
+ *  must refuse the write. */
 export declare function overlayBytesLoadError(repoRoot: string, bytes: string, opts?: {
     globalDir?: string;
+    layer?: "repo" | "user";
+    repoOverlayText?: string;
 }): string | null;
 export type InitConfigOverlay = {
     concurrency?: number;
@@ -474,6 +481,17 @@ export declare function fleetEditableFromConfig(cfg: TickmarkrConfig, universe?:
 export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
     globalDir?: string;
 }): "defaults" | "global" | "repo";
+/** B2: the user-overlay keys a write changes that the repo overlay (merged above it) decides in this
+ *  repository — it declares the path, or a non-map (value, list, null tombstone) at a prefix that
+ *  replaces or deletes the user's subtree, or its merge otherwise moves the value (a repo pin/pool/
+ *  prefer replaces the user's whole routing.map slot atomically) — each with the value that still
+ *  applies here. Bytes the loader refuses yield none: the write guard refuses them anyway. */
+export declare function repoShadowedUserKeys(repoRoot: string, beforeUser: string, afterUser: string, opts?: {
+    globalDir?: string;
+}): Array<{
+    path: string;
+    value: unknown;
+}>;
 /** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
 export declare function formatFleetPrint(repoRoot: string, opts?: {
     globalDir?: string;

package/dist/config/config.js

@@ -545,10 +545,27 @@ export const DEFAULT_CONFIG = {
         // retired id. Installed codex 0.144.1 lists it (models_cache.json client_version 0.144.0, fetched
         // 2026-07-10) AND a live runtime probe (`codex exec --model gpt-5.6-sol` → "OK", 2026-07-10) confirmed
         // it runs. Reseeding away would be a regression — the CLI upgrade closed the gate. Seed stays.
+        // v2.6.4 T3 (B1b, D-717): gpt-6-astra / gpt-6-sol / gpt-6-luna seeded AHEAD of the retained gpt-5.x
+        // ids from the installed CLI's models_cache.json snapshot (codex 0.159.0, fetched 2026-09-29T16:09Z).
+        // Tiers are ASSUMPTIONS, not measurements — no benchmark was run or cited for any of the three:
+        // astra=frontier and luna=cheap follow the provider's own descriptions in the local cache (read
+        // 2026-09-29: "Frontier intelligence for the most demanding work" / "Fast and affordable model for
+        // easier tasks"); sol=frontier keeps the shipped workhorse-family mapping (gpt-5.6-sol above) by
+        // continuity. Learned routing or an overlay may retier on evidence. gpt-5.5 stays seeded until its
+        // CLI-announced retirement (2026-10-14T19:00:00Z → gpt-5.6-sol); gpt-5.6-sol is not retiring.
+        // Windows: the same snapshot lists context_window=272000 for all seven — the budget the CLI launches
+        // with, and the authority for these seeds. The API's published 1,050,000 is a different surface and is
+        // not contradicted. A later cache listing more ids (gpt-6.1-sol) does not widen this sealed set.
         codex: {
             vendor: "openai", channel: "sub",
-            models: { "gpt-5.6-sol": "frontier", "gpt-5.5": "frontier", "gpt-5.6-terra": "mid", "gpt-5.6-luna": "cheap" },
-            windows: { "gpt-5.6-sol": 1_050_000, "gpt-5.5": 1_050_000, "gpt-5.6-terra": 1_050_000, "gpt-5.6-luna": 1_050_000 },
+            models: {
+                "gpt-6-astra": "frontier", "gpt-6-sol": "frontier", "gpt-6-luna": "cheap",
+                "gpt-5.6-sol": "frontier", "gpt-5.5": "frontier", "gpt-5.6-terra": "mid", "gpt-5.6-luna": "cheap",
+            },
+            windows: {
+                "gpt-6-astra": 272_000, "gpt-6-sol": 272_000, "gpt-6-luna": 272_000,
+                "gpt-5.6-sol": 272_000, "gpt-5.5": 272_000, "gpt-5.6-terra": 272_000, "gpt-5.6-luna": 272_000,
+            },
         },
         // grok-4.5 (xAI, released 2026-07-08) → mid: AA Intelligence 54 (#4), Terminal-Bench 2.1 83.3%
         // (≈ GPT-5.5 83.4, Fable 5 84.3), SWE-bench Pro 64.7%, ~4.2× more token-efficient than Opus 4.8
@@ -809,7 +826,11 @@ function resolveRoutingMode(cfg, layers) {
 /** loadConfig plus the mode-resolution record (floor provenance + plan lints). The resolved floors are
  *  already applied to cfg.routing.floors — route() consumes floors only and never sees the mode. */
 export function loadConfigWithMode(repoRoot, opts = {}) {
-    const globalCfg = readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"));
+    // B2: userOverlayText substitutes candidate bytes for the on-disk USER layer — the fleet's save
+    // destination — so a preview and the write guard load exactly the bytes a save would land.
+    const globalCfg = opts.userOverlayText === undefined
+        ? readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"))
+        : parse(opts.userOverlayText);
     // v1.52 T2: repoOverlayText substitutes candidate bytes for the on-disk repo layer — the fleet
     // write guard validates EXACTLY what it is about to write through this one loader path.
     const repoCfg = opts.repoOverlayText === undefined
@@ -824,9 +845,11 @@ export function loadConfigWithMode(repoRoot, opts = {}) {
     assertSeededModelWindows();
     return { cfg: r.data, mode: resolveRoutingMode(r.data, [globalCfg, repoCfg]) };
 }
-/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the repo overlay (defaults + global)
- *  merge them. Read raw, never schema-validated: a lower layer may only validate beside repo fields
- *  (global `vendor: null` completed by a repo vendor) and its override metadata is still inherited.
+/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the written overlay merge them —
+ *  defaults + global under the repo overlay; B2 `below: "user"`: the defaults alone under the USER
+ *  overlay, which is never read as its own lower layer. Read raw, never schema-validated: a lower
+ *  layer may only validate beside upper fields (global `vendor: null` completed by a repo vendor)
+ *  and its override metadata is still inherited.
  *  OBS-1188: an unparseable global file, or a non-map where this path expects a map, is an error —
  *  never an empty lower layer, which would silently drop the metadata a write must re-mask. */
 export function lowerLayerModelOverrides(opts = {}) {
@@ -834,7 +857,7 @@ export function lowerLayerModelOverrides(opts = {}) {
     const path = join(opts.globalDir ?? globalConfigDir(), "config.yaml");
     let global;
     try {
-        global = readYaml(path);
+        global = opts.below === "user" ? undefined : readYaml(path);
     }
     catch (error) {
         return { ok: false, error: `lower config layer ${path} is malformed YAML: ${error.message.replace(/\s+/g, " ").trim()}` };
@@ -865,12 +888,17 @@ export function lowerLayerModelOverrides(opts = {}) {
 export function loadConfig(repoRoot, opts = {}) {
     return loadConfigWithMode(repoRoot, opts).cfg;
 }
-/** v1.52 T2 write-time reload guard: run candidate repo-overlay bytes through the SAME production
- *  loader path every later command uses (parse → merge → schema → mode resolution). Returns null
- *  when the bytes load, else the loader's failure message — the caller must refuse the write. */
+/** v1.52 T2 write-time reload guard: run candidate overlay bytes (the repo layer, or B2's USER layer)
+ *  through the SAME production loader path every later command uses (parse → merge → schema → mode
+ *  resolution). Returns null when the bytes load, else the loader's failure message — the caller
+ *  must refuse the write. */
 export function overlayBytesLoadError(repoRoot, bytes, opts = {}) {
     try {
-        loadConfigWithMode(repoRoot, { ...opts, repoOverlayText: bytes });
+        loadConfigWithMode(repoRoot, {
+            globalDir: opts.globalDir,
+            // B2: a user-layer check may substitute the repo layer too ("" = none: the bytes on their own)
+            ...(opts.layer === "user" ? { userOverlayText: bytes, repoOverlayText: opts.repoOverlayText } : { repoOverlayText: bytes }),
+        });
         return null;
     }
     catch (e) {
@@ -1085,6 +1113,59 @@ export function fleetKeyLayer(repoRoot, dotted, opts = {}) {
         return "global";
     return "defaults";
 }
+const isPlainMap = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** B2: every leaf path an overlay write changes — a map on either side (the other absent) is
+ *  walked, anything else (scalar, list, null tombstone) is one leaf. */
+function changedLeafPaths(before, after, path = []) {
+    if (JSON.stringify(before) === JSON.stringify(after))
+        return [];
+    const walkable = (v) => v === undefined || isPlainMap(v);
+    if (!walkable(before) || !walkable(after))
+        return [path];
+    const b = (before ?? {});
+    const a = (after ?? {});
+    return [...new Set([...Object.keys(b), ...Object.keys(a)])].flatMap((key) => changedLeafPaths(b[key], a[key], [...path, key]));
+}
+/** B2: the user-overlay keys a write changes that the repo overlay (merged above it) decides in this
+ *  repository — it declares the path, or a non-map (value, list, null tombstone) at a prefix that
+ *  replaces or deletes the user's subtree, or its merge otherwise moves the value (a repo pin/pool/
+ *  prefer replaces the user's whole routing.map slot atomically) — each with the value that still
+ *  applies here. Bytes the loader refuses yield none: the write guard refuses them anyway. */
+export function repoShadowedUserKeys(repoRoot, beforeUser, afterUser, opts = {}) {
+    let effective;
+    let paths;
+    try {
+        effective = loadConfigWithMode(repoRoot, { globalDir: opts.globalDir, userOverlayText: afterUser }).cfg;
+        paths = changedLeafPaths(parse(beforeUser) ?? undefined, parse(afterUser) ?? undefined);
+    }
+    catch {
+        return [];
+    }
+    // the same bytes without the repo layer: any changed path whose value differs here is the repo's merge
+    let alone;
+    try {
+        alone = loadConfigWithMode(repoRoot, { globalDir: opts.globalDir, userOverlayText: afterUser, repoOverlayText: "" }).cfg;
+    }
+    catch {
+        alone = undefined;
+    }
+    const at = (cfg, path) => path.reduce((cur, key) => (isPlainMap(cur) ? cur[key] : undefined), cfg);
+    const repo = readOverlayFile(repoOverlayPath(repoRoot));
+    const decides = (path) => {
+        if (alone !== undefined && JSON.stringify(at(alone, path)) !== JSON.stringify(at(effective, path)))
+            return true;
+        let cur = repo;
+        for (const key of path) {
+            if (!isPlainMap(cur))
+                return cur !== repo;
+            if (!(key in cur))
+                return false;
+            cur = cur[key];
+        }
+        return true;
+    };
+    return paths.filter(decides).map((path) => ({ path: path.join("."), value: at(effective, path) }));
+}
 /** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
 export function formatFleetPrint(repoRoot, opts = {}) {
     const gdir = opts.globalDir ?? globalConfigDir();

package/dist/route/router.d.ts

@@ -55,6 +55,17 @@ export declare const taskPool: (task: Task, cfg: TickmarkrConfig) => {
 /** Park-reason suffix naming the pool an exhausted re-dispatch stayed inside; empty when unpooled. */
 export declare const poolExhaustion: (task: Task, cfg: TickmarkrConfig) => string;
 export declare const inTaskPool: (task: Task, cfg: TickmarkrConfig, key: string) => boolean;
+/**
+ * F (D-718): the one exclusion meaning route(), nextChannel() and climbChannel() share — explicit
+ * exclusions, demotions, tried and escalation history, and climb skips — exported so resume can test a
+ * restored assignment the same way. An excluded raw channel key always excludes itself (the fallback).
+ * The exclusion extends to another offered channel only when BOTH offered channels carry a probed
+ * identity and the two are equal. A missing identity is neutral: it never matches and never blocks.
+ * Residual, by ruling: an unprobed alias of an excluded model stays eligible by its raw key — this is
+ * not complete alias exclusion; reopen on an executed re-dispatch of a tried model through an alias
+ * with no probed identity. The daemon's nextChannel-null exhaustion fallback is not this policy's.
+ */
+export declare function channelExclusion(offered: readonly BillingChannel[], excluded: Iterable<string>): (seat: ChannelSeat) => boolean;
 export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>, exploreCtx?: ExploreContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;
 export type ClimbPick = Assignment & {

package/dist/route/router.js

@@ -1,6 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
-import { channelRouteIdentity, disallowedBy, modelRouteIdentity, routingModelProvider } from "./preference.js";
+import { disallowedBy, routingModelProvider } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
 export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
 // OBS-89 (v1.60): the TICKMARKR_QUALITY variable is RETIRED — nothing in src reads it anymore and
@@ -124,11 +124,33 @@ function spreadFrontierTies(sorted, task, prefer, tied) {
     }
     return out;
 }
+/**
+ * F (D-718): the one exclusion meaning route(), nextChannel() and climbChannel() share — explicit
+ * exclusions, demotions, tried and escalation history, and climb skips — exported so resume can test a
+ * restored assignment the same way. An excluded raw channel key always excludes itself (the fallback).
+ * The exclusion extends to another offered channel only when BOTH offered channels carry a probed
+ * identity and the two are equal. A missing identity is neutral: it never matches and never blocks.
+ * Residual, by ruling: an unprobed alias of an excluded model stays eligible by its raw key — this is
+ * not complete alias exclusion; reopen on an executed re-dispatch of a tried model through an alias
+ * with no probed identity. The daemon's nextChannel-null exhaustion fallback is not this policy's.
+ */
+export function channelExclusion(offered, excluded) {
+    const keys = new Set(excluded);
+    const identityOf = new Map(offered.flatMap((c) => (c.identity ? [[channelKey(c), c.identity]] : [])));
+    const identities = new Set([...keys].flatMap((k) => identityOf.get(k) ?? []));
+    return (seat) => {
+        const key = channelKey(seat);
+        const identity = identityOf.get(key);
+        return keys.has(key) || (identity !== undefined && identities.has(identity));
+    };
+}
 function withoutExcluded(channels, exclude) {
     if (!exclude?.size)
         return channels;
     // OBS-57: in-run demotion after consecutive no-trailer windows — route around poisoned channels for the rest of the run.
-    return channels.filter((c) => !exclude.has(channelKey(c)));
+    // D-718: a demoted channel's probed-identical alias is routed around too; an unprobed one is not.
+    const excluded = channelExclusion(channels, exclude);
+    return channels.filter((c) => !excluded(c));
 }
 // Pools spread providers before tier, independently within each marginal-cost run. Stable
 // cost sorting preserves declaration order when forming groups; gateways share the served
@@ -394,19 +416,18 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
 function candidatePool(current, task, cfg, channels, tried, tierPredicate, exclude) {
-    channels = withoutExcluded(channels, exclude).filter((c) => inTaskPool(task, cfg, channelKey(c)));
+    // D-718: tried/escalated/demoted keys share channelExclusion's meaning, resolved against every offered
+    // channel; the provider-outage rule below still reads the raw-key remainder exactly as before.
+    const excluded = channelExclusion(channels, [...(exclude ?? []), ...tried]);
+    channels = channels.filter((c) => !exclude?.has(channelKey(c)) && inTaskPool(task, cfg, channelKey(c)));
     const triedKeys = new Set(tried);
-    const triedIdentities = new Set(tried.map((key) => {
-        const channel = channels.find((c) => channelKey(c) === key);
-        return channel ? modelRouteIdentity(channel.model, channel.vendor) : channelRouteIdentity(key);
-    }));
     // excludeAdapter is expanded by the daemon into every channel key of the failed adapter. Once that
     // complete set is present, the outage follows the current served provider across gateway aliases.
     const currentAdapterExcluded = channels.some((c) => c.adapter === current.adapter)
         && channels.filter((c) => c.adapter === current.adapter).every((c) => triedKeys.has(channelKey(c)));
     const currentChannel = channels.find((c) => c.adapter === current.adapter && c.model === current.model);
     const excludedProvider = currentAdapterExcluded ? routingModelProvider(current.model, currentChannel?.vendor) : undefined;
-    return channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
+    return channels.filter((c) => !excluded(c)
         && (!excludedProvider || routingModelProvider(c.model, c.vendor) !== excludedProvider)
         && tierPredicate(c.tier));
 }

package/dist/run/daemon.js

@@ -39,7 +39,7 @@ import { applyScopeAmendments, activeRetryBan, interruptedAttempt, RESUME_HARVES
 import { gateReviewerFloor, isDiffCapPark, isGarbageReview, pickReviewer } from "../gates/review.js";
 import { acquireApprovalSerialization, acquireRunLock, isPidLive, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, reusedTipEvidence, verifyIntegrationTip } from "./merge.js";
-import { climbChannel, inTaskPool, marginalCostRank, nextChannel, poolExhaustion, route, taskPool } from "../route/router.js";
+import { channelExclusion, climbChannel, inTaskPool, marginalCostRank, nextChannel, poolExhaustion, route, taskPool } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
 import { readTierLiveness, readWatchBoard, supervisionPresencePath } from "./supervision.js";
 import { harvestCpuFlatWindowMs, NUDGEABLE_ADAPTERS, PANE_READ_ROWS, StallProgressTracker, stallSnapshotBannerRows, WorkerTreeCpuAccountant, reapOwnedProcessGroup, readOwnedProcessGroup, } from "./stall.js";
@@ -3215,10 +3215,12 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // and a lastAssignment at zero attempts is a first dispatch whose capacity requeue was taken back:
                     // the seat is still in force, so restore it instead of failing over its own tried[] entry early.
                     // OBS-1187: a restored seat must still be a member of the task's pool (the operator may have closed it).
+                    // F/W (D-718): and not excluded under the router's one meaning — its raw key, or a probed identity
+                    // it shares with an excluded channel; an unprobed seat is excluded by its raw key alone.
                     if (!hintsChanged && rs?.lastAssignment
                         && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))
                         && inTaskPool(t, cfg, channelKey(rs.lastAssignment))
-                        && !demotedChannels.has(channelKey(rs.lastAssignment))) {
+                        && !channelExclusion(channels, demotedChannels)(rs.lastAssignment)) {
                         assignment = rs.lastAssignment; // restore the consult-chosen assignment (bypasses route()'s static re-pick)
                     }
                     else if (!hintsChanged && rs && rs.tried.length && !t.routingHints?.pin) {
@@ -4016,7 +4018,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 const followsApproved = GATE_NAMES.indexOf(gate) > satisfiedIndex;
                                 const otherRed = prior?.pass === false;
                                 const needsFullSuite = gate === "test" && prior?.fullSuite !== true;
-                                return followsApproved || otherRed || needsFullSuite;
+                                // W: a red evidence/scope screen ends the round before the battery, so a gate that PRECEDES
+                                // the waived one may never have run: no prior-round row is no verdict — run it as declared.
+                                const unobserved = prior === undefined;
+                                return followsApproved || otherRed || needsFullSuite || unobserved;
                             });
                         }
                         else {

package/dist/run/journal.d.ts

@@ -435,8 +435,8 @@ export declare const TelemetryRowSchema: z.ZodObject<{
     quotaFailover: z.ZodOptional<z.ZodLiteral<true>>;
     overrun: z.ZodOptional<z.ZodLiteral<true>>;
     retryMode: z.ZodOptional<z.ZodEnum<{
-        repair: "repair";
         resume: "resume";
+        repair: "repair";
         fresh: "fresh";
     }>>;
     signalQuality: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<0.75>, z.ZodLiteral<1>]>>;
@@ -593,4 +593,100 @@ export declare class Journal {
     readTelemetry(): TelemetryRow[];
     readJudgeTelemetry(): TelemetryRow[];
 }
+export declare const OWED_CHECK_VERSION: 1;
+export declare const OWED_DISCHARGE_EVENT: "owed-check-discharged";
+export interface OwedCheck {
+    version: typeof OWED_CHECK_VERSION;
+    id: string;
+    runId: string;
+    taskId: string;
+    gate: GateName;
+    /** The immutable range the waived gate measured, and its canonical subject (daemon gateCommitSubject). */
+    base: string;
+    head: string;
+    subject: string;
+    /** Verbatim (whitespace-sensitive) patch identity of the whole range and of each commit, in order — the integration mapping key. */
+    patch: string;
+    patches: string[];
+    criteria: string;
+    /** The task's file scope at waive time: a discharge gates exactly this allowlist, never a wider one. */
+    files: string[];
+    authors: string[];
+    /** The channels this repository's adapters declared under its config at waive time (key → vendor):
+     *  the only seats a review discharge's reviewer and author channels may resolve to. */
+    declared: ChannelFact[];
+    cause: string;
+    evidence: string;
+    disposition: "accepted-risk";
+    known: boolean;
+    unknownReason?: string;
+}
+export interface OwedFold {
+    known: boolean;
+    debt: number | "unknown";
+    outstanding: OwedCheck[];
+    acceptedRisk: OwedCheck[];
+    discharged: string[];
+    unknown: Array<{
+        taskId?: string;
+        gate?: string;
+        reason: string;
+    }>;
+}
+export declare const owedCriteria: (acceptance: unknown) => string;
+/** The daemon's canonical gate subject for base..head (daemon.ts gateCommitSubject), byte for byte. */
+export declare const owedSubject: (cwd: string, base: string, head: string) => string;
+/** Ordered verbatim patch ids of the commits in base..head; an empty commit authored no patch. */
+export declare const rangePatches: (cwd: string, base: string, head: string) => string[];
+/** Verbatim patch identity of the whole change base..head introduces. */
+export declare const rangePatch: (cwd: string, base: string, head: string) => string;
+/**
+ * `head` is the task's own recorded integration merge of the obligation's range — exactly. Its first
+ * parent is `mergeBase`; its second parent replays the waived history source tree for source tree from
+ * a base with the waived base's tree (a carry may mint new commit objects, never new content — and
+ * patch ids alone ignore where a hunk lands); its tree is git's own clean merge of the two (no
+ * resolution, no amend); and it introduced the same ordered verbatim patch series and total patch.
+ * Squashed, reordered, relocated, re-indented, reverted or conflict-resolved history fails one of
+ * these and is refused as ambiguous; containment never counts.
+ * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
+ */
+export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown): boolean;
+/**
+ * Lifetime patch authors of base..head, read from the run: the daemon's subjectAuthors fold
+ * (daemon.ts, not exported and not this task's to edit) restated synchronously so the waive row is
+ * written without yielding. Recreation rows name SOURCE hashes, so ownership joins by stable patch
+ * identity across changed commit objects; a gate-only restore (resume-restore's seat, a recreation
+ * after work started) never becomes an author. Unreadable history names an unknown author.
+ */
+export declare function owedAuthors(events: readonly JournalEvent[], taskId: string, cwd: string, base: string, head: string): string[];
+/**
+ * The obligation a waive of `gate` leaves on the task branch's current range. Synchronous on purpose:
+ * approve writes it into the waive row under the approval serialization without yielding, so a live
+ * daemon's boundary sees the same single append it always did. Anything not bound exactly — the
+ * waived row measured another subject, unreadable refs, unresolved authors, unreadable criteria — is
+ * recorded, never guessed, as known: false.
+ */
+export declare function captureOwedCheck(input: {
+    cwd: string;
+    runId: string;
+    taskId: string;
+    gate: GateName;
+    cause: string;
+    acceptance: unknown;
+    files: unknown;
+    declared: readonly ChannelFact[] | undefined;
+    taskRef: string;
+    integrationRef: string;
+    events: readonly JournalEvent[];
+}): OwedCheck;
+export type ChannelFact = {
+    key: string;
+    vendor: string;
+};
+/**
+ * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
+ * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
+ * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ */
+export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string): OwedFold;
 export {};