@gajae-code/coding-agent 0.14.2 → 0.15.0

package/dist/types/autoresearch/prompts.d.ts

@@ -0,0 +1,51 @@
+export interface AutoresearchSetupPromptInput {
+    baseSystemPrompt: string;
+    goal: string;
+    workingDir: string;
+    branch: string | null;
+    /** Dirty-worktree / no-repo degradation warning shown during Phase 1. */
+    baselineWarning?: string | null;
+}
+/** Phase 1: harness-setup prompt. */
+export declare function renderAutoresearchSetupPrompt(input: AutoresearchSetupPromptInput): string;
+export interface AutoresearchRecentRunPrompt {
+    run_number: number;
+    status: string;
+    metric_display: string;
+    description: string;
+    has_asi_summary: boolean;
+    asi_summary: string;
+    has_deviations: boolean;
+    deviations: string;
+    justified: boolean;
+    flagged: boolean;
+    flagged_reason: string;
+}
+export interface AutoresearchIteratePromptInput {
+    baseSystemPrompt: string;
+    goal: string;
+    workingDir: string;
+    branch: string | null;
+    baselineCommit: string | null;
+    metricName: string;
+    metricUnit: string;
+    notes: string;
+    currentSegment: number;
+    currentSegmentRunCount: number;
+    baselineMetric: number | null;
+    bestMetric: number | null;
+    bestRunNumber: number | null;
+    recentRuns: AutoresearchRecentRunPrompt[];
+    unjustifiedRuns: Array<{
+        run_number: number;
+        paths: string;
+    }>;
+    pendingRun: {
+        runNumber: number;
+        command: string;
+        parsedPrimary: number | null;
+        passed: boolean;
+    } | null;
+}
+/** Phase 2: iterate-loop prompt. */
+export declare function renderAutoresearchIteratePrompt(input: AutoresearchIteratePromptInput): string;

package/dist/types/autoresearch/runs.d.ts

