tickmarkr 1.84.0 → 1.86.0

package/README.md

@@ -253,7 +253,9 @@ the frontier-model consult is the *National Office*. The terms below use that vo
 
 ### Tab vocabulary
 
-- **WORKERS**: the primary generation tab showing active field-team tasks. The tab header shows a live token (task ID) plus one state glyph:
+- **`<taskId>`**: one tab per TASK. A task's worker pane and every gate pane it earns — judge, review,
+  consult — live together in that task's tab, so everything happening to one task is in one place. The
+  tab header shows the task token plus one state glyph:
   - ↻ — the member is a retry attempt (attempt > 0)
   - ✋ — the driver detected the member is blocked
   - (bare token) — member is running normally
@@ -288,7 +290,7 @@ This keeps the Partner focused on decisions that require attention, not noise.
 tickmarkr closes exactly what it owns and no longer needs, no matter how any process died.
 
 Every pane and tab tickmarkr creates receives a **parseable ownership name** encoding the pane's role, task, attempt, and run:
-- `WORKERS` — active worker generation tab
+- `<taskId>` — the task's tab, holding its worker and its judge/review/consult panes
 - `cleanup · <taskId>` — teardown generation tab for overflow attempts
 - `watch` — status monitor pane
 - `<role> · <taskId> · A<attempt> · R<runId>` — judge, review, consult, and worker panes (formats like `judge · task-abc123 · A1 · Rrun-20260713-175532`)

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

