tickmarkr 2.2.1 → 2.4.0

package/README.md

@@ -13,8 +13,9 @@ tickmarkr is a spec-driven orchestration harness for AI coding agent CLIs. You w
 acceptance criteria; the engine routes tasks to the best installed agent CLI (claude-code, codex,
 cursor-agent, opencode, grok, pi, kimi) by cost and capability, dispatches work in git worktrees for
 change isolation — as interactive TUIs when running under [herdr](https://herdr.dev), headless
-subprocesses otherwise, or in [Orca](https://onorca.dev) terminals when you name that driver
-yourself — and independently verifies each committed result by checking for no new
+subprocesses otherwise, or in [Orca](https://onorca.dev) terminals when auto detects both Orca
+markers (name that driver explicitly outside one) — and independently verifies each committed
+result by checking for no new
 baseline failures per task, then strictly verifying the integration tip. Green tasks consolidate onto a
 `tickmarkr/<runId>` branch; merging to your mainline is always your call, never automated. Engage
 with full visibility into routing decisions, worker progress, and gate verdicts — or run headless
@@ -251,14 +252,14 @@ and first-attempt success rate. Cost reporting follows strict honesty rules and
 When running under [herdr](https://herdr.dev), tickmarkr creates a labeled pane-and-tab workspace
 for real-time visibility (optional — omit `--driver herdr` or run headless if preferred).
 
-### Orca: an explicit-selection execution surface
+### Orca: a detected-or-named execution surface
 
-[Orca](https://onorca.dev) is the third execution surface, and the only one you must ask for by
-name: `--driver orca` or `driver: orca` in config. `--driver auto` never selects it — auto picks
-herdr when a herdr session is live and subprocess otherwise — so Orca is never inherited from an
-ambient environment variable, and an Orca that is installed but unreachable is not silently
-downgraded to a hidden subprocess worker either. Naming it is the whole gate; its runtime failures
-stay Orca's, reported as failures.
+[Orca](https://onorca.dev) is the third execution surface. `auto` resolves herdr first when
+`HERDR_ENV=1`, then Orca only when both Orca-authored markers `TERM_PROGRAM=Orca` and
+`ORCA_TERMINAL_HANDLE` are present, then subprocess. This environment-only choice executes no
+binary or runtime probe. Outside an Orca terminal, name it explicitly with `--driver orca` or
+`driver: orca` in config. Once selected either way, an unreachable Orca stays a loud Orca driver
+failure and is never silently replaced by a hidden subprocess worker.
 
 What Orca supplies is terminals. What tickmarkr keeps is everything that decides whether work
 ships: **it creates and owns the git worktree** for every task (Orca is told which checkout to bind

package/dist/adapters/catalog-remote.d.ts

@@ -66,9 +66,6 @@ export declare function resolveCatalogModel(catalog: CatalogCache, query: {
     model: string;
     resolvedModel?: string;
 }): CatalogModelEvidence | undefined;
-/**
- * The named, explicit refresh path. No other function in this module can reach fetch.
- * A failed refresh preserves the previous cache byte-for-byte and returns it fail-open.
- */
+/** Shared refresh path for the explicit command and the seven-day doctor/fleet guard. */
 export declare function refreshCatalogCommand(opts: RefreshCatalogOptions): Promise<RefreshCatalogResult>;
 export {};

package/dist/adapters/catalog-remote.js

@@ -9,20 +9,21 @@ export const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/ap
 export const LIVEBENCH_TABLE_DATE = "2026_06_25";
 export const LIVEBENCH_TABLE_URL = `https://livebench.ai/table_${LIVEBENCH_TABLE_DATE}.csv`;
 export const LIVEBENCH_CATEGORIES_URL = `https://livebench.ai/categories_${LIVEBENCH_TABLE_DATE}.json`;
-export const CATALOG_CACHE_MAX_AGE_MS = 30 * 86_400_000;
+export const CATALOG_CACHE_MAX_AGE_MS = 7 * 86_400_000;
 export const CATALOG_REFRESH_TIMEOUT_MS = 10_000;
 const ARTIFICIAL_ANALYSIS_PAGE_SIZE = 100;
 const ARTIFICIAL_ANALYSIS_MAX_PAGES = 100;
 const VENDORED_CATALOG = {
     schemaVersion: 1,
     // Package fallback copied from https://models.dev/api.json on 2026-08-05. It is deliberately
-    // small: an explicit refresh owns broad/current coverage, while doctor remains cache-only.
+    // small: the explicit or seven-day operator-surface refresh owns broad/current coverage.
     fetchedAt: "2026-08-05T20:00:05.000Z",
     modelsDev: {
         anthropic: {
             id: "anthropic",
             models: {
-                "claude-fable-5": { id: "claude-fable-5", cost: { input: 10, output: 50 }, limit: { context: 1_000_000, output: 128_000 }, reasoning: true, tool_call: true, structured_output: true, attachment: true },
+                // SHIP (OBS-871, 2026-09-03): users resolving the current Fable alias need the 5.1 identity even when refresh is unavailable.
+                "claude-fable-5-1": { id: "claude-fable-5-1", cost: { input: 10, output: 50 }, limit: { context: 1_000_000, output: 128_000 }, reasoning: true, tool_call: true, structured_output: true, attachment: true },
                 "claude-opus-4-8": { id: "claude-opus-4-8", cost: { input: 5, output: 25 }, limit: { context: 1_000_000, output: 128_000 }, reasoning: true, tool_call: true, structured_output: true, attachment: true },
                 "claude-sonnet-5": { id: "claude-sonnet-5", cost: { input: 2, output: 10 }, limit: { context: 1_000_000, output: 128_000 }, reasoning: true, tool_call: true, structured_output: true, attachment: true },
                 "claude-haiku-4-5-20251001": { id: "claude-haiku-4-5-20251001", cost: { input: 1, output: 5 }, limit: { context: 200_000, output: 64_000 }, reasoning: true, tool_call: true, structured_output: true, attachment: true },
@@ -226,6 +227,7 @@ function assertUsableLiveBench(rows, categories) {
 // `-thinking-auto-medium-effort`); the highest effort is the model at its best. Rank by
 // hyphen-delimited token so `xhigh` never reads as `high`.
 const LIVEBENCH_EFFORT_RANK = { max: 5, xhigh: 4, high: 3, medium: 2, low: 1 };
+const LIVEBENCH_VARIANT_RE = /^-(?:max|xhigh|high|medium|low|thinking|auto|effort|fast)(?:-(?:max|xhigh|high|medium|low|thinking|auto|effort|fast))*$/;
 const liveBenchEffortRank = (residue) => residue.split("-").reduce((rank, token) => Math.max(rank, LIVEBENCH_EFFORT_RANK[token] ?? 0), 0);
 const liveBenchCategoryMean = (row, tasks) => {
     const scores = (Array.isArray(tasks) ? tasks : [])
@@ -233,8 +235,8 @@ const liveBenchCategoryMean = (row, tasks) => {
         .filter((score) => score !== undefined);
     return scores.length > 0 ? scores.reduce((sum, score) => sum + score, 0) / scores.length : undefined;
 };
-/** LiveBench hyphenates where models.dev spaces: `Kimi K3` is `kimi-k3` in the table. */
-const liveBenchIdentity = (value) => value.trim().toLowerCase().replace(/\s+/g, "-");
+/** LiveBench treats spaces, dots, and punctuation as the same word boundary. */
+const liveBenchIdentity = (value) => value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 function liveBenchIndex(value, identities) {
     const root = record(value);
     if (!root || !Array.isArray(root.rows))
@@ -249,7 +251,7 @@ function liveBenchIndex(value, identities) {
         // Bare startsWith is a false-positive machine: `glm-5` would claim `glm-5.2`. The residue after
         // the fleet id must be empty or an effort suffix.
         const residue = wanted.map((identity) => model.startsWith(identity) ? model.slice(identity.length) : undefined)
-            .find((rest) => rest === "" || rest?.startsWith("-"));
+            .find((rest) => rest === "" || LIVEBENCH_VARIANT_RE.test(rest ?? ""));
         if (residue === undefined)
             continue;
         const rank = liveBenchEffortRank(residue);
@@ -285,6 +287,7 @@ export function resolveCatalogModel(catalog, query) {
     const identities = [
         modelId,
         query.model,
+        ...[modelId, query.model].flatMap((identity) => identity.includes("/") ? [identity.slice(identity.lastIndexOf("/") + 1)] : []),
         ...(typeof model.name === "string" ? [model.name] : []),
     ];
     const intelligence = artificialAnalysisIndex(catalog.artificialAnalysis, [
@@ -400,53 +403,60 @@ async function fetchLiveBench(fetcher, timeoutMs) {
     assertUsableLiveBench(rows, categories);
     return { tableDate: LIVEBENCH_TABLE_DATE, categories, rows };
 }
-/**
- * The named, explicit refresh path. No other function in this module can reach fetch.
- * A failed refresh preserves the previous cache byte-for-byte and returns it fail-open.
- */
+/** Shared refresh path for the explicit command and the seven-day doctor/fleet guard. */
 export async function refreshCatalogCommand(opts) {
     const now = opts.now ?? (() => new Date());
     const current = readCachedCatalog(opts.repoRoot, { now });
+    const fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
+    const timeoutMs = opts.timeoutMs ?? CATALOG_REFRESH_TIMEOUT_MS;
+    const warnings = [];
+    let modelsDev = current.catalog.modelsDev;
+    let modelsDevUpdated = false;
     try {
-        const fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
-        const timeoutMs = opts.timeoutMs ?? CATALOG_REFRESH_TIMEOUT_MS;
-        const modelsDev = await fetchCatalog(fetcher, MODELS_DEV_CATALOG_URL, {}, timeoutMs, (r) => r.json());
+        modelsDev = await fetchCatalog(fetcher, MODELS_DEV_CATALOG_URL, {}, timeoutMs, (r) => r.json());
         if (!validModelsDevCatalog(modelsDev))
             throw new Error("models.dev catalog schema is invalid");
-        const apiKey = opts.artificialAnalysisKey ?? process.env.ARTIFICIAL_ANALYSIS_API_KEY?.trim();
-        const artificialAnalysis = apiKey
-            ? await fetchArtificialAnalysis(fetcher, apiKey, timeoutMs)
-            : undefined;
-        // The LiveBench leg is keyless and never costs the models.dev refresh: a failure keeps the
-        // previous section verbatim and names the leg in the warning.
-        let liveBench = current.catalog.liveBench;
-        let warning;
+        modelsDevUpdated = true;
+    }
+    catch (error) {
+        warnings.push(`models.dev refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let artificialAnalysis = current.catalog.artificialAnalysis;
+    const apiKey = opts.artificialAnalysisKey ?? process.env.ARTIFICIAL_ANALYSIS_API_KEY?.trim();
+    if (apiKey) {
         try {
-            liveBench = await fetchLiveBench(fetcher, timeoutMs);
+            artificialAnalysis = await fetchArtificialAnalysis(fetcher, apiKey, timeoutMs);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            warning = message.startsWith("LiveBench") ? message : `LiveBench refresh failed: ${message}`;
+            warnings.push(`Artificial Analysis refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const catalog = {
-            schemaVersion: 1,
-            fetchedAt: now().toISOString(),
-            modelsDev,
-            ...(artificialAnalysis !== undefined ? { artificialAnalysis } : {}),
-            ...(liveBench !== undefined ? { liveBench } : {}),
-        };
-        writeCatalogCache(opts.repoRoot, catalog);
-        return {
-            updated: true,
-            catalog: readCachedCatalog(opts.repoRoot, { now }),
-            ...(warning !== undefined ? { warning } : {}),
-        };
+    }
+    let liveBench = current.catalog.liveBench;
+    let liveBenchUpdated = false;
+    try {
+        liveBench = await fetchLiveBench(fetcher, timeoutMs);
+        liveBenchUpdated = true;
     }
     catch (error) {
-        return {
-            updated: false,
-            catalog: current,
-            warning: error instanceof Error ? error.message : String(error),
-        };
+        warnings.push(`LiveBench refresh failed: ${error instanceof Error ? error.message : String(error)}`);
     }
+    // models.dev is the required cache spine. Still run every independent leg after it fails, but do
+    // not write a cache that would make the vendored fallback look fetched.
+    if (!modelsDevUpdated) {
+        return { updated: false, catalog: current, warning: warnings.join("; ") };
+    }
+    const catalog = {
+        schemaVersion: 1,
+        // A failed keyless leg keeps the old age so doctor/fleet retry it rather than masking it for 7d.
+        fetchedAt: liveBenchUpdated ? now().toISOString() : current.catalog.fetchedAt,
+        modelsDev,
+        ...(artificialAnalysis !== undefined ? { artificialAnalysis } : {}),
+        ...(liveBench !== undefined ? { liveBench } : {}),
+    };
+    writeCatalogCache(opts.repoRoot, catalog);
+    return {
+        updated: true,
+        catalog: readCachedCatalog(opts.repoRoot, { now }),
+        ...(warnings.length ? { warning: warnings.join("; ") } : {}),
+    };
 }

package/dist/adapters/catalog.js

@@ -9,6 +9,7 @@ import { cursorAgent } from "./cursor-agent.js";
 import { grok } from "./grok.js";
 import { kimi } from "./kimi.js";
 import { opencode } from "./opencode.js";
+import { qwen, QWEN_VERSION_IDENTITY } from "./qwen.js";
 import { pi } from "./pi.js";
 import { TRUST_DIALOG_VARIANTS, TrustDialogSchema } from "./types.js";
 export const CLI_NAME_RE = /^[a-z0-9-]+$/;
@@ -105,10 +106,10 @@ function validateCliEntry(entry) {
 }
 // Package-owned, deterministic order. This is the sole shipped definition array: candidate-name
 // compatibility and advisory/routable projections below are all derived from it.
-const native = (adapter, binary) => ({
+const native = (adapter, binary, identity = ".+") => ({
     id: adapter.id,
     binary,
-    identity: ".+",
+    identity,
     vendor: adapter.vendor,
     drive: { adapter },
 });
@@ -122,7 +123,8 @@ export const CLI_CATALOG = [
     native(pi, "pi"),
     native(grok, "grok"),
     native(kimi, "kimi"),
-    "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush",
+    native(qwen, "qwen", QWEN_VERSION_IDENTITY.source),
+    "gemini", "aider", "goose", "amp", "droid", "auggie", "crush",
     {
         id: "omp",
         binary: "omp",

package/dist/adapters/claude-code.d.ts

@@ -1,6 +1,6 @@
 import { type AuthHealth, type TrustDialog, type WorkerAdapter } from "./types.js";
 export declare const CLAUDE_ALIAS_IDENTITY_STAMPS: {
-    readonly fable: "claude-fable-5";
+    readonly fable: "claude-fable-5-1";
     readonly opus: "claude-opus-4-8";
     readonly sonnet: "claude-sonnet-5";
     readonly haiku: "claude-haiku-4-5-20251001";

package/dist/adapters/claude-code.js

@@ -29,7 +29,8 @@ const MAX_SESSION_BYTES = 8_000_000; // per-file cap; a runaway JSONL cannot mak
 // claude-opus-5 channel to the repo overlay — it did not re-date this alias's stamps, so the
 // alias channel still carries 4-8-dated tier/pricing while serving 5. That warning is true.
 export const CLAUDE_ALIAS_IDENTITY_STAMPS = {
-    fable: "claude-fable-5",
+    // OBS-871, 2026-09-03: Fable's floating alias now resolves to the 5.1 benchmark identity.
+    fable: "claude-fable-5-1",
     opus: "claude-opus-4-8",
     sonnet: "claude-sonnet-5",
     haiku: "claude-haiku-4-5-20251001",
@@ -209,7 +210,7 @@ export const claudeCode = {
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
     // v1.65 T3: every flag the command builders below hardcode — doctor checks `claude --help` still
     // lists each (all present on claude 2.x, verified 2026-07-22). Advisory only, never routing.
-    hardcodedFlags: { binary: "claude", flags: ["-p", "--model", "--permission-mode", "--strict-mcp-config", "--mcp-config", "--output-format", "-r", "--prompt-suggestions"] },
+    hardcodedFlags: { binary: "claude", flags: ["-p", "--model", "--permission-mode", "--strict-mcp-config", "--mcp-config", "--output-format", "-r", "--prompt-suggestions", "--settings"] },
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree
     // workers/gates don't load project .mcp.json servers (herdr scrapes dialogs as idle — v1.4 incident,
     // memory tickmarkr-worker-mcp-dialog-stall). Live-verified 2026-07-10 on claude 2.1.205 (operator check):
@@ -219,7 +220,9 @@ export const claudeCode = {
     // Gotchas (both bit the 2026-07-10 live check): bare '{}' is REJECTED ("mcpServers: expected record"),
     // and --mcp-config is VARIADIC — a positional after it is eaten as a config-file path, so another
     // flag must always follow the value, never the prompt.
-    headlessCommand: (promptFile, model) => `claude -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --permission-mode bypassPermissions --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text`,
+    // The empty -p argument selects print mode while stdin carries the prompt, keeping its nonce out
+    // of process argv. The redirect path is shell-quoted independently from the model.
+    headlessCommand: (promptFile, model) => `claude -p '' --model ${shq(model)} --permission-mode bypassPermissions --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text < ${shq(promptFile)}`,
     // HYG-03 / OBS-137: the residual first-entry dialog is workspace trust, not MCP config loading.
     // Claude's only store is global last-writer-wins ~/.claude.json, so tickmarkr still does not seed it;
     // the daemon safely answers only the exact adapter-declared dialog once per slot.
@@ -236,12 +239,12 @@ export const claudeCode = {
     // live check ate the prompt), and --prompt-suggestions takes an OPTIONAL value — appended directly
     // before the prompt it would swallow it the same way. So the setting's value is always followed by
     // another flag, never by the prompt positional.
-    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --settings '{"promptSuggestionEnabled":false}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     trustDialog: CLAUDE_TRUST_DIALOG,
     inputBox: CLAUDE_INPUT_BOX,
     // A resumed attempt lands in the same painted editor, so it carries the same ghost-text suppression
     // and the same value-then-flag placement.
-    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --settings '{"promptSuggestionEnabled":false}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

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

@@ -4,6 +4,14 @@ import { type AuthHealth, type WorkerAdapter } from "./types.js";
 import { type CatalogModelEvidence, type CatalogReadResult } from "./catalog-remote.js";
 export declare const SEED_STAMPED = "2026-07-09";
 export declare const MODEL_STALE_DAYS = 30;
+export type FleetUnclassifiedModel = {
+    adapter: string;
+    model: string;
+    detectedAt?: string;
+    variants?: string[];
+    /** The real CLI id written by classify when the display row is a collapsed base. */
+    classifyModel?: string;
+};
 /**
  * Operator directive 2026-08-13 ("we should exclude all retired models"): the fleet models
  * screen hides these classes BY DEFAULT — omp alone reports 218 ids, most of them dated
@@ -84,9 +92,5 @@ export declare function suggestOverlay(cfg: TickmarkrConfig, health: Record<stri
     resolvedModel?: (adapter: string, model: string) => string | undefined;
 }): 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;
-}[];
+export declare function fleetUnclassifiedModels(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): FleetUnclassifiedModel[];
 export {};

package/dist/adapters/model-lints.js

@@ -11,12 +11,52 @@ 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;
 const DAY_MS = 86400000;
-// cursor-agent 2026.07.08 reports 193 mostly-parameterized ids (e.g. gpt-5.3-codex-high-fast); filter the `auto`
-// pseudo-model + effort/speed variant suffixes from the unconfigured-lint aggregation ONLY — doctor.json keeps the
-// raw list (verified 2026-07-10). Data stays raw; lints stay signal. -max/-none/-thinking joined the suffix set
-// 2026-08-12 (D-OBS-11: cursor's residual lint list was still mostly effort variants of configured bases).
-const LINT_VARIANT_RE = /^auto$|-(fast|minimal|none|low|medium|high|xhigh|max|thinking)$/;
+// cursor-agent reports mostly effort/speed variants. Keep doctor.json raw, but collapse those ids
+// into one base row; a base-less classify writes the highest-effort real id.
+const VARIANT_SUFFIX_RE = /-(fast|minimal|none|low|medium|high|xhigh|max|thinking)$/;
+const VARIANT_RANK = { max: 6, xhigh: 5, high: 4, medium: 3, low: 2, minimal: 1, none: 0, thinking: 0, fast: 0 };
 const LINT_CAP = 5;
+const variantBase = (model) => {
+    let base = model;
+    while (VARIANT_SUFFIX_RE.test(base))
+        base = base.replace(VARIANT_SUFFIX_RE, "");
+    return base;
+};
+const variantRank = (model) => {
+    let rank = 0;
+    for (const token of model.split("-"))
+        rank = Math.max(rank, VARIANT_RANK[token] ?? 0);
+    return rank;
+};
+function collapseUnclassified(detected, configured) {
+    const groups = new Map();
+    for (const model of detected) {
+        if (model === "auto" || configured.has(model))
+            continue;
+        const base = variantBase(model);
+        if (configured.has(base))
+            continue;
+        const group = groups.get(base) ?? { bare: false, variants: [] };
+        if (model === base)
+            group.bare = true;
+        else
+            group.variants.push(model);
+        groups.set(base, group);
+    }
+    return [...groups].map(([model, group]) => {
+        if (!group.variants.length)
+            return { adapter: "", model };
+        const classifyModel = group.bare
+            ? model
+            : group.variants.reduce((best, candidate) => variantRank(candidate) > variantRank(best) ? candidate : best);
+        return {
+            adapter: "",
+            model,
+            variants: group.variants,
+            ...(classifyModel !== model ? { classifyModel } : {}),
+        };
+    });
+}
 /**
  * Operator directive 2026-08-13 ("we should exclude all retired models"): the fleet models
  * screen hides these classes BY DEFAULT — omp alone reports 218 ids, most of them dated
@@ -477,9 +517,9 @@ export function modelLints(cfg, health, adapters, opts) {
                 lints.push(`${id}: tiers lists ${model} — CLI no longer reports it; tombstone it (${model}: null overlay) or verify the id`);
             }
         }
-        const extra = detected.filter((m) => !configured.includes(m) && !LINT_VARIANT_RE.test(m));
+        const extra = collapseUnclassified(detected, new Set(configured));
         if (extra.length) {
-            const shown = extra.slice(0, cap).join(", ");
+            const shown = extra.slice(0, cap).map((row) => row.model).join(", ");
             const tail = extra.length > cap ? `, +${extra.length - cap} more${doctorRef}` : "";
             lints.push(`${id}: reports ${extra.length} model(s) not in tiers (${shown}${tail}) — classify before routing (benchmark policy)`);
         }
@@ -533,7 +573,7 @@ export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_D
         // Tombstones: configured ids the CLI no longer reports. Ids are operator-authored (from cfg) → MODEL_ID_RE only.
         const tombstones = configured.filter((model) => !detected.includes(model) && MODEL_ID_RE.test(model));
         // Additions: detected ids not in cfg. WHOLE line commented, no tier (MODEL-06). Ids come from an external
-        // CLI → MODEL_ID_RE (defense-in-depth, T-21-01) + the variant filter (cursor's ~193 parameterized ids).
+        // CLI → MODEL_ID_RE (defense-in-depth, T-21-01); effort variants collapse before this loop.
         // RELATIONAL gate (no capability judgment — "looks like an embedding model" is auto-tiering's cousin, the
         // NaN-routing class the v1.5 decision forbids): a detected id is suggested iff it shares a provider prefix
         // (clause a) OR a canonical segment (clause b, the RENAME case: opencode/glm-5.2 ⇒ zai-coding-plan/glm-5.2)
@@ -547,8 +587,9 @@ export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_D
         const cfgCanon = new Set(configured.map(canonical));
         const additions = [];
         let omitted = 0;
-        for (const model of detected) {
-            if (configured.includes(model) || !MODEL_ID_RE.test(model) || LINT_VARIANT_RE.test(model))
+        for (const row of collapseUnclassified(detected, new Set(configured))) {
+            const model = row.classifyModel ?? row.model;
+            if (!MODEL_ID_RE.test(model))
                 continue;
             if (configured.length > 0 && !cfgPrefixes.has(providerPrefix(model)) && !cfgCanon.has(canonical(model))) {
                 omitted++;
@@ -619,11 +660,11 @@ export function fleetUnclassifiedModels(cfg, health, adapters) {
             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 });
-        }
+        out.push(...collapseUnclassified(detected, configured).map((row) => ({
+            ...row,
+            adapter: id,
+            ...(date ? { detectedAt: date } : {}),
+        })));
     }
     return out;
 }

package/dist/adapters/model-windows.js

@@ -28,6 +28,9 @@ const CURSOR_SOURCE = "https://cursor.com/help/ai-features/max-mode";
 const ZAI_SOURCE = "https://z.ai/blog/glm-5.2";
 const XAI_SOURCE = "https://docs.x.ai/developers/models/grok-4.5";
 const KIMI_SOURCE = "https://www.kimi.com/code/docs/en/kimi-code-cli/configuration/config-files.html";
+const GOOGLE_SOURCE = "https://ai.google.dev/gemini-api/docs/models";
+const QWEN_SOURCE = "https://qwenlm.github.io/";
+const OBS_871_READ_DATE = "2026-09-03";
 const READ_DATE = "2026-08-05";
 const VENDORED_MODEL_WINDOW_CLAIMS = [
     { modelId: "fable", window: 1_000_000, source: ANTHROPIC_SOURCE, readDate: READ_DATE },
@@ -40,8 +43,16 @@ const VENDORED_MODEL_WINDOW_CLAIMS = [
     { modelId: "gpt-5.6-luna", window: 1_050_000, source: OPENAI_SOURCE, readDate: READ_DATE },
     { modelId: "composer-2.5", window: 200_000, source: CURSOR_SOURCE, readDate: READ_DATE },
     { modelId: "composer-2.5-fast", window: 200_000, source: CURSOR_SOURCE, readDate: READ_DATE },
+    { modelId: "claude-fable-5-1", window: 1_000_000, source: ANTHROPIC_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "gemini-3.8-flash", window: 1_000_000, source: GOOGLE_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "google/gemini-3.8-flash", window: 1_000_000, source: GOOGLE_SOURCE, readDate: OBS_871_READ_DATE },
     { modelId: "zai-coding-plan/glm-5.2", window: 1_000_000, source: ZAI_SOURCE, readDate: READ_DATE },
     { modelId: "zai/glm-5.2", window: 1_000_000, source: ZAI_SOURCE, readDate: READ_DATE },
+    { modelId: "zai/glm-5.3", window: 1_000_000, source: ZAI_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "zai/glm-5.3-flash", window: 200_000, source: ZAI_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "alibaba/qwen3.8-max", window: 1_000_000, source: QWEN_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "qwen3.8-max", window: 1_000_000, source: QWEN_SOURCE, readDate: OBS_871_READ_DATE },
+    { modelId: "prime-inference/z-ai/glm-5.2", window: 1_000_000, source: ZAI_SOURCE, readDate: OBS_871_READ_DATE },
     { modelId: "grok-4.5", window: 500_000, source: XAI_SOURCE, readDate: READ_DATE },
     { modelId: "grok-composer-2.5-fast", window: 200_000, source: CURSOR_SOURCE, readDate: READ_DATE },
     { modelId: "kimi-code/k3", window: 1_048_576, source: KIMI_SOURCE, readDate: READ_DATE },

package/dist/adapters/prompt.js

@@ -23,6 +23,7 @@ ${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(ta
 - Work only inside the current directory (your isolated worktree). Never push. Never switch branches.
 - Make small atomic git commits as you go (git add + git commit, conventional messages).
 - Touch ONLY paths matching the file scope. Out-of-scope edits FAIL the scope gate. The operator's allowlist is fixed when the run starts and nothing you do can change it while your work is judged; declaring a deviation never passes the gate either. If you cannot complete the task without an out-of-scope edit, stop and report ok:false explaining why in "summary". List any out-of-scope paths you did touch, each with a reason, in "deviations" (journaled for the operator's audit).
+- No background process may outlive the worker, and no suite may run beside another.
 - Do not ask questions; you are unattended. Make the smallest correct change.
 ${feedback ? `\n## Previous attempt failed gates — fix these specifically\n${feedback}\n` : ""}
 When finished, end your final message with exactly one line (no code fence):

package/dist/adapters/qwen.d.ts

@@ -0,0 +1,5 @@
+import { type ClassifiedWorkerResult } from "./prompt.js";
+import { type WorkerAdapter } from "./types.js";
+export declare const QWEN_VERSION_IDENTITY: RegExp;
+export declare function parseQwenResult(raw: string, nonce: string): ClassifiedWorkerResult;
+export declare const qwen: WorkerAdapter;

package/dist/adapters/qwen.js

@@ -0,0 +1,153 @@
+import { spawnSync } from "node:child_process";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, shq, } from "./types.js";
+export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
+const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
+function decodeQwenEvents(events) {
+    const text = [];
+    let failed = false;
+    let resultText;
+    let errorText;
+    let denialText;
+    for (const event of events) {
+        if (!event || typeof event !== "object")
+            continue;
+        if ("type" in event && event.type === "assistant" && "message" in event) {
+            const message = event.message;
+            if (message && typeof message === "object" && "content" in message && Array.isArray(message.content)) {
+                for (const content of message.content) {
+                    if (!content || typeof content !== "object" || !(("type" in content) && content.type === "text"))
+                        continue;
+                    if ("text" in content && typeof content.text === "string")
+                        text.push(content.text);
+                }
+            }
+        }
+        if ("is_error" in event && event.is_error === true)
+            failed = true;
+        if ("type" in event && event.type === "result") {
+            if (!(("subtype" in event) && event.subtype === "success"))
+                failed = true;
+            if ("result" in event && typeof event.result === "string" && event.result.trim()) {
+                resultText ??= event.result.trim();
+            }
+            // A no-auth host answers `result/error_during_execution` with the cause under `error.message`
+            // (verbatim: .planning/assessments/2026-09-04-qwen-live-worker-form/no-auth-home.stdout).
+            const error = "error" in event ? event.error : undefined;
+            if (error && typeof error === "object" && "message" in error && typeof error.message === "string" && error.message.trim()) {
+                errorText ??= error.message.trim();
+            }
+        }
+        if ("permission_denials" in event && Array.isArray(event.permission_denials) && event.permission_denials.length > 0) {
+            failed = true;
+            denialText ??= event.permission_denials.map(String).join(", ");
+        }
+        if (!("stats" in event) || !event.stats || typeof event.stats !== "object" || !("models" in event.stats))
+            continue;
+        const models = event.stats.models;
+        if (!models || typeof models !== "object")
+            continue;
+        for (const model of Object.values(models)) {
+            if (!model || typeof model !== "object" || !("api" in model))
+                continue;
+            const api = model.api;
+            if (!api || typeof api !== "object" || !("totalErrors" in api))
+                continue;
+            if (typeof api.totalErrors === "number" && api.totalErrors > 0)
+                failed = true;
+        }
+    }
+    const assistantText = text.join("\n");
+    const apiError = text.find((line) => line.startsWith("[API Error:"));
+    if (apiError)
+        failed = true;
+    if (!failed)
+        return { assistantText };
+    return {
+        assistantText,
+        failure: apiError ?? errorText ?? resultText ?? (denialText ? `qwen permission denied: ${denialText}` : "qwen reported a startup failure"),
+    };
+}
+// OBS-903: the daemon hands the adapter the WHOLE captured stream, never qwen's bare stdout — the
+// launch script's banner and TICKMARKR_EXIT line sit around it and the subprocess driver appends stderr
+// (the headless yolo warning) into the same buffer. The event array is located, not assumed: the bare
+// buffer first, then the outermost `[{` … `}]` span. A live PONG completion read as "unparseable" and
+// merged only through the harvest path until this (clause-4 probe, RULING-222-42).
+function eventArray(raw) {
+    const start = raw.indexOf("[{");
+    const end = raw.lastIndexOf("}]");
+    for (const text of [raw.trim(), start !== -1 && end > start ? raw.slice(start, end + 2) : ""]) {
+        if (!text.startsWith("["))
+            continue;
+        try {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* try the next shape */ }
+    }
+    return undefined;
+}
+// Decode qwen's JSON envelope before scanning only decoded assistant text for the worker trailer.
+export function parseQwenResult(raw, nonce) {
+    const malformed = {
+        ok: false,
+        summary: raw.trim() ? "unparseable qwen JSON event stream" : "qwen produced no JSON event stream",
+        deviations: [],
+        raw,
+        cause: raw.trim() ? "malformed-verdict" : "empty-output",
+    };
+    const parsed = eventArray(raw);
+    if (!parsed)
+        return malformed;
+    const decoded = decodeQwenEvents(parsed);
+    if (decoded.failure !== undefined) {
+        return {
+            ok: false,
+            summary: decoded.failure,
+            deviations: [],
+            raw,
+            cause: "startup-failure",
+        };
+    }
+    return { ...parseWorkerResult(decoded.assistantText, nonce), raw };
+}
+function probeQwen() {
+    const result = spawnSync("qwen", ["--version"], { encoding: "utf8", timeout: 10_000 });
+    if (result.error || result.status !== 0)
+        return { installed: false, authed: false, models: [] };
+    const version = (result.stdout || result.stderr).trim().split("\n")[0] ?? "";
+    if (!QWEN_VERSION_IDENTITY.test(version)) {
+        return { installed: false, authed: false, models: [], note: `qwen binary identity mismatch: ${version || "empty version"}` };
+    }
+    return {
+        installed: true,
+        authed: true,
+        version,
+        models: [],
+        note: "auth assumed; verified at dispatch (qwen reports API failures inside exit-0 success envelopes)",
+    };
+}
+export const qwen = {
+    id: "qwen",
+    vendor: "alibaba",
+    probeCwd: "neutral",
+    probe: async () => probeQwen(),
+    channels: (cfg) => channelsFromConfig("qwen", cfg),
+    hardcodedFlags: { binary: "qwen", flags: ["--approval-mode", "-m", "-o", "-p"] },
+    headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
+    // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
+    // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.
+    // The headless form runs in the visible pane and the same parser reads it in every driver; the daemon's
+    // mode-fallback branch (daemon.ts, `icmd === null`) journals the choice once per run.
+    interactiveCommand: () => null,
+    invoke(task, _cwd, assignment, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, assignment.model) };
+    },
+    parse: parseQwenResult,
+    trustDialog: {
+        kind: "none",
+        reason: "qwen 0.21.15 showed no workspace-trust prompt in a fresh repository during the recorded interactive probe (.planning/assessments/2026-09-03-qwen-cli-probe/README.md, 2026-09-03); enabling security.folderTrust falsifies this declaration",
+    },
+};