@@ -0,0 +1,173 @@
+import type { ASIData, ExperimentStatus, MetricDef, MetricDirection, NumericMetricMap } from "./types";
+export type { ASIData, ExperimentStatus, MetricDirection, NumericMetricMap };
+export interface AutoresearchExperimentConfig {
+    name: string;
+    goal: string | null;
+    primaryMetric: string;
+    metricUnit: string;
+    direction: MetricDirection;
+    preferredCommand: string | null;
+    branch: string | null;
+    baselineCommit: string | null;
+    currentSegment: number;
+    maxIterations: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    secondaryMetrics: string[];
+    notes: string;
+    createdAt: number;
+    closedAt: number | null;
+}
+export interface AutoresearchRunRecord {
+    runId: string;
+    runNumber: number;
+    segment: number;
+    command: string;
+    startedAt: number;
+    completedAt: number | null;
+    durationMs: number | null;
+    exitCode: number | null;
+    timedOut: boolean;
+    status: ExperimentStatus | null;
+    description: string | null;
+    metric: number | null;
+    metrics: NumericMetricMap;
+    asi: ASIData | null;
+    commitHash: string | null;
+    confidence: number | null;
+    preRunDirtyPaths: string[];
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+    loggedAt: number | null;
+    abandonedAt: number | null;
+}
+export interface AutoresearchRunsPaths {
+    dir: string;
+    runsPath: string;
+    configPath: string;
+}
+export declare function autoresearchRunsPaths(cwd: string, sessionId?: string | null): AutoresearchRunsPaths;
+export declare function createAutoresearchExperimentConfig(input: {
+    name: string;
+    goal?: string | null;
+    primaryMetric: string;
+    metricUnit?: string;
+    direction?: MetricDirection;
+    preferredCommand?: string | null;
+    branch?: string | null;
+    baselineCommit?: string | null;
+    maxIterations?: number | null;
+    scopePaths?: string[];
+    offLimits?: string[];
+    constraints?: string[];
+    secondaryMetrics?: string[];
+    notes?: string;
+    createdAt?: number;
+}): AutoresearchExperimentConfig;
+/**
+ * Session-scoped JSONL run store. Reads are served from a cached in-memory
+ * snapshot; every mutation routes through the sanctioned `.gjc/**` state-writer
+ * primitives (append for new runs, locked rewrite for updates).
+ */
+export declare class AutoresearchRunsStore {
+    #private;
+    private constructor();
+    static open(cwd: string, sessionId?: string | null): Promise<AutoresearchRunsStore>;
+    get paths(): AutoresearchRunsPaths;
+    get config(): AutoresearchExperimentConfig | null;
+    get runs(): AutoresearchRunRecord[];
+    /** Persist the experiment configuration (first write creates the file). */
+    saveConfig(config: AutoresearchExperimentConfig): Promise<void>;
+    /** Seed the in-memory config without persisting (mission-derived defaults). */
+    setInMemoryConfig(config: AutoresearchExperimentConfig): void;
+    /** Start a run: append its record line and return the created record. */
+    startRun(input: {
+        segment?: number;
+        command: string;
+        preRunDirtyPaths?: string[];
+        startedAt?: number;
+    }): Promise<AutoresearchRunRecord>;
+    /** Mark a completed run (exit code, duration, parsed metrics/ASI). */
+    completeRun(runId: string, patch: Partial<AutoresearchRunRecord>): Promise<AutoresearchRunRecord>;
+    /** Log a run: final status, description, metric, ASI, paths, confidence. */
+    logRun(runId: string, patch: Partial<AutoresearchRunRecord>): Promise<AutoresearchRunRecord>;
+    /** Flag a run as suspect; flagged runs are excluded from baseline/best math. */
+    flagRun(runId: string, reason: string): Promise<AutoresearchRunRecord>;
+    updateRunConfidence(runId: string, confidence: number | null): Promise<AutoresearchRunRecord>;
+    /** Abandon every pending run; returns how many were abandoned. */
+    abandonPendingRuns(): Promise<number>;
+    /** Most recent pending (started, unlogged, unabandoned) run, or null. */
+    getPendingRun(): AutoresearchRunRecord | null;
+    listRuns(): AutoresearchRunRecord[];
+    listLoggedRuns(): AutoresearchRunRecord[];
+}
+/**
+ * Minimal structural shape the math operates on; both persisted run records
+ * and rebuilt experiment results satisfy it.
+ */
+export interface BaselineCandidate {
+    segment: number;
+    status: ExperimentStatus | null;
+    metric: number | null;
+    metrics: NumericMetricMap;
+    flagged: boolean;
+    runNumber: number;
+}
+export declare function currentResults(results: readonly BaselineCandidate[], segment: number): BaselineCandidate[];
+/** First kept, unflagged run in the segment — the baseline. */
+export declare function findBaselineResult(results: readonly BaselineCandidate[], segment: number): BaselineCandidate | null;
+export declare function findBaselineMetric(results: readonly BaselineCandidate[], segment: number): number | null;
+/** Best kept, unflagged metric in the segment, honoring direction. */
+export declare function findBestKeptMetric(results: readonly BaselineCandidate[], segment: number, direction: MetricDirection): number | null;
+export declare function findBaselineRunNumber(results: readonly BaselineCandidate[], segment: number): number | null;
+/** Baseline secondary-metric values, filling gaps from other unflagged runs. */
+export declare function findBaselineSecondary(results: readonly BaselineCandidate[], segment: number, knownMetrics: MetricDef[]): NumericMetricMap;
+export declare function sortedMedian(values: number[]): number;
+/**
+ * Confidence score: how many multiples of the observed noise floor (median
+ * absolute deviation) separate the best kept metric from the baseline. Null
+ * when there are too few runs, no baseline, or no measurable spread.
+ */
+export declare function computeConfidence(results: readonly BaselineCandidate[], segment: number, direction: MetricDirection): number | null;
+export interface AutoresearchExperimentResult {
+    runNumber: number;
+    commit: string;
+    metric: number | null;
+    metrics: NumericMetricMap;
+    status: ExperimentStatus;
+    description: string;
+    timestamp: number;
+    segment: number;
+    confidence: number | null;
+    asi?: ASIData;
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+}
+export interface AutoresearchExperimentState {
+    results: AutoresearchExperimentResult[];
+    bestMetric: number | null;
+    bestDirection: MetricDirection;
+    metricName: string;
+    metricUnit: string;
+    secondaryMetrics: MetricDef[];
+    name: string | null;
+    goal: string | null;
+    currentSegment: number;
+    maxExperiments: number | null;
+    confidence: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    notes: string;
+    branch: string | null;
+    baselineCommit: string | null;
+}
+/** Rebuild the experiment state view from the persisted config + logged runs. */
+export declare function buildAutoresearchExperimentState(config: AutoresearchExperimentConfig, loggedRuns: AutoresearchRunRecord[]): AutoresearchExperimentState;