@@ -0,0 +1,64 @@
+export declare const MODELS_DEV_CATALOG_URL = "https://models.dev/api.json";
+export declare const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/language/models/free";
+export declare const CATALOG_CACHE_MAX_AGE_MS: number;
+export declare const CATALOG_REFRESH_TIMEOUT_MS = 10000;
+export interface CatalogCache {
+    schemaVersion: 1;
+    fetchedAt: string;
+    modelsDev: unknown;
+    artificialAnalysis?: unknown;
+}
+export interface CatalogReadResult {
+    catalog: CatalogCache;
+    source: "cache" | "vendored";
+    stale: boolean;
+    warning?: string;
+}
+export interface CatalogModelEvidence {
+    modelId: string;
+    inputCostPerMtok?: number;
+    outputCostPerMtok?: number;
+    contextWindow?: number;
+    outputWindow?: number;
+    features: string[];
+    intelligenceIndex?: number;
+    intelligenceIndexVersion?: string;
+}
+type CatalogResponse = {
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+};
+export type CatalogFetcher = (input: string | URL | Request, init?: RequestInit) => Promise<CatalogResponse>;
+export interface RefreshCatalogOptions {
+    repoRoot: string;
+    fetcher?: CatalogFetcher;
+    artificialAnalysisKey?: string;
+    timeoutMs?: number;
+    now?: () => Date;
+}
+export interface RefreshCatalogResult {
+    updated: boolean;
+    catalog: CatalogReadResult;
+    warning?: string;
+}
+export declare const catalogCachePath: (repoRoot: string) => string;
+/**
+ * Doctor's catalog seam: one synchronous local read with a vendored fail-open fallback.
+ * This function deliberately has no callback, promise, fetch, or adapter dependency.
+ */
+export declare function readCachedCatalog(repoRoot: string, opts?: {
+    now?: () => Date;
+}): CatalogReadResult;
+/** Resolve the alias identity first; the floating alias is only a fallback when identity is unknown. */
+export declare function resolveCatalogModel(catalog: CatalogCache, query: {
+    provider?: string;
+    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.
+ */
+export declare function refreshCatalogCommand(opts: RefreshCatalogOptions): Promise<RefreshCatalogResult>;
+export {};

package/dist/adapters/catalog-remote.js

@@ -0,0 +1,287 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const MODELS_DEV_CATALOG_URL = "https://models.dev/api.json";
+export const ARTIFICIAL_ANALYSIS_CATALOG_URL = "https://artificialanalysis.ai/api/v2/language/models/free";
+export const CATALOG_CACHE_MAX_AGE_MS = 30 * 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.
+    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 },
+                "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 },
+            },
+        },
+    },
+};
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+const nonNegative = (value) => {
+    const n = finite(value);
+    return n !== undefined && n >= 0 ? n : undefined;
+};
+const positive = (value) => {
+    const n = finite(value);
+    return n !== undefined && n > 0 ? n : undefined;
+};
+const validCache = (value) => {
+    const root = record(value);
+    return root?.schemaVersion === 1
+        && typeof root.fetchedAt === "string"
+        && Number.isFinite(Date.parse(root.fetchedAt))
+        && validModelsDevCatalog(root.modelsDev);
+};
+const validModelsDevCatalog = (value) => {
+    const providers = record(value);
+    if (!providers || Object.keys(providers).length === 0)
+        return false;
+    return Object.values(providers).some((provider) => {
+        const models = record(record(provider)?.models);
+        return models !== undefined && Object.keys(models).length > 0;
+    });
+};
+const staleAt = (fetchedAt, now) => {
+    const age = now.getTime() - Date.parse(fetchedAt);
+    return !Number.isFinite(age) || age > CATALOG_CACHE_MAX_AGE_MS;
+};
+export const catalogCachePath = (repoRoot) => join(repoRoot, ".tickmarkr", "catalog-cache.json");
+/**
+ * Doctor's catalog seam: one synchronous local read with a vendored fail-open fallback.
+ * This function deliberately has no callback, promise, fetch, or adapter dependency.
+ */
+export function readCachedCatalog(repoRoot, opts = {}) {
+    const now = (opts.now ?? (() => new Date()))();
+    try {
+        const parsed = JSON.parse(readFileSync(catalogCachePath(repoRoot), "utf8"));
+        if (!validCache(parsed))
+            throw new Error("catalog cache schema is invalid");
+        return { catalog: parsed, source: "cache", stale: staleAt(parsed.fetchedAt, now) };
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return {
+            catalog: VENDORED_CATALOG,
+            source: "vendored",
+            stale: staleAt(VENDORED_CATALOG.fetchedAt, now),
+            ...(!missing ? { warning: error instanceof Error ? error.message : String(error) } : {}),
+        };
+    }
+}
+function providerModels(modelsDev, preferred) {
+    const providers = record(modelsDev);
+    if (!providers)
+        return [];
+    const entries = Object.entries(providers);
+    const preferredEntries = preferred
+        ? entries.filter(([key, value]) => key === preferred || record(value)?.id === preferred)
+        : [];
+    // Price is provider-specific. A provider-qualified query must never borrow an identically named
+    // model from another provider, where subscription and metered costs can differ materially.
+    const selected = preferred ? preferredEntries : entries;
+    return selected
+        .map(([, provider]) => record(record(provider)?.models))
+        .filter((models) => models !== undefined);
+}
+function findModelsDevModel(catalog, provider, modelId) {
+    for (const models of providerModels(catalog.modelsDev, provider)) {
+        const direct = record(models[modelId]);
+        if (direct)
+            return direct;
+        const byId = Object.values(models).map(record).find((candidate) => candidate?.id === modelId);
+        if (byId)
+            return byId;
+    }
+    return undefined;
+}
+function artificialAnalysisRows(value) {
+    if (Array.isArray(value))
+        return value;
+    const root = record(value);
+    for (const key of ["data", "models", "results"]) {
+        if (Array.isArray(root?.[key]))
+            return root[key];
+    }
+    return [];
+}
+const canonicalCatalogIdentity = (identity) => identity.trim().toLowerCase().replace(/[^a-z0-9]+/g, "").replace(/(?:19|20)\d{6}$/, "");
+function artificialAnalysisIndex(value, identities, provider) {
+    const root = record(value);
+    const wanted = identities.map(canonicalCatalogIdentity).filter(Boolean);
+    for (const raw of artificialAnalysisRows(value)) {
+        const row = record(raw);
+        if (!row)
+            continue;
+        const nestedModel = record(row.model);
+        const creator = record(row.model_creator) ?? record(row.creator);
+        const creatorIds = [row.provider, creator?.id, creator?.slug, creator?.name]
+            .filter((candidate) => typeof candidate === "string")
+            .map(canonicalCatalogIdentity);
+        if (provider && creatorIds.length > 0 && !creatorIds.includes(canonicalCatalogIdentity(provider)))
+            continue;
+        const ids = [row.id, row.model_id, row.slug, row.name, nestedModel?.id, nestedModel?.slug, nestedModel?.name]
+            .filter((candidate) => typeof candidate === "string")
+            .map(canonicalCatalogIdentity);
+        if (!ids.some((identity) => wanted.includes(identity)))
+            continue;
+        const evaluations = record(row.evaluations);
+        for (const candidate of [
+            evaluations?.artificial_analysis_intelligence_index,
+            evaluations?.intelligence_index,
+            row.artificial_analysis_intelligence_index,
+            row.intelligence_index,
+        ]) {
+            const n = nonNegative(candidate);
+            if (n !== undefined) {
+                const version = root?.intelligence_index_version;
+                return {
+                    index: n,
+                    ...((typeof version === "string" || typeof version === "number") ? { version: String(version) } : {}),
+                };
+            }
+        }
+    }
+    return undefined;
+}
+/** Resolve the alias identity first; the floating alias is only a fallback when identity is unknown. */
+export function resolveCatalogModel(catalog, query) {
+    const modelId = query.resolvedModel ?? query.model;
+    const model = findModelsDevModel(catalog, query.provider, modelId);
+    if (!model)
+        return undefined;
+    const cost = record(model.cost);
+    const limit = record(model.limit);
+    const intelligence = artificialAnalysisIndex(catalog.artificialAnalysis, [
+        modelId,
+        ...(typeof model.name === "string" ? [model.name] : []),
+    ], query.provider);
+    const features = [
+        ["reasoning", model.reasoning],
+        ["tool-call", model.tool_call],
+        ["structured-output", model.structured_output],
+        ["attachment", model.attachment],
+        ["open-weights", model.open_weights],
+    ].filter((entry) => entry[1] === true).map((entry) => entry[0]);
+    return {
+        modelId,
+        ...(nonNegative(cost?.input) !== undefined ? { inputCostPerMtok: nonNegative(cost?.input) } : {}),
+        ...(nonNegative(cost?.output) !== undefined ? { outputCostPerMtok: nonNegative(cost?.output) } : {}),
+        ...(positive(limit?.context) !== undefined ? { contextWindow: positive(limit?.context) } : {}),
+        ...(positive(limit?.output) !== undefined ? { outputWindow: positive(limit?.output) } : {}),
+        features,
+        ...(intelligence !== undefined ? {
+            intelligenceIndex: intelligence.index,
+            ...(intelligence.version ? { intelligenceIndexVersion: intelligence.version } : {}),
+        } : {}),
+    };
+}
+async function fetchJson(fetcher, url, init, timeoutMs) {
+    const controller = new AbortController();
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            const error = new Error(`catalog request timed out after ${timeoutMs}ms`);
+            controller.abort(error);
+            reject(error);
+        }, timeoutMs);
+    });
+    try {
+        const request = (async () => {
+            const response = await fetcher(url, { ...init, signal: controller.signal });
+            if (!response.ok)
+                throw new Error(`${url === MODELS_DEV_CATALOG_URL ? "models.dev" : "Artificial Analysis"} HTTP ${response.status}`);
+            return response.json();
+        })();
+        return await Promise.race([request, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function writeCatalogCache(repoRoot, catalog) {
+    const path = catalogCachePath(repoRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}-${randomUUID()}.tmp`;
+    try {
+        writeFileSync(tmp, JSON.stringify(catalog, null, 2) + "\n");
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        rmSync(tmp, { force: true });
+        throw error;
+    }
+}
+async function fetchArtificialAnalysis(fetcher, apiKey, timeoutMs) {
+    const rows = [];
+    let first;
+    let lastPagination;
+    let intelligenceIndexVersion;
+    for (let page = 1; page <= ARTIFICIAL_ANALYSIS_MAX_PAGES; page++) {
+        const url = `${ARTIFICIAL_ANALYSIS_CATALOG_URL}?page=${page}&page_size=${ARTIFICIAL_ANALYSIS_PAGE_SIZE}`;
+        const value = await fetchJson(fetcher, url, { headers: { "x-api-key": apiKey } }, timeoutMs);
+        const root = record(value);
+        if (!root || !Array.isArray(root.data))
+            throw new Error("Artificial Analysis catalog schema is invalid");
+        first ??= root;
+        if (typeof root.intelligence_index_version === "string" || typeof root.intelligence_index_version === "number") {
+            intelligenceIndexVersion ??= root.intelligence_index_version;
+        }
+        rows.push(...root.data);
+        lastPagination = record(root.pagination);
+        if (lastPagination?.has_more !== true) {
+            return {
+                ...first,
+                ...(intelligenceIndexVersion !== undefined ? { intelligence_index_version: intelligenceIndexVersion } : {}),
+                data: rows,
+                ...(lastPagination ? { pagination: { ...lastPagination, has_more: false } } : {}),
+            };
+        }
+    }
+    throw new Error(`Artificial Analysis catalog exceeds ${ARTIFICIAL_ANALYSIS_MAX_PAGES} pages`);
+}
+/**
+ * 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.
+ */
+export async function refreshCatalogCommand(opts) {
+    const now = opts.now ?? (() => new Date());
+    const current = readCachedCatalog(opts.repoRoot, { now });
+    try {
+        const fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
+        const timeoutMs = opts.timeoutMs ?? CATALOG_REFRESH_TIMEOUT_MS;
+        const modelsDev = await fetchJson(fetcher, MODELS_DEV_CATALOG_URL, {}, timeoutMs);
+        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;
+        const catalog = {
+            schemaVersion: 1,
+            fetchedAt: now().toISOString(),
+            modelsDev,
+            ...(artificialAnalysis !== undefined ? { artificialAnalysis } : {}),
+        };
+        writeCatalogCache(opts.repoRoot, catalog);
+        return { updated: true, catalog: readCachedCatalog(opts.repoRoot, { now }) };
+    }
+    catch (error) {
+        return {
+            updated: false,
+            catalog: current,
+            warning: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/adapters/catalog.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import type { WorkerAdapter } from "./types.js";
+export declare const CLI_NAME_RE: RegExp;
+export declare const CliDriveSchema: z.ZodObject<{
+    headless: z.ZodString;
+    interactive: z.ZodNullable<z.ZodString>;
+    listModels: z.ZodOptional<z.ZodObject<{
+        argv: z.ZodArray<z.ZodString>;
+        parser: z.ZodEnum<{
+            lines: "lines";
+            "pi-table": "pi-table";
+            json: "json";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const CliEntryBaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    binary: z.ZodString;
+    identity: z.ZodString;
+    vendor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const CliEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    binary: z.ZodString;
+    identity: z.ZodString;
+    vendor: z.ZodNullable<z.ZodString>;
+    drive: z.ZodOptional<z.ZodObject<{
+        headless: z.ZodString;
+        interactive: z.ZodNullable<z.ZodString>;
+        listModels: z.ZodOptional<z.ZodObject<{
+            argv: z.ZodArray<z.ZodString>;
+            parser: z.ZodEnum<{
+                lines: "lines";
+                "pi-table": "pi-table";
+                json: "json";
+            }>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DeclarativeCliDrive = z.infer<typeof CliDriveSchema>;
+export type NativeCliDrive = {
+    adapter: WorkerAdapter;
+};
+export type CliDrive = DeclarativeCliDrive | NativeCliDrive;
+export type CliEntry = z.infer<typeof CliEntryBaseSchema> & {
+    drive?: CliDrive;
+};
+export declare function isNativeCliDrive(drive: CliDrive | undefined): drive is NativeCliDrive;
+export declare const CLI_CATALOG: readonly CliEntry[];
+export declare const SHIPPED_CLI_CATALOG: readonly CliEntry[];
+export declare function parseOperatorCliCatalog(text: string): CliEntry[];
+/** The one operator-owned definition file. Never relative to a repository and never enumerated. */
+export declare function operatorCliCatalogPath(env?: NodeJS.ProcessEnv): string;
+export declare function loadOperatorCliCatalog(path?: string): CliEntry[];
+export interface CatalogEntriesOptions {
+    shipped?: readonly CliEntry[];
+    operatorYaml?: string | null;
+    operatorPath?: string | false;
+    herdrNames?: readonly string[];
+}
+/**
+ * Compose package data, the single operator YAML layer, and Herdr name nominations into one array.
+ * Herdr cannot define or override a drive contract: valid tokens nominate only names not already
+ * defined. Invalid tokens are discarded before any resolver can receive them.
+ */
+export declare function catalogEntries(opts?: CatalogEntriesOptions): CliEntry[];
+export interface CliCatalogConflict {
+    binary: string;
+    ids: string[];
+}
+export declare function projectCliEntries(entries: readonly CliEntry[]): {
+    routable: CliEntry[];
+    advisory: CliEntry[];
+    conflicts: CliCatalogConflict[];
+};
+export interface CliPresence {
+    id: string;
+    binary: string;
+    path: string;
+    routable: boolean;
+}
+export interface CliDiscoveryDeps {
+    resolveBinary: (binary: string) => {
+        resolved?: string;
+        all: string[];
+    };
+    execute?: (entry: CliEntry, path: string) => unknown;
+}
+/** Resolve presence for both projections; only a declared drive contract licenses target execution. */
+export declare function discoverCliEntries(entries: readonly CliEntry[], deps: CliDiscoveryDeps): {
+    present: CliPresence[];
+    conflicts: CliCatalogConflict[];
+};
+export {};

package/dist/adapters/catalog.js

@@ -0,0 +1,176 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { claudeCode } from "./claude-code.js";
+import { codex } from "./codex.js";
+import { cursorAgent } from "./cursor-agent.js";
+import { grok } from "./grok.js";
+import { kimi } from "./kimi.js";
+import { opencode } from "./opencode.js";
+import { pi } from "./pi.js";
+export const CLI_NAME_RE = /^[a-z0-9-]+$/;
+const ListModelsSchema = z.object({
+    argv: z.array(z.string()).min(1),
+    parser: z.enum(["lines", "pi-table", "json"]),
+    path: z.string().min(1).optional(),
+}).strict();
+export const CliDriveSchema = z.object({
+    headless: z.string().min(1),
+    interactive: z.string().min(1).nullable(),
+    listModels: ListModelsSchema.optional(),
+}).strict().superRefine((drive, ctx) => {
+    for (const [field, template] of [["headless", drive.headless], ["interactive", drive.interactive]]) {
+        if (template === null)
+            continue;
+        for (const placeholder of ["{promptFile}", "{model}"]) {
+            if (!template.includes(placeholder)) {
+                ctx.addIssue({ code: "custom", path: [field], message: `${field} must contain ${placeholder}` });
+            }
+        }
+    }
+});
+const CliEntryBaseSchema = z.object({
+    id: z.string().regex(CLI_NAME_RE, "id must match [a-z0-9-]+"),
+    binary: z.string().regex(CLI_NAME_RE, "binary must match [a-z0-9-]+"),
+    // A declarative drive may execute `--version`; its first line must identify the expected CLI.
+    // Advisory entries carry the field too so shipped and operator data have one schema, but never use it.
+    identity: z.string().min(1).refine((source) => {
+        try {
+            new RegExp(source);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "identity must be a valid regular expression"),
+    vendor: z.string().min(1).nullable(),
+}).strict();
+export const CliEntrySchema = CliEntryBaseSchema.extend({
+    drive: CliDriveSchema.optional(),
+}).strict().superRefine((entry, ctx) => {
+    if (entry.drive && entry.vendor === null) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["vendor"],
+            message: "a drive contract requires a vendor until per-model vendor configuration lands",
+        });
+    }
+});
+export function isNativeCliDrive(drive) {
+    return !!drive && "adapter" in drive;
+}
+function validateCliEntry(entry) {
+    if (!isNativeCliDrive(entry.drive))
+        return CliEntrySchema.parse(entry);
+    const { drive, ...fields } = entry;
+    const base = CliEntryBaseSchema.parse(fields);
+    if (drive.adapter.id !== base.id || drive.adapter.vendor !== base.vendor) {
+        throw new Error(`native drive identity mismatch for ${base.id}`);
+    }
+    return { ...base, drive };
+}
+// 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) => ({
+    id: adapter.id,
+    binary,
+    identity: ".+",
+    vendor: adapter.vendor,
+    drive: { adapter },
+});
+export const CLI_CATALOG = [
+    // Preserve the historical tie-break order byte-for-byte: pi, grok and kimi stay last among the
+    // native adapters, with kimi after grok. Catalog-driven adapters append after this sequence.
+    native(claudeCode, "claude"),
+    native(codex, "codex"),
+    native(cursorAgent, "cursor-agent"),
+    native(opencode, "opencode"),
+    native(pi, "pi"),
+    native(grok, "grok"),
+    native(kimi, "kimi"),
+    "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush", "omp",
+].flatMap((entry) => typeof entry === "string"
+    ? [{ id: entry, binary: entry, identity: ".+", vendor: null }]
+    : [entry]);
+export const SHIPPED_CLI_CATALOG = CLI_CATALOG;
+const OperatorCatalogSchema = z.union([
+    z.array(CliEntrySchema),
+    z.object({ clis: z.array(CliEntrySchema) }).strict().transform(({ clis }) => clis),
+]);
+export function parseOperatorCliCatalog(text) {
+    return OperatorCatalogSchema.parse(parseYaml(text));
+}
+/** The one operator-owned definition file. Never relative to a repository and never enumerated. */
+export function operatorCliCatalogPath(env = process.env) {
+    const xdg = env.XDG_CONFIG_HOME?.trim();
+    const configRoot = xdg && isAbsolute(xdg) ? xdg : join(env.HOME?.trim() || homedir(), ".config");
+    return join(configRoot, "tickmarkr", "clis.yaml");
+}
+export function loadOperatorCliCatalog(path = operatorCliCatalogPath()) {
+    if (!isAbsolute(path))
+        throw new Error(`operator CLI catalog path must be absolute: ${path}`);
+    try {
+        return parseOperatorCliCatalog(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT"
+            || (error instanceof Error && error.message.includes("ENOENT"));
+        if (missing)
+            return [];
+        throw error;
+    }
+}
+/**
+ * Compose package data, the single operator YAML layer, and Herdr name nominations into one array.
+ * Herdr cannot define or override a drive contract: valid tokens nominate only names not already
+ * defined. Invalid tokens are discarded before any resolver can receive them.
+ */
+export function catalogEntries(opts = {}) {
+    const shipped = [...(opts.shipped ?? SHIPPED_CLI_CATALOG)].map(validateCliEntry);
+    const operator = opts.operatorYaml !== undefined
+        ? opts.operatorYaml === null ? [] : parseOperatorCliCatalog(opts.operatorYaml)
+        : opts.operatorPath === false ? [] : loadOperatorCliCatalog(opts.operatorPath);
+    const definitions = [...shipped, ...operator];
+    const claimed = new Set(definitions.map((entry) => entry.binary));
+    const nominated = [];
+    for (const name of opts.herdrNames ?? []) {
+        if (!CLI_NAME_RE.test(name) || claimed.has(name))
+            continue;
+        claimed.add(name);
+        nominated.push({ id: name, binary: name, identity: ".+", vendor: null });
+    }
+    return [...definitions, ...nominated];
+}
+export function projectCliEntries(entries) {
+    const parsed = entries.map(validateCliEntry);
+    const claims = new Map();
+    for (const entry of parsed)
+        claims.set(entry.binary, [...(claims.get(entry.binary) ?? []), entry]);
+    const conflicts = [...claims]
+        .filter(([, owners]) => owners.length > 1)
+        .map(([binary, owners]) => ({ binary, ids: owners.map((entry) => entry.id).sort() }))
+        .sort((a, b) => a.binary.localeCompare(b.binary));
+    const conflicted = new Set(conflicts.map((conflict) => conflict.binary));
+    const eligible = parsed.filter((entry) => !conflicted.has(entry.binary));
+    return {
+        routable: eligible.filter((entry) => entry.drive !== undefined),
+        advisory: eligible.filter((entry) => entry.drive === undefined),
+        conflicts,
+    };
+}
+/** Resolve presence for both projections; only a declared drive contract licenses target execution. */
+export function discoverCliEntries(entries, deps) {
+    const projected = projectCliEntries(entries);
+    const present = [];
+    for (const entry of [...projected.routable, ...projected.advisory]) {
+        const { resolved } = deps.resolveBinary(entry.binary);
+        if (!resolved)
+            continue;
+        if (entry.drive)
+            deps.execute?.(entry, resolved);
+        present.push({ id: entry.id, binary: entry.binary, path: resolved, routable: entry.drive !== undefined });
+    }
+    return { present, conflicts: projected.conflicts };
+}

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

@@ -8,6 +8,7 @@ export declare const CLAUDE_ALIAS_IDENTITY_STAMPS: {
 export type ClaudeAlias = keyof typeof CLAUDE_ALIAS_IDENTITY_STAMPS;
 export type ClaudeAliasIdentityProbe = (cwd: string, alias: ClaudeAlias) => string | undefined;
 export declare const CLAUDE_TRUST_DIALOG: TrustDialog;
+export declare const CLAUDE_INPUT_BOX: import("./types.js").InputBox;
 export declare function claudeSlug(real: string): string;
 export declare function readClaudeAliasIdentity(cwd: string, alias: ClaudeAlias): string | undefined;
 export declare function probeClaudeAliasIdentity(cwd: string, alias: ClaudeAlias): string | undefined;