quotacap 0.0.34 → 0.0.35

package/README.md

@@ -10,7 +10,7 @@ QuotaCap helps you get more from the AI coding subscriptions you already pay for
 ## Features
 
 - **Visibility**: remaining usage and reset time for one current window per connected plan
-- **Pacing**: recent usage when history is available, or an estimated pace while QuotaCap collects it
+- **Pacing**: a blend of the last 24h and past closed windows, or a window-average pace while QuotaCap collects history
 - **Advice**: an estimate of which plan to use next so you can use more of each allowance without exhausting one early
 - **Dashboard, CLI, and MCP**: the same data and advice on every surface
 

package/dist/advisory/engine.d.ts

@@ -1,5 +1,5 @@
 import type { Quota } from "../adapters/types.js";
-import type { Advisory, PaceSource, RecommendationBasis } from "./types.js";
+import type { Advisory, RecommendationBasis } from "./types.js";
 /**
  * Pace from a single reading.
  *
@@ -10,8 +10,13 @@ import type { Advisory, PaceSource, RecommendationBasis } from "./types.js";
  * denominator fabricates verdicts).
  */
 export declare function averagePace(q: Quota, now?: Date): number | null;
-export declare function computeAdvisory(q: Quota, burnRate: number | null, now?: Date, paceSourceOrMeasured?: PaceSource | boolean): Advisory;
-export declare function recommend(quotas: Quota[], _task: string, burnByProvider?: Map<string, number>, now?: Date): {
+export declare function blendForecast(recent: number | null, baseline: number | null): number | null;
+export declare function baselineFor(historyAvg: number | null, q: Quota, now: Date): number | null;
+export declare function computeAdvisory(q: Quota, recent: number | null, baseline: number | null, now?: Date): Advisory;
+export declare function recommend(quotas: Quota[], _task: string, paceByProvider?: Map<string, {
+    recent: number | null;
+    baseline: number | null;
+}>, now?: Date): {
     use: string;
     reason: string;
     wastePct: number;

package/dist/advisory/engine.js

@@ -1,4 +1,4 @@
-import { MIN_PACE_SPAN_DAYS } from "./types.js";
+import { MIN_PACE_SPAN_DAYS, BLEND_K, RISK_MARGIN, GATE_TOL } from "./types.js";
 const DAY_MS = 86400000;
 /**
  * Pace from a single reading.
@@ -23,7 +23,41 @@ export function averagePace(q, now = new Date()) {
         return null;
     return Math.max(0, pace);
 }
-export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasured = "unknown") {
+export function blendForecast(recent, baseline) {
+    if (recent === null)
+        return baseline;
+    if (baseline === null)
+        return recent;
+    return Math.max(0, baseline + BLEND_K * (recent - baseline));
+}
+export function baselineFor(historyAvg, q, now) {
+    if (historyAvg !== null)
+        return historyAvg;
+    return averagePace(q, now);
+}
+/**
+ * Position in the window from raw timestamps, clamped to 0..100. Derived
+ * elapsed time, never the clamped `daysLeft`: an estimated reset makes this
+ * fictional, which is exactly why the gate and the ahead test also check
+ * `resetsAtEstimated`. Returns null when either timestamp is missing or
+ * unparseable, the window has no positive span, or no time has elapsed.
+ */
+function elapsedPctOf(q, now) {
+    if (!q.periodStart)
+        return null;
+    const start = new Date(q.periodStart).getTime();
+    const resets = new Date(q.resetsAt).getTime();
+    if (Number.isNaN(start) || Number.isNaN(resets))
+        return null;
+    const span = resets - start;
+    if (!(span > 0))
+        return null;
+    const elapsed = now.getTime() - start;
+    if (!(elapsed > 0))
+        return null;
+    return Math.min(100, Math.max(0, (elapsed / span) * 100));
+}
+export function computeAdvisory(q, recent, baseline, now = new Date()) {
     const resets = new Date(q.resetsAt);
     const daysLeft = Math.max(0.1, (resets.getTime() - now.getTime()) / DAY_MS);
     const remaining = 100 - q.usedPct;
@@ -32,20 +66,11 @@ export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasu
     // Nothing left to burn: force the capped verdict even when the recent
     // window is flat (burn 0 at 100% used must not read "on track").
     const exhausted = remaining <= 0;
-    let paceSource;
-    let burnMeasured;
-    if (burnRate === null) {
-        paceSource = "unknown";
-        burnMeasured = false;
-    }
-    else if (typeof paceSourceOrMeasured === "string") {
-        paceSource = paceSourceOrMeasured;
-        burnMeasured = paceSource === "recent";
-    }
-    else {
-        burnMeasured = paceSourceOrMeasured;
-        paceSource = burnMeasured ? "recent" : "window-average";
-    }
+    const burnRate = blendForecast(recent, baseline);
+    // paceSource describes recent availability; the blend's composition is
+    // carried by recentRate and baselineRate.
+    const paceSource = recent !== null ? "recent" : burnRate !== null ? "window-average" : "unknown";
+    const burnMeasured = recent !== null;
     if (burnRate === null) {
         return {
             provider: q.provider,
@@ -53,6 +78,9 @@ export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasu
             remaining,
             idealRate,
             burnRate: null,
+            recentRate: null,
+            baselineRate: null,
+            aheadOfElapsed: null,
             avgPace,
             burnMeasured: false,
             paceSource: "unknown",
@@ -69,6 +97,9 @@ export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasu
             remaining,
             idealRate,
             burnRate,
+            recentRate: null,
+            baselineRate: null,
+            aheadOfElapsed: null,
             avgPace,
             burnMeasured,
             paceSource,
@@ -78,10 +109,23 @@ export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasu
             urgency: "slow down",
         };
     }
+    // Red needs a deadband margin and a cumulatively-ahead position on a
+    // verified clock; a missing or estimated clock caps at Watch.
+    const elapsed = elapsedPctOf(q, now);
+    const estimated = q.resetsAtEstimated === true;
+    const gate = elapsed !== null && !estimated && q.usedPct >= elapsed * (1 - GATE_TOL);
+    const aheadOfElapsed = elapsed !== null && !estimated && q.usedPct > elapsed * (1 + GATE_TOL);
     const wastePct = Math.max(0, remaining - burnRate * daysLeft);
-    // burn > ideal is exactly "quota exhausts before reset": remaining/burn < daysLeft
     const daysToExhaust = burnRate > 0 ? remaining / burnRate : Infinity;
-    const status = daysToExhaust < daysLeft ? "at risk" : "on track";
+    const over = daysToExhaust < daysLeft * (1 - RISK_MARGIN);
+    const marginal = !over && daysToExhaust < daysLeft * (1 + RISK_MARGIN);
+    let status;
+    if (over && gate)
+        status = "at risk";
+    else if (over || marginal)
+        status = "watch";
+    else
+        status = "on track";
     let urgency = "on track";
     if (wastePct > 30 && daysLeft < 3)
         urgency = "burn now";
@@ -91,9 +135,11 @@ export function computeAdvisory(q, burnRate, now = new Date(), paceSourceOrMeasu
         urgency = "slow down";
     else if (wastePct > 10)
         urgency = "save";
-    return { provider: q.provider, daysLeft, remaining, idealRate, burnRate, avgPace, burnMeasured, paceSource, daysToExhaust, status, wastePct, urgency };
+    if (estimated && urgency === "burn now")
+        urgency = "use soon";
+    return { provider: q.provider, daysLeft, remaining, idealRate, burnRate, recentRate: recent, baselineRate: baseline, aheadOfElapsed, avgPace, burnMeasured, paceSource, daysToExhaust, status, wastePct, urgency };
 }
-export function recommend(quotas, _task, burnByProvider = new Map(), now = new Date()) {
+export function recommend(quotas, _task, paceByProvider = new Map(), now = new Date()) {
     if (!quotas.length) {
         return {
             use: "none",
@@ -105,24 +151,23 @@ export function recommend(quotas, _task, burnByProvider = new Map(), now = new D
             advisories: [],
         };
     }
-    // Build advisories for every quota with honest pace sources.
+    // Callers own the blend inputs; an entry without pace stays honest about it.
     const advisories = quotas.map(q => {
-        const recent = burnByProvider.get(q.provider);
-        if (recent !== undefined) {
-            return computeAdvisory(q, recent, now, "recent");
-        }
-        const avg = averagePace(q, now);
-        if (avg !== null) {
-            return computeAdvisory(q, avg, now, "window-average");
-        }
-        return computeAdvisory(q, null, now, "unknown");
+        const pace = paceByProvider.get(q.provider);
+        if (pace)
+            return computeAdvisory(q, pace.recent, pace.baseline, now);
+        return computeAdvisory(q, null, null, now);
     });
+    // Ranking must not assert a fictional deadline: estimated-clock candidates
+    // are a fallback pool, read from the flags on the quotas already received.
+    const estimatedProviders = new Set(quotas.filter(q => q.resetsAtEstimated === true).map(q => q.provider));
     // 1. Prefer measured providers with positive avoidable waste (actionable "Use more" candidates).
     const positiveWaste = advisories.filter((a) => a.paceSource !== "unknown" && a.wastePct !== null && a.wastePct > 0);
     if (positiveWaste.length > 0) {
-        const burnNow = positiveWaste.filter(a => a.urgency === "burn now");
-        const pool = burnNow.length ? burnNow : positiveWaste;
-        const use = pool.sort((a, b) => b.wastePct - a.wastePct)[0];
+        const verified = positiveWaste.filter(a => !estimatedProviders.has(a.provider));
+        const pool = verified.length ? verified : positiveWaste.filter(a => estimatedProviders.has(a.provider));
+        const burnNow = pool.filter(a => a.urgency === "burn now");
+        const use = (burnNow.length ? burnNow : pool).sort((a, b) => b.wastePct - a.wastePct)[0];
         return {
             use: use.provider,
             reason: `${Math.round(use.wastePct)}% waste in ${use.daysLeft.toFixed(1)}d`,
@@ -147,23 +192,10 @@ export function recommend(quotas, _task, burnByProvider = new Map(), now = new D
             advisories,
         };
     }
-    // 3. Check if all measured providers are healthy and on pace (status "on track").
-    const onTrack = advisories.filter(a => a.paceSource !== "unknown" && a.status === "on track" && a.remaining > 0);
-    if (onTrack.length > 0) {
-        return {
-            use: "none",
-            reason: "No subscription needs priority",
-            wastePct: 0,
-            idealRate: 0,
-            recommendationBasis: "none",
-            alternatives: quotas,
-            advisories,
-        };
-    }
-    // 4. No meaningful candidate (e.g. all quotas at risk or exhausted).
+    // 3. No meaningful candidate (e.g. all quotas at risk, watch, or exhausted).
     return {
         use: "none",
-        reason: "all quotas at risk or exhausted",
+        reason: "all quotas at risk, watch, or exhausted",
         wastePct: 0,
         idealRate: 0,
         recommendationBasis: "none",

package/dist/advisory/snapshot.js

@@ -1,6 +1,8 @@
-import { getAllLatest, getBurnRates } from "../store/quotas.js";
+import { getAllLatest, getBurnRates, getHistoryBaseline, getWindowCloses } from "../store/quotas.js";
 import { getAttempts } from "../store/attempts.js";
-import { recommend, averagePace, computeAdvisory } from "./engine.js";
+import { getCatalogs } from "../store/catalogs.js";
+import { emptyCatalog } from "../catalog/types.js";
+import { recommend, baselineFor, computeAdvisory } from "./engine.js";
 import { providerIdentity } from "./provider-names.js";
 export const STALE_MS = 60 * 60 * 1000;
 function normalizeAdvisory(adv) {
@@ -12,6 +14,9 @@ function normalizeAdvisory(adv) {
         remaining: Number.isFinite(adv.remaining) ? adv.remaining : 0,
         idealRate: Number.isFinite(adv.idealRate) ? adv.idealRate : 0,
         burnRate: adv.burnRate !== null && Number.isFinite(adv.burnRate) ? adv.burnRate : null,
+        recentRate: adv.recentRate != null && Number.isFinite(adv.recentRate) ? adv.recentRate : null,
+        baselineRate: adv.baselineRate != null && Number.isFinite(adv.baselineRate) ? adv.baselineRate : null,
+        aheadOfElapsed: typeof adv.aheadOfElapsed === "boolean" ? adv.aheadOfElapsed : null,
         avgPace: adv.avgPace !== null && Number.isFinite(adv.avgPace) ? adv.avgPace : null,
         daysToExhaust: adv.daysToExhaust !== null && Number.isFinite(adv.daysToExhaust) ? adv.daysToExhaust : null,
         wastePct: adv.wastePct !== null && Number.isFinite(adv.wastePct) ? adv.wastePct : null,
@@ -37,9 +42,11 @@ export function buildSnapshot(db, opts) {
     }
     const unionIds = Array.from(new Set([...opts.enabledProviders, ...storedIds])).sort((a, b) => a.localeCompare(b));
     const burnRates = getBurnRates(db, asOfMs);
+    const history = getHistoryBaseline(db);
+    const catalogMap = getCatalogs(db);
     const providerSnapshots = [];
     const eligibleQuotas = [];
-    const burnSubset = new Map();
+    const paceByProvider = new Map();
     const allValidAdvisories = [];
     for (const id of unionIds) {
         const quota = quotaMap.get(id) ?? null;
@@ -103,22 +110,15 @@ export function buildSnapshot(db, opts) {
         // Reporting requires a quota row with no stale, reset-passed, invalid, or failed flags.
         // Offline (runtime.available=false) forces reporting=false for stale rows.
         const reporting = quota !== null && exclusionReason === null;
-        // Advisory computation
+        // Advisory computation: the engine blends recent toward the history
+        // baseline internally; this loop is the single place both inputs form.
         let rawAdvisory = null;
+        let pace = null;
         if (quota !== null && !isInvalid) {
-            const recentBurn = burnRates.get(id);
-            if (recentBurn !== undefined) {
-                rawAdvisory = computeAdvisory(quota, recentBurn, now, "recent");
-            }
-            else {
-                const avg = averagePace(quota, now);
-                if (avg !== null) {
-                    rawAdvisory = computeAdvisory(quota, avg, now, "window-average");
-                }
-                else {
-                    rawAdvisory = computeAdvisory(quota, null, now, "unknown");
-                }
-            }
+            const recent = burnRates.get(id) ?? null;
+            const baseline = baselineFor(history.get(id) ?? null, quota, now);
+            pace = { recent, baseline };
+            rawAdvisory = computeAdvisory(quota, recent, baseline, now);
         }
         const advisory = normalizeAdvisory(rawAdvisory);
         // Controlled evidence vocabulary
@@ -137,10 +137,10 @@ export function buildSnapshot(db, opts) {
         }
         if (enabled && quota !== null && exclusionReason === null) {
             eligibleQuotas.push(quota);
-            if (burnRates.has(id)) {
-                burnSubset.set(id, burnRates.get(id));
-            }
+            if (pace)
+                paceByProvider.set(id, pace);
         }
+        const catalog = catalogMap.get(id) ?? emptyCatalog();
         providerSnapshots.push({
             id,
             ...providerIdentity(id, opts.providerNames),
@@ -155,6 +155,8 @@ export function buildSnapshot(db, opts) {
             evidence,
             exclusionReason,
             advisory,
+            lastCloses: getWindowCloses(db, id, 4),
+            catalog,
         });
     }
     // 2. Recommendation: ranked from eligible providers only; advisories cover all valid rows
@@ -166,12 +168,15 @@ export function buildSnapshot(db, opts) {
             wastePct: null,
             idealRate: 0,
             recommendationBasis: "none",
+            models: [],
+            catalogStatus: "unfetched",
+            catalogFetchedAt: null,
             alternatives: [],
             advisories: allValidAdvisories,
         };
     }
     else {
-        const rec = recommend(eligibleQuotas, "any", burnSubset, now);
+        const rec = recommend(eligibleQuotas, "any", paceByProvider, now);
         const chosenProvider = eligibleQuotas.find((q) => q.provider === rec.use);
         let reason = rec.reason;
         if (chosenProvider?.resetsAtEstimated) {
@@ -185,11 +190,20 @@ export function buildSnapshot(db, opts) {
                 reason = `${reason} (estimated)`;
             }
         }
+        const pickCatalog = catalogMap.get(rec.use) ?? emptyCatalog();
+        const alternativesWithCatalog = (rec.alternatives ?? []).map((alt) => ({
+            ...alt,
+            catalog: catalogMap.get(alt.provider) ?? emptyCatalog(),
+        }));
         recommendation = {
             ...rec,
             reason,
             wastePct: rec.wastePct !== null && Number.isFinite(rec.wastePct) ? rec.wastePct : null,
             idealRate: Number.isFinite(rec.idealRate) ? rec.idealRate : 0,
+            models: pickCatalog.listed,
+            catalogStatus: rec.use === "none" ? "unfetched" : pickCatalog.status,
+            catalogFetchedAt: pickCatalog.fetchedAt,
+            alternatives: alternativesWithCatalog,
             advisories: allValidAdvisories,
         };
     }
@@ -214,6 +228,8 @@ export function projectQuotasResponse(s) {
         ageMs: p.ageMs,
         evidence: p.evidence,
         exclusionReason: p.exclusionReason,
+        lastCloses: p.lastCloses,
+        catalog: p.catalog,
     }));
 }
 export function projectRecommendationResponse(s, _task = "any") {

package/dist/advisory/types.d.ts

@@ -1,5 +1,6 @@
 import type { Quota } from "../adapters/types.js";
 import type { AttemptRecord } from "../store/attempts.js";
+import type { CatalogStatus, CatalogView, ListedModel } from "../catalog/types.js";
 /**
  * Minimum data span before a pace annualizes, in days. Under 6h a single
  * 1% quantum annualizes to 4%/day of noise — enough to fabricate Cap-risk
@@ -7,8 +8,11 @@ import type { AttemptRecord } from "../store/attempts.js";
  * (elapsed time) and the recent rate (reading span) alike.
  */
 export declare const MIN_PACE_SPAN_DAYS: number;
+export declare const BLEND_K = 0.5;
+export declare const RISK_MARGIN = 0.15;
+export declare const GATE_TOL = 0.1;
 export type Urgency = "burn now" | "use soon" | "slow down" | "save" | "on track";
-export type BurnStatus = "at risk" | "on track" | "unknown";
+export type BurnStatus = "at risk" | "watch" | "on track" | "unknown";
 export type PaceSource = "recent" | "window-average" | "unknown";
 export type RecommendationBasis = "known-waste" | "unknown-headroom" | "none";
 export type ExclusionReason = "not-reporting" | "stale" | "reset-passed" | "invalid" | "provider-failed" | null;
@@ -19,6 +23,9 @@ export interface Advisory {
     remaining: number;
     idealRate: number;
     burnRate: number | null;
+    recentRate?: number | null;
+    baselineRate?: number | null;
+    aheadOfElapsed?: boolean | null;
     /**
      * Window-average pace (used % ÷ days elapsed), always computed when the
      * window start is known — independent of `burnRate`, which is the forecast
@@ -39,9 +46,26 @@ export interface Recommendation {
     wastePct: number | null;
     idealRate: number;
     recommendationBasis: RecommendationBasis;
-    alternatives: any[];
+    models: ListedModel[];
+    catalogStatus: CatalogStatus;
+    catalogFetchedAt: string | null;
+    alternatives: Array<Quota & {
+        catalog: CatalogView;
+    }>;
     advisories: Advisory[];
 }
+export interface WindowClose {
+    provider: string;
+    plan: string | null;
+    usedPct: number;
+    leftoverPct: number;
+    sampledAt: string;
+    periodStart: string | null;
+    resetsAt: string | null;
+    resetsAtEstimated: boolean;
+    detectedAt: string;
+    reason: "usage-drop" | "resets-at-rolled" | "both";
+}
 export interface ProviderSnapshot {
     id: string;
     displayName: string;
@@ -60,6 +84,8 @@ export interface ProviderSnapshot {
     evidence: string[];
     exclusionReason: ExclusionReason;
     advisory: Advisory | null;
+    lastCloses: WindowClose[];
+    catalog: CatalogView;
 }
 export interface UpdateStatus {
     current: string;

package/dist/advisory/types.js

@@ -5,3 +5,6 @@
  * (elapsed time) and the recent rate (reading span) alike.
  */
 export const MIN_PACE_SPAN_DAYS = 6 / 24;
+export const BLEND_K = 0.5;
+export const RISK_MARGIN = 0.15;
+export const GATE_TOL = 0.10;

package/dist/catalog/agy.d.ts

@@ -0,0 +1,4 @@
+import type { CatalogFetcher, ListedModel } from "./types.js";
+export declare function agyBucketForModelId(id: string): "agy" | "agy:3p" | null;
+export declare function parseAgyModels(stdout: string): Record<"agy" | "agy:3p", ListedModel[]>;
+export declare const agyCatalogFetcher: CatalogFetcher;

package/dist/catalog/agy.js

@@ -0,0 +1,59 @@
+import { trackedExecFile } from "../runtime/spawn.js";
+// Pinned split rule (design §6.1): one `agy models` list covers both quota
+// buckets; the id prefix decides which. Unmatched ids are omitted from both.
+export function agyBucketForModelId(id) {
+    const s = id.trim().toLowerCase();
+    if (s.startsWith("gemini"))
+        return "agy";
+    if (s.startsWith("claude") || s.startsWith("gpt"))
+        return "agy:3p";
+    return null;
+}
+export function parseAgyModels(stdout) {
+    const out = { agy: [], "agy:3p": [] };
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        if (/^Fetching available models/i.test(t))
+            continue;
+        const tab = t.indexOf("\t");
+        const id = (tab < 0 ? t : t.slice(0, tab)).trim();
+        const displayName = (tab < 0 ? "" : t.slice(tab + 1).trim()) || id;
+        if (id)
+            rows.push({ id, displayName });
+    }
+    // Empty stdout after a successful exit is a parse failure, not an empty picker.
+    if (rows.length === 0)
+        throw new Error("agy: no model rows in `agy models` output");
+    let matched = 0;
+    for (const row of rows) {
+        const bucket = agyBucketForModelId(row.id);
+        if (!bucket)
+            continue;
+        matched++;
+        out[bucket].push(row);
+    }
+    // Rows came back but the classifier recognized none: the picker drifted.
+    if (matched === 0)
+        throw new Error("agy: no `agy models` row matched the bucket classifier");
+    return out;
+}
+const EXEC_TIMEOUT_MS = 8000;
+export const agyCatalogFetcher = {
+    id: "agy",
+    async fetch() {
+        // Per-fetch catalog-owned signal: never the usage poll's shared controller.
+        const { stdout } = await trackedExecFile("agy", "agy", ["models"], {
+            timeout: EXEC_TIMEOUT_MS,
+            signal: new AbortController().signal,
+        });
+        try {
+            return parseAgyModels(stdout);
+        }
+        catch (e) {
+            throw new Error(`agy: failed to parse \`agy models\` output: ${e?.message ?? e}`);
+        }
+    },
+};

package/dist/catalog/claude.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogFetcher, ListedModel } from "./types.js";
+export declare function parseClaudeModelSlash(jsonText: string): ListedModel[];
+export declare const claudeCatalogFetcher: CatalogFetcher;

package/dist/catalog/claude.js

@@ -0,0 +1,70 @@
+import { trackedExecFile } from "../runtime/spawn.js";
+import { claudeAdapter } from "../adapters/claude.js";
+// `Current model: `Name`` short names onto picker aliases (design §6.4).
+const CLAUDE_SHORT_NAMES = {
+    opus: "opus",
+    sonnet: "sonnet",
+    haiku: "haiku",
+    fable: "fable",
+};
+// `claude -p /model --output-format json` with no extra arg lists aliases in
+// the result text. A positive num_turns / total_cost_usd means a real model
+// turn ran (the print-mode failure mode), not the slash listing.
+export function parseClaudeModelSlash(jsonText) {
+    const data = JSON.parse(jsonText);
+    if (typeof data?.num_turns === "number" && data.num_turns > 0) {
+        throw new Error("claude: /model JSON is a model turn (num_turns > 0), not a catalog");
+    }
+    if (typeof data?.total_cost_usd === "number" && data.total_cost_usd > 0) {
+        throw new Error("claude: /model JSON is a model turn (total_cost_usd > 0), not a catalog");
+    }
+    const result = data?.result;
+    if (typeof result !== "string" || !result) {
+        throw new Error("claude: /model JSON has no result text");
+    }
+    const availIdx = result.indexOf("Available:");
+    if (availIdx < 0)
+        throw new Error("claude: /model result has no Available list");
+    let tail = result.slice(availIdx + "Available:".length);
+    const stop = tail.search(/,\s*or a full model ID/i);
+    if (stop >= 0)
+        tail = tail.slice(0, stop);
+    const ids = tail
+        .split(",")
+        .map((t) => t.trim().replace(/[.\s]+$/g, ""))
+        .filter((t) => t.length > 0 && t.toLowerCase() !== "default");
+    if (ids.length === 0)
+        throw new Error("claude: /model Available list had no usable aliases");
+    let defaultAlias = null;
+    const cur = result.match(/Current model:\s*`([^`]+)`/i);
+    if (cur) {
+        const first = cur[1].trim().split(/\s+/)[0]?.toLowerCase();
+        if (first && CLAUDE_SHORT_NAMES[first])
+            defaultAlias = CLAUDE_SHORT_NAMES[first];
+    }
+    return ids.map((id) => {
+        const entry = { id, displayName: id };
+        if (defaultAlias !== null && id === defaultAlias)
+            entry.default = true;
+        return entry;
+    });
+}
+const EXEC_TIMEOUT_MS = 8000;
+export const claudeCatalogFetcher = {
+    id: "claude",
+    async fetch() {
+        // Reuse the pinned claude path the daemon resolves (claudeAdapter.execPath).
+        const bin = claudeAdapter.execPath ?? "claude";
+        // Per-fetch catalog-owned signal: never the usage poll's shared controller.
+        const { stdout } = await trackedExecFile("claude", bin, ["-p", "/model", "--output-format", "json"], {
+            timeout: EXEC_TIMEOUT_MS,
+            signal: new AbortController().signal,
+        });
+        try {
+            return { claude: parseClaudeModelSlash(stdout) };
+        }
+        catch (e) {
+            throw new Error(`claude: failed to parse \`claude -p /model\` output: ${e?.message ?? e}`);
+        }
+    },
+};

package/dist/catalog/codex.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogFetcher, ListedModel } from "./types.js";
+export declare function parseCodexDebugModels(jsonText: string): ListedModel[];
+export declare const codexCatalogFetcher: CatalogFetcher;

package/dist/catalog/codex.js

@@ -0,0 +1,55 @@
+import { trackedExecFile } from "../runtime/spawn.js";
+// `codex debug models` (design §6.5): the dump is ~500KB of prompt templates;
+// project to id / displayName / efforts and keep `visibility === "list"` only.
+// A slug-bearing row without a string visibility means the dump's shape
+// drifted: throw (caller keeps the prior list). A well-formed all-hide dump is
+// a successful empty picker, [] rather than a throw.
+export function parseCodexDebugModels(jsonText) {
+    const data = JSON.parse(jsonText);
+    const models = data?.models;
+    if (!Array.isArray(models))
+        throw new Error("codex: debug models JSON has no models array");
+    for (const row of models) {
+        if (row && typeof row === "object" && typeof row.slug === "string" && typeof row.visibility !== "string") {
+            throw new Error(`codex: model row "${row.slug}" lacks a string visibility`);
+        }
+    }
+    const out = [];
+    for (const row of models) {
+        if (!row || typeof row !== "object" || typeof row.slug !== "string")
+            continue;
+        if (row.visibility !== "list")
+            continue;
+        const entry = {
+            id: row.slug,
+            displayName: typeof row.display_name === "string" && row.display_name ? row.display_name : row.slug,
+        };
+        if (Array.isArray(row.supported_reasoning_levels)) {
+            const efforts = row.supported_reasoning_levels
+                .map((l) => l?.effort)
+                .filter((e) => typeof e === "string");
+            if (efforts.length > 0)
+                entry.efforts = efforts;
+        }
+        out.push(entry);
+    }
+    return out;
+}
+// Larger cap than the other exec fetchers: the debug dump is a big JSON blob.
+const EXEC_TIMEOUT_MS = 12000;
+export const codexCatalogFetcher = {
+    id: "codex",
+    async fetch() {
+        // Per-fetch catalog-owned signal: never the usage poll's shared controller.
+        const { stdout } = await trackedExecFile("codex", "codex", ["debug", "models"], {
+            timeout: EXEC_TIMEOUT_MS,
+            signal: new AbortController().signal,
+        });
+        try {
+            return { codex: parseCodexDebugModels(stdout) };
+        }
+        catch (e) {
+            throw new Error(`codex: failed to parse \`codex debug models\` output: ${e?.message ?? e}`);
+        }
+    },
+};

package/dist/catalog/grok.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogFetcher, ListedModel } from "./types.js";
+export declare function parseGrokModels(stdout: string): ListedModel[];
+export declare const grokCatalogFetcher: CatalogFetcher;