@wrongstack/core 0.284.1 → 0.285.0

package/dist/kernel/pipeline.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Pipeline — Koa-style middleware chain with named middleware
+ * and position-aware insertion. Generic over input type T.
+ */
+export type NextFn<T> = (value: T) => Promise<T>;
+export type MiddlewareHandler<T> = (value: T, next: NextFn<T>) => Promise<T>;
+/**
+ * Called when a middleware crashes (throws or rejects). Used by the
+ * Pipeline's error boundary to log the offender without aborting the run.
+ *
+ * Return `'rethrow'` to propagate the error (default for core middleware),
+ * or `'swallow'` to abort descent into the crashing middleware: its caller's
+ * `await next()` resolves with the value that was about to flow into the
+ * crashed middleware. The crashed middleware AND every middleware after it in
+ * the chain are skipped (they never run); UPSTREAM middleware, already paused
+ * at their own `await next()`, resume their post-`next()` work normally. It
+ * does NOT continue at the next sibling middleware. Plugin middleware should
+ * usually be swallowed so one bad plugin can't kill an agent run.
+ */
+export type PipelineErrorPolicy = 'rethrow' | 'swallow';
+export interface PipelineErrorEvent {
+    middleware: string;
+    owner?: string | undefined;
+    err: unknown;
+}
+export type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
+export interface Middleware<T> {
+    name: string;
+    handler: MiddlewareHandler<T>;
+    owner?: string | undefined;
+}
+export interface PipelineOptions {
+    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
+    optional?: boolean | undefined;
+}
+/**
+ * Read-only view of a pipeline. Returned to consumers (plugins, hooks)
+ * so they can inspect but not mutate the chain.
+ */
+export interface ReadonlyPipeline<T> {
+    readonly size: number;
+    list(): readonly string[];
+    run(input: T): Promise<T>;
+}
+export declare class Pipeline<T> {
+    private readonly chain;
+    private errorHandler?;
+    /**
+     * Optional operational logger. When set, the `swallow` error-boundary path
+     * emits a structured warning so a swallowed middleware crash is never
+     * completely silent (P2 #7, before-release.md). Without a logger, the
+     * swallow path still works but the crash is invisible — host code should
+     * always wire one.
+     */
+    private logger?;
+    /**
+     * Install an error boundary. When a middleware throws or rejects, the
+     * handler is called and decides whether to swallow (continue with the
+     * pre-handler value) or rethrow. Without a handler, errors propagate.
+     *
+     * Wire one per pipeline at boot — the host CLI typically installs a
+     * single boundary that logs to the operational log and emits a
+     * `pipeline.error` event for /diag.
+     */
+    setErrorHandler(handler: PipelineErrorHandler | undefined): this;
+    /**
+     * Set the operational logger used by the swallow error-boundary path.
+     * Without this, a swallowed middleware crash is completely silent.
+     */
+    setLogger(logger: {
+        warn: (msg: string, ctx?: unknown) => void | undefined;
+    } | undefined): this;
+    use(mw: Middleware<T> | Middleware<unknown>): this;
+    prepend(mw: Middleware<T>): this;
+    /**
+     * Insert middleware at an explicit index. Out-of-range indices are clamped.
+     * Use this when insertBefore/insertAfter are insufficient (e.g. to place
+     * a middleware at a known position regardless of named targets).
+     */
+    insertAt(index: number, mw: Middleware<T>): this;
+    /**
+     * Insert mw immediately before the first occurrence of target.
+     * If called multiple times with the same target, each call inserts
+     * before the target's current position — so after insertBefore('B', X)
+     * then insertBefore('B', Y), the order is Y → X → B.
+     */
+    insertBefore(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    /**
+     * Insert mw immediately after the first occurrence of target.
+     * If called multiple times with the same target, each call inserts
+     * after the target's current position — so after insertAfter('B', X)
+     * then insertAfter('B', Y), the order is B → X → Y.
+     */
+    insertAfter(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    replace(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    remove(name: string, opts?: PipelineOptions): this;
+    list(): readonly string[];
+    size(): number;
+    /** Return a read-only view suitable for passing to plugins. */
+    asReadonly(): ReadonlyPipeline<T>;
+    run(input: T): Promise<T>;
+    private indexOf;
+    private ensureUnique;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/kernel/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/kernel/pipeline.ts"],"names":[],"mappings":"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"}

package/dist/kernel/run-controller.d.ts

@@ -0,0 +1,55 @@
+/**
+ * RunController centralises abort + cleanup for a single agent run. It
+ * wraps a single AbortController and exposes a registry of teardown
+ * hooks that fire (LIFO, exactly once) when the run aborts OR ends
+ * normally. Anyone holding the controller can:
+ *
+ *   - read `signal` to bail out cooperatively
+ *   - call `abort(reason?)` to abort the run
+ *   - call `onAbort(fn)` to register a cleanup hook
+ *   - call `dispose()` when the run ends normally — this fires the
+ *     hooks too, so cleanup runs regardless of outcome
+ *
+ * Hooks must be idempotent and synchronous-or-quick. Errors thrown
+ * inside hooks are caught and surfaced through `errorSink` (or the
+ * console as a last resort) so one bad hook can't block the others.
+ */
+export interface RunControllerOptions {
+    /** Optional parent signal — abort propagates from parent → this. */
+    parentSignal?: AbortSignal | undefined;
+    /** Receives errors thrown by cleanup hooks. Defaults to console.warn. */
+    errorSink?: (err: unknown, where: string) => void;
+}
+export declare class RunController {
+    private readonly ctrl;
+    private readonly hooks;
+    private disposed;
+    private hooksDrained;
+    private readonly errorSink;
+    constructor(opts?: RunControllerOptions);
+    get signal(): AbortSignal;
+    get aborted(): boolean;
+    abort(reason?: unknown): void;
+    /**
+     * Register a teardown hook. Returns an unsubscribe function so callers
+     * can opt out before the hook fires (e.g. when a tool finishes cleanly
+     * before abort happens).
+     *
+     * If the controller has already drained its hooks (a prior abort() or
+     * dispose() ran), the new hook is fired immediately on a best-effort
+     * basis — otherwise a hook registered after teardown would be silently
+     * dropped and the resource it cleans up would leak. The returned
+     * unsubscribe is a no-op in that case (the hook has already run). Errors
+     * from the immediate run are routed through `errorSink` like any other
+     * cleanup failure.
+     */
+    onAbort(fn: () => void | Promise<void>): () => void;
+    /**
+     * Fire cleanup hooks and tear down listeners — called when the run
+     * ends *normally* so cleanup happens regardless of outcome. Subsequent
+     * aborts become no-ops.
+     */
+    dispose(): Promise<void>;
+    private runHooks;
+}
+//# sourceMappingURL=run-controller.d.ts.map

package/dist/kernel/run-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-controller.d.ts","sourceRoot":"","sources":["../../src/kernel/run-controller.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,YAAY,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACvC,yEAAyE;IACzE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnD;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyC;IAC/D,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAElE,YAAY,IAAI,GAAE,oBAAyB,EAyC1C;IAED,IAAI,MAAM,IAAI,WAAW,CAExB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAG5B;IAED;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAgBlD;IAED;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAI7B;YAEa,QAAQ;CAuBvB"}

package/dist/kernel/tokens.d.ts

@@ -0,0 +1,53 @@
+import type { BrainArbiter } from '../coordination/brain.js';
+import type { HookRegistry } from '../hooks/registry.js';
+import type { Compactor } from '../types/compactor.js';
+import type { ConfigLoader, ConfigStore } from '../types/config.js';
+import type { ErrorHandler } from '../types/error-handler.js';
+import type { InputReader } from '../types/input-reader.js';
+import type { Logger } from '../types/logger.js';
+import type { MemoryStore } from '../types/memory.js';
+import type { ModeStore } from '../types/mode.js';
+import type { ModelsRegistry } from '../types/models-registry.js';
+import type { PathResolver } from '../types/path-resolver.js';
+import type { PermissionPolicy } from '../types/permission.js';
+import type { ProviderRunner } from '../types/provider-runner.js';
+import type { Renderer } from '../types/renderer.js';
+import type { RetryPolicy } from '../types/retry-policy.js';
+import type { SecretScrubber } from '../types/secret-scrubber.js';
+import type { SessionStore } from '../types/session.js';
+import type { PromptLoader } from '../types/prompt.js';
+import type { SkillLoader } from '../types/skill.js';
+import type { SystemPromptBuilder } from '../types/system-prompt.js';
+import type { TokenCounter } from '../types/token-counter.js';
+import type { WorktreeManager } from '../worktree/worktree-manager.js';
+import type { Token } from './container.js';
+export declare const TOKENS: {
+    readonly Logger: Token<Logger>;
+    readonly TokenCounter: Token<TokenCounter>;
+    readonly SessionStore: Token<SessionStore>;
+    readonly MemoryStore: Token<MemoryStore>;
+    readonly PermissionPolicy: Token<PermissionPolicy>;
+    readonly Compactor: Token<Compactor>;
+    readonly PathResolver: Token<PathResolver>;
+    readonly ConfigLoader: Token<ConfigLoader>;
+    readonly ConfigStore: Token<ConfigStore>;
+    readonly Renderer: Token<Renderer>;
+    readonly InputReader: Token<InputReader>;
+    readonly ErrorHandler: Token<ErrorHandler>;
+    readonly RetryPolicy: Token<RetryPolicy>;
+    readonly SkillLoader: Token<SkillLoader>;
+    readonly PromptLoader: Token<PromptLoader>;
+    readonly SystemPromptBuilder: Token<SystemPromptBuilder>;
+    readonly SecretScrubber: Token<SecretScrubber>;
+    readonly ModelsRegistry: Token<ModelsRegistry>;
+    readonly ModeStore: Token<ModeStore>;
+    /** Replaces the entire provider call layer — retry, streaming, tracing. */
+    readonly ProviderRunner: Token<ProviderRunner>;
+    /** Optional git-worktree lifecycle manager (per-phase isolation in AutoPhase). */
+    readonly WorktreeManager: Token<WorktreeManager>;
+    /** Optional global Brain arbiter for policy/decision escalation. */
+    readonly BrainArbiter: Token<BrainArbiter>;
+    /** Lifecycle hook registry (shell + in-process hooks). */
+    readonly HookRegistry: Token<HookRegistry>;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/dist/kernel/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/kernel/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAe5C,eAAO,MAAM,MAAM;aACjB,MAAM;aACN,YAAY;aACZ,YAAY;aACZ,WAAW;aACX,gBAAgB;aAChB,SAAS;aACT,YAAY;aACZ,YAAY;aACZ,WAAW;aACX,QAAQ;aACR,WAAW;aACX,YAAY;aACZ,WAAW;aACX,WAAW;aACX,YAAY;aACZ,mBAAmB;aACnB,cAAc;aACd,cAAc;aACd,SAAS;IACT,2EAA2E;aAC3E,cAAc;IACd,kFAAkF;aAClF,eAAe;IACf,oEAAoE;aACpE,YAAY;IACZ,0DAA0D;aAC1D,YAAY;CACJ,CAAC"}

package/dist/mailbox-attach.d.ts

@@ -0,0 +1,27 @@
+/**
+ * mailbox-attach — composition glue for the agent-loop mailbox checker.
+ *
+ * Lives at the src root (composition layer) because it constructs the
+ * concrete GlobalMailbox from coordination/ and hands the resulting
+ * checker to core/ — core/ itself may only depend on the Mailbox
+ * interface (architecture Rule 3, see tests/architecture/
+ * package-boundaries.test.ts).
+ *
+ * @module mailbox-attach
+ */
+import type { MailboxMessage } from './coordination/mailbox-types.js';
+import type { FleetConfig } from './types/config.js';
+import type { AgentInternals } from './core/agent-internals.js';
+export declare function attachMailboxChecker(a: AgentInternals, source?: 'cli' | 'webui'): () => Promise<MailboxMessage[]>;
+/**
+ * Fleet-pulse provider: returns a fresh "[FLEET PULSE]" digest block when
+ * (a) the read throttle allows, (b) at least one online peer exists, and
+ * (c) the peer picture actually changed since the last injected pulse.
+ * Otherwise `null`. Same best-effort posture as the mailbox checker — any
+ * failure degrades to "no pulse", never to a thrown error.
+ */
+export declare function attachFleetPulse(a: AgentInternals, cfg?: FleetConfig['pulse']): () => Promise<{
+    type: 'text';
+    text: string;
+} | null>;
+//# sourceMappingURL=mailbox-attach.d.ts.map

package/dist/mailbox-attach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox-attach.d.ts","sourceRoot":"","sources":["../src/mailbox-attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,cAAc,EACjB,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,GACvB,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,CAYjC;AAiID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,cAAc,EACjB,GAAG,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,GACzB,MAAM,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAqCtD"}

package/dist/middleware/collab-pause.d.ts

@@ -0,0 +1,73 @@
+import type { CollaborationBus, InjectedToolResult } from '../coordination/collab-bus.js';
+import type { ToolCallPipelinePayload } from '../core/agent.js';
+import type { Middleware } from '../kernel/pipeline.js';
+/**
+ * collabPauseMiddleware — gates the agent's `toolCall` pipeline on
+ * the collaboration pause signal.
+ *
+ * Position: must be installed as the *first* middleware in the
+ * `toolCall` pipeline so it runs before permission checks, retries,
+ * and the tool itself. That way the controller can halt an agent
+ * regardless of what the model is about to do.
+ *
+ * Semantics:
+ *   - When the bus is not paused: pass through (`next()`).
+ *   - When the bus is paused: await `bus.waitForResume(timeoutMs)`.
+ *     The default timeout is 60s — long enough for a human to think,
+ *     short enough that a forgotten controller doesn't pin the agent
+ *     forever. The auto-resume on timeout is logged below.
+ *
+ * Phase 3 of idea #13. Manual tool-call injection (a controller
+ * "writing" a tool result) is *not* in scope for this middleware —
+ * that requires splicing the injected result into the agent's
+ * message stream and is a follow-up.
+ */
+export interface CollabPauseMiddlewareOptions {
+    /**
+     * How long to wait for a resume before auto-resuming the bus.
+     * Defaults to 60_000 ms. Set to 0 for an unbounded wait (the
+     * caller is then responsible for cancellation via the bus itself).
+     */
+    defaultTimeoutMs?: number | undefined;
+    /**
+     * Optional logger — receives a debug line on pause entry and on
+     * timeout-driven auto-resume. Matches the `Logger` token surface
+     * so the runtime can pass its existing logger.
+     */
+    logger?: {
+        debug?: ((msg: string) => void) | undefined;
+        warn?: ((msg: string) => void) | undefined;
+    };
+}
+export declare function collabPauseMiddleware(bus: CollaborationBus, opts?: CollabPauseMiddlewareOptions): Middleware<ToolCallPipelinePayload>;
+/**
+ * collabInjectMiddleware — Phase 4 of idea #13. Splices
+ * controller-injected tool results into the toolCall pipeline.
+ *
+ * Position: should run AFTER `collabPauseMiddleware` so the
+ * controller has a chance to pause + inject before the next tool
+ * executes. Install order:
+ *   - `pipeline.toolCall.prepend(collabInject)`
+ *   - `pipeline.toolCall.prepend(collabPause)`  // runs first
+ *
+ * Semantics:
+ *   - On every tool call, the middleware asks the bus for an
+ *     injection matching `payload.toolUse.id`.
+ *   - If one is queued, the payload's `result` is overwritten with
+ *     a synthetic ToolResultBlock carrying the injected content +
+ *     `is_error` flag. The real `next()` is NOT called; downstream
+ *     middleware sees the controller's synthetic result.
+ *   - The injection is consumed once and removed from the bus.
+ *
+ * Why this shape: the agent loop's existing `tool.executed` event still
+ * fires (carrying the injected content), so the session log + observers see
+ * a normal-looking call — just with the controller's intent in the result.
+ */
+export declare function collabInjectMiddleware(bus: CollaborationBus, opts?: {
+    logger?: {
+        debug?: ((msg: string) => void) | undefined;
+        warn?: ((msg: string) => void) | undefined;
+    };
+}): Middleware<ToolCallPipelinePayload>;
+export type { InjectedToolResult };
+//# sourceMappingURL=collab-pause.d.ts.map

package/dist/middleware/collab-pause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collab-pause.d.ts","sourceRoot":"","sources":["../../src/middleware/collab-pause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC1F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC;;;;OAIG;IACH,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;QAC5C,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;KAC5C,CAAC;CACH;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,IAAI,GAAE,4BAAiC,GACtC,UAAU,CAAC,uBAAuB,CAAC,CA8BrC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,IAAI,GAAE;IACJ,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;QAC5C,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;KAC5C,CAAC;CACE,GACL,UAAU,CAAC,uBAAuB,CAAC,CAoCrC;AAID,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/models/codex-catalog.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Offline **floor** for the ChatGPT "Sign in with ChatGPT" (`openai-codex`)
+ * models, mirroring what the official Codex CLI / ChatGPT model picker shows.
+ *
+ * Source-of-truth precedence (live path wins):
+ *  1. The curated overlay `packages/cli/data/providers.json` — provider
+ *     `openai-codex` — which is **synced from raw GitHub** + cached + bundled
+ *     offline by `DefaultModelsRegistry` (overlayUrl/overlayFile). Editing that
+ *     JSON and pushing updates every client without a code release; this is the
+ *     authoritative list whenever the registry overlay is wired (the CLI path).
+ *  2. This hardcoded table — the last-resort floor used where no overlay is
+ *     available (a standalone registry without the bundled file) and by the CLI
+ *     auth-menu login flow, which needs a synchronous id list.
+ *
+ * Keep this in lockstep with the `openai-codex` block in `providers.json`; the
+ * drift-guard test `packages/cli/tests/codex-catalog-overlay-sync.test.ts`
+ * asserts they agree.
+ *
+ * Layer note: this lives in `core` (not the CLI auth-menu) so the model-list
+ * resolver can read it without `core` depending on `cli`. The CLI's
+ * `FALLBACK_CODEX_MODELS` is derived from this list.
+ */
+export interface CodexModelMeta {
+    /** The wire id sent to the backend and stored in config (e.g. `gpt-5.5`). */
+    id: string;
+    /** Human-readable display name shown in pickers. */
+    name: string;
+    /** One-line capability blurb, matching the official Codex picker copy. */
+    description: string;
+    /** The recommended / latest model — tagged "(current)" in the official UI. */
+    current?: boolean;
+}
+/**
+ * Current ChatGPT sign-in models, newest first. The first entry is the
+ * recommended default (`current`). Order is significant: callers that need a
+ * default model id use `CODEX_MODELS[0]`.
+ */
+export declare const CODEX_MODELS: ReadonlyArray<CodexModelMeta>;
+/** Look up the canonical metadata for a Codex model id, or `undefined`. */
+export declare function codexModelMeta(id: string): CodexModelMeta | undefined;
+//# sourceMappingURL=codex-catalog.d.ts.map

package/dist/models/codex-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-catalog.d.ts","sourceRoot":"","sources":["../../src/models/codex-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,cAAc;IAC7B,6EAA6E;IAC7E,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,cAAc,CAqCtD,CAAC;AAIF,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAErE"}

package/dist/models/index.d.ts

@@ -1,163 +1,8 @@
-export { C as CODEX_MODELS, a as CodexModelMeta, D as DefaultModeStore, b as DefaultModelsRegistry, c as DefaultModelsRegistryOptions, L as LLMSelector, d as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, e as classifyFamily, f as codexModelMeta, g as describeCatalogModel, l as loadProjectModes, h as loadUserModes, r as resolveProviderModelList } from '../provider-model-resolve-o2hHLs79.js';
-import { a as ModelMatrixEntry, P as ProviderConfig } from '../config-MRqn1V-u.js';
-import '../tool-BNlnIJvo.js';
-import '../selector-D8O6B_Rm.js';
-import '../mode-CZlO9iU1.js';
-
-/**
- * Model Intelligence — knowledge base of model capabilities, strengths,
- * and task-type suitability. Powers automatic agent → model routing.
- *
- * Each entry records:
- *   - Known strengths (what this model family excels at)
- *   - Known weaknesses (what it struggles with)
- *   - Best-for task types (coding, planning, security, docs, etc.)
- *   - Cost tier (budget / standard / premium)
- *
- * This is a curated dataset updated as new models release. Falls back
- * gracefully for unknown models.
- */
-interface ModelProfile {
-    /** Provider id (e.g. "anthropic", "openai"). */
-    provider: string;
-    /** Model id regex — matches partial ids for a model family. */
-    pattern: RegExp;
-    /** Human-readable model family name. */
-    family: string;
-    /** What this model is particularly good at. */
-    strengths: string[];
-    /** Known limitations. */
-    weaknesses?: string[];
-    /** Task types this model is the best choice for. Ordered by preference. */
-    bestFor: TaskType[];
-    /** Task types to avoid with this model (use a different one). */
-    avoidFor?: TaskType[];
-    /** Approximate cost tier. */
-    costTier: 'budget' | 'standard' | 'premium';
-    /** Approximate speed tier (relative to other models). */
-    speedTier: 'fast' | 'normal' | 'slow';
-    /** Minimum recommended context window. */
-    minContext?: number;
-}
-/** Task categories that map to agent roles. */
-type TaskType = 'coding' | 'planning' | 'security' | 'docs' | 'testing' | 'refactoring' | 'debugging' | 'data' | 'frontend' | 'backend' | 'review' | 'lightweight' | 'general';
-/** Known model profiles. Patterns are tried in order; first match wins. */
-declare const MODEL_PROFILES: ModelProfile[];
-/** Map task types to the agent roles that handle them. */
-declare const TASK_TO_ROLE: Record<TaskType, string[]>;
-/**
- * Infer the most likely task type from a task description and target role.
- * Uses keyword matching; falls back to the role's primary task type.
- */
-declare function inferTaskType(description: string, role?: string): TaskType;
-/**
- * Find the best matching model profile for a given provider + model id.
- */
-declare function findModelProfile(provider: string, modelId: string): ModelProfile | undefined;
-/**
- * Score a model for a given task type. Higher = better fit.
- * Returns 0-100.
- */
-declare function scoreModelForTask(profile: ModelProfile | undefined, taskType: TaskType): number;
-
-/**
- * ModelRouter — intelligent model selection for subagent delegation.
- *
- * Combines:
- *   1. User-configured model matrix (/setmodel overrides)
- *   2. Model intelligence profiles (strengths/weaknesses per model family)
- *   3. Provider availability (which models have API keys configured)
- *   4. Per-model cost tracking
- *
- * Usage:
- *   const router = new ModelRouter({ matrix, config, profiles: MODEL_PROFILES });
- *   const pick = router.pickForTask('security-scanner', 'Audit the auth module');
- *   // → { provider: 'anthropic', model: 'matched-model', reason: 'best-for security' }
- */
-
-interface ModelIntelligenceEntry {
-    provider: string;
-    pattern: RegExp;
-    family: string;
-    strengths: string[];
-    weaknesses?: string[];
-    bestFor: string[];
-    avoidFor?: string[];
-    costTier: 'budget' | 'standard' | 'premium';
-    speedTier: 'fast' | 'normal' | 'slow';
-    minContext?: number;
-}
-interface RouterConfig {
-    /** User-configured model matrix (from /setmodel). */
-    matrix?: Record<string, ModelMatrixEntry> | undefined;
-    /** Provider configurations (to check API key availability). */
-    config: {
-        provider: string;
-        model: string;
-        providers?: Record<string, ProviderConfig>;
-    };
-    /** Known model intelligence profiles. */
-    profiles?: ModelIntelligenceEntry[] | undefined;
-}
-interface ModelPick {
-    provider: string;
-    model: string;
-    /** Why this model was chosen. */
-    reason: string;
-    /** Whether this came from the user's matrix (true) or auto-detected (false). */
-    fromMatrix: boolean;
-}
-interface RouterCosts {
-    /** Cumulative cost per provider/model key. */
-    byModel: Record<string, {
-        cost: number;
-        tokens: {
-            input: number;
-            output: number;
-        };
-        calls: number;
-    }>;
-    /** Grand total. */
-    totalCost: number;
-}
-declare class ModelRouter {
-    private profiles;
-    private matrix;
-    private config;
-    private costs;
-    constructor(opts: RouterConfig);
-    /** Look up the model matrix resolution for a role (role → phase → * → leader). */
-    private resolveMatrix;
-    /** Simplified phase lookup for common roles. */
-    private roleToPhase;
-    /**
-     * Pick the best model for a task.
-     *
-     * Priority:
-     *   1. User's /setmodel matrix entry for this role (explicit override)
-     *   2. Best-matching model from intelligence profiles
-     *   3. Leader model (fallback)
-     */
-    pickForTask(role: string, description: string): ModelPick;
-    /** Infer task category from description keywords + role. */
-    private inferCategory;
-    /** Find the best available model for a task category. */
-    private findBestModel;
-    /** Check if a provider has an API key configured. */
-    private hasKey;
-    /** Get the configured model list for a provider. */
-    private getProviderModels;
-    /** Record cost for a model. */
-    recordCost(provider: string, model: string, cost: number, tokens?: {
-        input: number;
-        output: number;
-    }): void;
-    /** Get cumulative costs. */
-    getCosts(): RouterCosts;
-    /** Reset cost tracking. */
-    resetCosts(): void;
-    /** List all available providers with their best model for each task category. */
-    suggestMatrix(): Record<string, ModelPick>;
-}
-
-export { MODEL_PROFILES, type ModelIntelligenceEntry, type ModelPick, type ModelProfile, ModelRouter, type RouterConfig, type RouterCosts, TASK_TO_ROLE, type TaskType, findModelProfile, inferTaskType, scoreModelForTask };
+export { DefaultModelsRegistry, classifyFamily, type DefaultModelsRegistryOptions, } from './models-registry.js';
+export { DefaultModeStore, loadProjectModes, loadUserModes, type ModeLoaderOptions, } from './mode-store.js';
+export { LLMSelector, type LLMSelectorOptions } from './llm-selector.js';
+export { resolveProviderModelList, describeCatalogModel, type ProviderModelDescriptor, } from './provider-model-resolve.js';
+export { CODEX_MODELS, codexModelMeta, type CodexModelMeta } from './codex-catalog.js';
+export { MODEL_PROFILES, TASK_TO_ROLE, inferTaskType, findModelProfile, scoreModelForTask, type ModelProfile, type TaskType, } from './model-intelligence.js';
+export { ModelRouter, type RouterConfig, type ModelPick, type RouterCosts, type ModelIntelligenceEntry, } from './model-router.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,KAAK,4BAA4B,GAClC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,uBAAuB,GAC7B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGvF,OAAO,EACL,cAAc,EACd,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,QAAQ,GACd,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,WAAW,EACX,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,sBAAsB,GAC5B,MAAM,mBAAmB,CAAC"}