package/dist/types/autoresearch/types.d.ts

@@ -1,7 +1,12 @@
-import type { AgentToolResult } from "@gajae-code/agent-core";
-import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
-import type { SessionEntry } from "../session/session-manager";
-import type { TruncationResult } from "../session/streaming-output";
+/**
+ * Shared types for the rebuilt autoresearch capability modules.
+ *
+ * These mirror the deleted extension's `types.ts` surface (metrics, ASI,
+ * experiment statuses) without the extension-only runtime types (dashboards,
+ * tool factories, session entries). The mission/verdict/ledger types live in
+ * `gjc-runtime/autoresearch-runtime.ts`; run storage and dashboard models live
+ * in `runs.ts` / `dashboard.ts`.
+ */
 export type MetricDirection = "lower" | "higher";
 export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
 export type ASIValue = string | number | boolean | null | ASIValue[] | {
@@ -17,138 +22,3 @@ export interface MetricDef {
     name: string;
     unit: string;
 }
-export interface ExperimentResult {
-    runNumber: number | null;
-    commit: string;
-    metric: number;
-    metrics: NumericMetricMap;
-    status: ExperimentStatus;
-    description: string;
-    timestamp: number;
-    segment: number;
-    confidence: number | null;
-    asi?: ASIData;
-    modifiedPaths: string[];
-    scopeDeviations: string[];
-    justification: string | null;
-    flagged: boolean;
-    flaggedReason: string | null;
-}
-export interface ExperimentState {
-    results: ExperimentResult[];
-    bestMetric: number | null;
-    bestDirection: MetricDirection;
-    metricName: string;
-    metricUnit: string;
-    secondaryMetrics: MetricDef[];
-    name: string | null;
-    goal: string | null;
-    currentSegment: number;
-    maxExperiments: number | null;
-    confidence: number | null;
-    scopePaths: string[];
-    offLimits: string[];
-    constraints: string[];
-    notes: string;
-    branch: string | null;
-    baselineCommit: string | null;
-    sessionId: number | null;
-}
-export interface RunExperimentProgressDetails {
-    phase: "running";
-    elapsed: string;
-    truncation?: TruncationResult;
-    fullOutputPath?: string;
-    runDirectory?: string;
-}
-export interface RunDetails {
-    runNumber: number;
-    runDirectory: string;
-    benchmarkLogPath: string;
-    command: string;
-    exitCode: number | null;
-    durationSeconds: number;
-    passed: boolean;
-    crashed: boolean;
-    timedOut: boolean;
-    tailOutput: string;
-    parsedMetrics: NumericMetricMap | null;
-    parsedPrimary: number | null;
-    parsedAsi: ASIData | null;
-    metricName: string;
-    metricUnit: string;
-    preRunDirtyPaths: string[];
-    abandonedPriorRun: number | null;
-    truncation?: TruncationResult;
-    fullOutputPath?: string;
-}
-export interface LogDetails {
-    experiment: ExperimentResult;
-    state: ExperimentState;
-    wallClockSeconds: number | null;
-    scopeDeviations: string[];
-    justification: string | null;
-    flaggedRuns: Array<{
-        runId: number;
-        reason: string;
-    }>;
-}
-export interface PendingRunSummary {
-    command: string;
-    durationSeconds: number | null;
-    parsedAsi: ASIData | null;
-    parsedMetrics: NumericMetricMap | null;
-    parsedPrimary: number | null;
-    passed: boolean;
-    preRunDirtyPaths: string[];
-    runDirectory: string;
-    runNumber: number;
-    exitCode: number | null;
-    timedOut: boolean;
-}
-export interface RunningExperiment {
-    startedAt: number;
-    command: string;
-    runDirectory: string;
-    runNumber: number;
-}
-export interface AutoresearchRuntime {
-    autoresearchMode: boolean;
-    autoResumeArmed: boolean;
-    dashboardExpanded: boolean;
-    lastAutoResumePendingRunNumber: number | null;
-    lastRunDuration: number | null;
-    lastRunAsi: ASIData | null;
-    lastRunArtifactDir: string | null;
-    lastRunNumber: number | null;
-    lastRunSummary: PendingRunSummary | null;
-    runningExperiment: RunningExperiment | null;
-    state: ExperimentState;
-    goal: string | null;
-}
-export interface AutoresearchControlEntryData {
-    mode: "on" | "off" | "clear";
-    goal?: string;
-}
-export interface ReconstructedControlState {
-    autoresearchMode: boolean;
-    goal: string | null;
-    lastMode: AutoresearchControlEntryData["mode"] | null;
-}
-export interface RuntimeStore {
-    clear(sessionKey: string): void;
-    ensure(sessionKey: string): AutoresearchRuntime;
-}
-export interface DashboardController {
-    clear(ctx: ExtensionContext): void;
-    requestRender(): void;
-    showOverlay(ctx: ExtensionContext, runtime: AutoresearchRuntime): Promise<void>;
-    updateWidget(ctx: ExtensionContext, runtime: AutoresearchRuntime): void;
-}
-export interface AutoresearchToolFactoryOptions {
-    dashboard: DashboardController;
-    getRuntime(ctx: ExtensionContext): AutoresearchRuntime;
-    pi: ExtensionAPI;
-}
-export type AutoresearchToolResult<TDetails> = AgentToolResult<TDetails>;
-export type SessionEntries = SessionEntry[];

package/dist/types/capability/types.d.ts

@@ -14,6 +14,20 @@ export interface LoadContext {
     cwd: string;
     /** User home directory */
     home: string;
+    /**
+     * GJC's user-scope config directory: the resolved agent directory
+     * (`getAgentDir()`), which `--agent-dir`, `GJC_CODING_AGENT_DIR` and
+     * `setAgentDir()` redirect away from `<home>/.gjc/agent`. `loadCapability`
+     * always sets it; ad-hoc contexts built for path scanning may omit it, and
+     * consumers then fall back to the same process-wide `getAgentDir()`.
+     *
+     * A native surface whose write path targets the agent directory resolves its
+     * user scope from here, or discovery reads a different file than the one the
+     * writer produced: `gjc mcp add` (user scope) writes `getMCPConfigPath("user")`
+     * under this directory. Surfaces whose writers are home-relative (skills) keep
+     * resolving from `home`.
+     */
+    userAgentDir?: string;
     /** Git repository root (directory containing .git), or null if not in a repo */
     repoRoot: string | null;
 }
@@ -59,6 +73,12 @@ export interface LoadOptions {
     excludeProviders?: string[];
     /** Custom cwd. Default: getProjectDir() */
     cwd?: string;
+    /**
+     * Agent directory backing `LoadContext.userAgentDir`. Default: getAgentDir().
+     * Set it when loading for a session whose agent directory differs from the
+     * process-wide one (`createAgentSession({ agentDir })`).
+     */
+    agentDir?: string;
     /** Include items even if they fail validation. Default: false */
     includeInvalid?: boolean;
     /** Include items disabled via settings. Default: false */

package/dist/types/cli/accounts-cli.d.ts

@@ -15,5 +15,6 @@ export interface AccountsCommandArgs {
 declare class AccountsCommandError extends Error {
     constructor(message: string);
 }
+export declare function toAccountsCommandError(error: unknown): AccountsCommandError | undefined;
 export declare function runAccountsCommand(cmd: AccountsCommandArgs): Promise<void>;
 export { AccountsCommandError };

package/dist/types/commands/{rlm.d.ts → autoresearch.d.ts}

@@ -1,10 +1,8 @@
-/**
- * `gjc rlm` — opt-in Jupyter-style research session with a persistent Python kernel.
- */
 import { Command } from "@gajae-code/utils/cli";
-export default class Rlm extends Command {
+export default class Autoresearch extends Command {
     static description: string;
     static strict: boolean;
     static examples: string[];
+    static delegateHelp: boolean;
     run(): Promise<void>;
 }

package/dist/types/config/autorouting-contract.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Dependency-free autorouting vocabulary and settings validators.
+ *
+ * This module deliberately does not import Settings, task code, or model
+ * profiles.  It is the shared contract used by settings and (later) routing
+ * policy code.
+ */
+export declare const AUTOROUTING_TIERS: readonly ["fast", "balanced", "strong"];
+export type AutoroutingTier = (typeof AUTOROUTING_TIERS)[number];
+export declare const DEFAULT_AUTOROUTING_TIER: AutoroutingTier;
+/**
+ * The single wording for "autorouting is switched on but cannot route".
+ *
+ * One constant so every delivery surface (interactive, print, and the SDK/ACP
+ * host) reports the identical sentence and cannot drift apart. Bounded and free
+ * of interpolation so it is always safe to render.
+ */
+export declare const AUTOROUTING_INACTIVE_WARNING = "Autorouting is enabled but has no usable tier chains; Task items fall back to manual model resolution. Run /routing to inspect, or /model \u2192 smart routing to generate tiers.";
+/** The normalized tier map consumed by routing policy. */
+export type TierMap = Partial<Record<AutoroutingTier, string[]>>;
+/** The permissive input shape accepted by the settings surface. */
+export type AutoroutingTierMapInput = Partial<Record<AutoroutingTier, string | string[]>>;
+export type AutoroutingSetup = {
+    schema: 1;
+    providers: string[];
+    models?: string[];
+};
+/** Fingerprints describing the generated autorouting declaration and materialized tiers. */
+export type AutoroutingProvenance = {
+    schema: 1;
+    source: {
+        catalogFingerprint: string;
+        mapFingerprint: string;
+        generatorVersion: number;
+    };
+    declarationFingerprint: string;
+    tiersFingerprint: string;
+};
+/** Hard upper bound shared with the routing-evidence invariant in task/types.ts. */
+export declare const AUTOROUTING_SELECTOR_MAX_LENGTH = 256;
+/** The exact selector grammar published by the generated config schema. */
+export declare const AUTOROUTING_SELECTOR_PATTERN = "^[^/\\s*?\\[\\x00-\\x1F\\x7F-\\x9F\\u2028\\u2029]+\\/[^\\s*?\\[\\x00-\\x1F\\x7F-\\x9F\\u2028\\u2029]+(?::(?:minimal|low|medium|high|xhigh))?$";
+export declare const AUTOROUTING_SELECTOR_DESCRIPTION = "provider/modelId with an optional valid thinking suffix (:minimal|low|medium|high|xhigh), no globs, no bare model ids, no pi/<role> role aliases.";
+export type AutoroutingReasonCode = "tier_unmatched" | "tier_missing_in_map" | "config_invalid" | "map_absent" | "selector_not_provider_qualified" | "auth_substituted" | "assistant_model_mismatch" | "provider_disabled" | "snapshot_missing" | "credential_unavailable" | "preflight_spawn_failed" | "preflight_exhausted";
+export type AutoroutingLocalIssue = {
+    path: string;
+    code: AutoroutingReasonCode;
+    /** Alias retained for callers that describe diagnostics as reasons. */
+    reason: AutoroutingReasonCode;
+    detail: string;
+};
+export type AutoroutingEffectiveIssue = {
+    code: Extract<AutoroutingReasonCode, "config_invalid" | "map_absent">;
+    /** Alias retained for callers that describe diagnostics as reasons. */
+    reason: Extract<AutoroutingReasonCode, "config_invalid" | "map_absent">;
+    detail: string;
+};
+export type AutoroutingEffective = {
+    active: true;
+    map: TierMap;
+} | {
+    active: false;
+    issue?: AutoroutingEffectiveIssue;
+};
+/**
+ * Validate one provider-qualified selector.  A selector has one provider
+ * segment, a non-empty model remainder, and may carry one supported thinking
+ * suffix.  Model ids may themselves contain slashes; the provider is always
+ * the segment before the first slash.
+ */
+export declare function isValidAutoroutingSelector(value: unknown): value is string;
+export declare function normalizeTierMap(value: unknown): TierMap;
+/** True when at least one known tier contains one grammatically valid selector. */
+export declare function isMeaningfulTierMap(value: unknown): value is TierMap;
+/** Validate the typed auto-setup declaration without consulting the model catalog. */
+export declare function validateAutoroutingSetup(value: unknown): AutoroutingLocalIssue[];
+/** Validate generated-tier provenance and its source identity. */
+export declare function validateAutoroutingProvenance(value: unknown): AutoroutingLocalIssue[];
+/** Validate only local types, keys, and selector grammar for one source layer. */
+export declare function validateAutoroutingLocal(fragment: unknown): AutoroutingLocalIssue[];
+export type AutoroutingProvenanceState = {
+    staleMap: boolean;
+    staleCatalog: boolean;
+    handEdited: boolean;
+};
+/** Compare recorded provenance with the current catalog/map/tier materialization. */
+export declare function evaluateAutoroutingProvenanceState(provenance: AutoroutingProvenance | undefined, current: {
+    catalogFingerprint: string;
+    mapFingerprint: string;
+    tiers: unknown;
+}): AutoroutingProvenanceState;
+/** Compare a recorded tier fingerprint with the current raw tier map. */
+export declare function matchesRecordedTiersFingerprint(provenance: AutoroutingProvenance | undefined, tiers: unknown): boolean;
+/** Advisory comparison between a recorded declaration and the current provider priority. */
+export type AutoroutingProviderOrderHint = {
+    /** The declaration lists the same providers in a different relative order. */
+    reordered: boolean;
+    /** Declared providers that the current catalog no longer offers, in declaration order. */
+    missing: string[];
+};
+/**
+ * Compare a recorded `setup.providers` declaration against the current provider
+ * priority, for an advisory panel hint only.
+ *
+ * Pure string comparison over two arrays, normalized exactly the way provider
+ * selection normalizes ids (trim + lowercase). It deliberately never reaches
+ * provenance, effective state, routing, preflight, or evidence: a changed priority
+ * is a new suggestion, not proof that persisted tiers went stale.
+ */
+export declare function autoroutingProviderOrderHint(setupProviders: readonly string[], currentOrder: readonly string[]): AutoroutingProviderOrderHint;
+export type AutoroutingSettingsBatchPatch = {
+    path: "task.autorouting.tiers";
+    op: "set";
+    value: TierMap;
+} | {
+    path: "task.autorouting.setup";
+    op: "set";
+    value: AutoroutingSetup;
+} | {
+    path: "task.autorouting.provenance";
+    op: "set";
+    value: AutoroutingProvenance;
+} | {
+    path: "task.autorouting.tiers" | "task.autorouting.setup" | "task.autorouting.provenance";
+    op: "unset";
+};
+/** Build the one atomic settings batch used by autorouting Apply/Refresh or Clear. */
+export declare function buildAutoroutingSettingsBatch(input: {
+    tiers: TierMap;
+    setup: AutoroutingSetup;
+    provenance: AutoroutingProvenance;
+} | {
+    clear: true;
+}): readonly AutoroutingSettingsBatchPatch[];
+/** Convenience aliases for controller intents that all use one atomic batch. */
+export declare const buildAutoroutingApplyPatches: typeof buildAutoroutingSettingsBatch;
+export declare const buildAutoroutingRefreshPatches: typeof buildAutoroutingSettingsBatch;
+export declare const buildAutoroutingClearPatches: () => readonly AutoroutingSettingsBatchPatch[];
+/** Build the separate single-key enabled toggle mutation. */
+export declare function buildAutoroutingEnabledPatch(enabled: boolean): {
+    path: "task.autorouting.enabled";
+    op: "set";
+    value: boolean;
+};
+/** Validate effective enablement and map cross-field semantics. */
+export declare function validateAutoroutingEffective(fragment: unknown): AutoroutingEffective;

package/dist/types/config/autorouting-generator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pure autorouting chain materialization.
+ *
+ * The generator consumes an explicit setup, a curation map, and a complete
+ * model-registry snapshot. It never reads credentials, the clock, network
+ * state, or discovery availability.
+ */
+import type { Api, Model } from "@gajae-code/ai/core";
+import { type AutoroutingSetup, type TierMap } from "./autorouting-contract";
+import { type AutoroutingCuratedTierMap, type CuratedTierLabels } from "./autorouting-tier-map";
+export type { AutoroutingSetup } from "./autorouting-contract";
+export { canonicalJsonBytes } from "./autorouting-tier-map";
+export declare const AUTOROUTING_GENERATOR_VERSION = 1;
+export declare const GENERATOR_VERSION = 1;
+export type AutoroutingGeneratorMap = AutoroutingCuratedTierMap | CuratedTierLabels | {
+    labels: CuratedTierLabels;
+    skips?: Record<`${string}/${string}`, {
+        rationale: string;
+        baseline?: true;
+    }>;
+    skipList?: Record<`${string}/${string}`, {
+        rationale: string;
+        baseline?: true;
+    }>;
+    version: number;
+};
+export type AutoroutingCuratedMap = AutoroutingGeneratorMap;
+export type AutoroutingSourceIdentity = {
+    catalogFingerprint: string;
+    mapFingerprint: string;
+    generatorVersion: number;
+};
+export type GeneratedTierChains = {
+    tiers: TierMap;
+    declarationFingerprint: string;
+    tiersFingerprint: string;
+    sourceIdentity: AutoroutingSourceIdentity;
+};
+/** Generate deterministic fast/balanced/strong fallback chains. */
+export declare function generateTierChains(setup: AutoroutingSetup, curatedMap: AutoroutingGeneratorMap | undefined, catalog: readonly Model<Api>[]): GeneratedTierChains;