@otto-code/protocol 0.5.1 → 0.5.4

package/dist/messages.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { TerminalActivitySchema } from "./terminal-activity.js";
+import { RunSchema } from "./orchestration.js";
 import { ArtifactMetadataSchema } from "./artifacts/types.js";
 import { ArtifactListRequestSchema, ArtifactCreateRequestSchema, ArtifactUpdateRequestSchema, ArtifactRegenerateRequestSchema, ArtifactCancelRequestSchema, ArtifactDeleteRequestSchema, ArtifactStarRequestSchema, ArtifactGetContentRequestSchema, ArtifactListResponseSchema, ArtifactCreateResponseSchema, ArtifactUpdateResponseSchema, ArtifactRegenerateResponseSchema, ArtifactCancelResponseSchema, ArtifactDeleteResponseSchema, ArtifactStarResponseSchema, ArtifactGetContentResponseSchema, ArtifactCreatedNotificationSchema, ArtifactUpdatedNotificationSchema, ArtifactDeletedNotificationSchema, } from "./artifacts/rpc-schemas.js";
 import { CLIENT_CAPS } from "./client-capabilities.js";
@@ -139,13 +140,20 @@ export const MutableGitHostingConfigSchema = z
 // agent-personalities.ts) so personalities persisted before the split keep their
 // role rather than silently losing it.
 export const PERSONALITY_ROLES = [
+    // Surfaces — the interactive / host-facing entry points.
     "chatter",
     "artificer",
     "scheduler",
-    "writer",
-    "coder",
+    // Thinking workers — read-only, return structured findings, never edit.
+    "researcher",
+    "planner",
     "judger",
     "advisor",
+    // Making workers — produce code, design, or short text.
+    "coder",
+    "designer",
+    "writer",
+    // Conductor — the sole role whose whole job is planning and driving a team.
     "orchestrator",
 ];
 // Two glow colors for the personality's thinking spinner (BlobLoader glowA/glowB).
@@ -198,6 +206,75 @@ const MutableAgentPersonalitiesConfigSchema = z
     personalities: z.array(AgentPersonalitySchema).default([]),
 })
     .passthrough();
+// Patch shape declared explicitly rather than via .partial(): partial() keeps
+// the personalities .default([]), so a patch touching the section without an
+// explicit personalities array would have an empty array injected and
+// deep-merge would wipe the stored roster.
+const MutableAgentPersonalitiesConfigPatchSchema = z
+    .object({
+    personalities: z.array(AgentPersonalitySchema).optional(),
+})
+    .passthrough();
+// A team's avatar. v1 ships only `color` (hex, validated at the editor like
+// spinner colors); `imageId` is reserved for the future themed avatar set —
+// when present it wins over color, and color stays the fallback so an old
+// client that doesn't know `imageId` keeps rendering the swatch. Plain
+// strings for forward compat.
+const AgentTeamAvatarSchema = z
+    .object({
+    color: z.string().min(1).optional(),
+    imageId: z.string().min(1).optional(),
+})
+    .passthrough();
+// A named, per-host grouping of agent personalities that acts as an operating
+// template: which personalities are on deck, plus a shared team prompt stacked
+// directly ahead of the member's personality prompt at spawn. `id` is the
+// stable identity everything binds to; `name` is a freely-renamable label.
+// `memberIds` bind personality ids (order = display order) — an entry pointing
+// at a deleted personality is tolerated and ignored everywhere, then pruned on
+// the next save of that team. Membership is many-to-many.
+export const AgentTeamSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    avatar: AgentTeamAvatarSchema.optional(),
+    teamPrompt: z.string().optional(),
+    memberIds: z.array(z.string().min(1)).optional(),
+})
+    .passthrough();
+const MutableAgentTeamsConfigSchema = z
+    .object({
+    teams: z.array(AgentTeamSchema).default([]),
+    // The host's active team id; null/absent = no team active (exactly legacy
+    // behavior). Host-scoped daemon config rather than device-local: the team
+    // prompt is applied daemon-side at spawn, so headless spawns (MCP
+    // create_agent, schedule runs) must see it, and a patch from any client
+    // hot-reloads the switch to every connected client.
+    activeTeamId: z.string().nullable().optional(),
+})
+    .passthrough();
+// Patch shape declared explicitly rather than via .partial(): partial() keeps
+// the teams .default([]), so a patch that only touches activeTeamId would have
+// an empty array injected and deep-merge would wipe the stored teams.
+const MutableAgentTeamsConfigPatchSchema = z
+    .object({
+    teams: z.array(AgentTeamSchema).optional(),
+    activeTeamId: z.string().nullable().optional(),
+})
+    .passthrough();
+export const ModelTierSchema = z.enum(["deep", "standard", "fast"]);
+// A user's explicit tier tag for one model of one provider. The daemon stamps
+// `model.tier` at ingest, preferring a matching override here over inference
+// (see model-tiers.ts). Stored as an array (not a nested record) so a patch
+// replaces it wholesale — that's how a tag gets cleared, since deep-merge can't
+// delete a record key.
+export const ModelTierOverrideSchema = z
+    .object({
+    provider: z.string().min(1),
+    modelId: z.string().min(1),
+    tier: ModelTierSchema,
+})
+    .passthrough();
 export const MutableDaemonConfigSchema = z
     .object({
     mcp: z
@@ -220,6 +297,14 @@ export const MutableDaemonConfigSchema = z
     // feature; defaults to an empty roster so a new client parsing an old
     // daemon's config still sees a well-formed section.
     agentPersonalities: MutableAgentPersonalitiesConfigSchema.default({ personalities: [] }),
+    // Per-host agent teams + the active team id. Gated by the agentTeams
+    // feature; defaults to an empty section so a new client parsing an old
+    // daemon's config still sees a well-formed shape.
+    agentTeams: MutableAgentTeamsConfigSchema.default({ teams: [] }),
+    // Per-host user overrides of model tiers, keyed by provider + model id.
+    // Gated by the modelTierOverrides feature; defaults empty so a new client
+    // parsing an old daemon's config still sees a well-formed array.
+    modelTierOverrides: z.array(ModelTierOverrideSchema).default([]),
 })
     .passthrough();
 export const MutableDaemonConfigPatchSchema = z
@@ -245,7 +330,14 @@ export const MutableDaemonConfigPatchSchema = z
     // Gated by server_info features.agentPersonalities. A patch replaces the
     // full roster (read-modify-write the array), matching how terminalProfiles
     // and metadataGeneration.providers patch.
-    agentPersonalities: MutableAgentPersonalitiesConfigSchema.partial().optional(),
+    agentPersonalities: MutableAgentPersonalitiesConfigPatchSchema.optional(),
+    // Gated by server_info features.agentTeams. A `teams` patch replaces the
+    // full array (read-modify-write), matching agentPersonalities;
+    // `activeTeamId: null` deactivates the team without touching the array.
+    agentTeams: MutableAgentTeamsConfigPatchSchema.optional(),
+    // Gated by server_info features.modelTierOverrides. Replaces the full array
+    // (read-modify-write), so removing an entry clears that model's tag.
+    modelTierOverrides: z.array(ModelTierOverrideSchema).optional(),
 })
     .partial()
     .passthrough();
@@ -308,6 +400,12 @@ const AgentModelDefinitionSchema = z.object({
     contextWindowMaxTokens: z.number().optional(),
     thinkingOptions: z.array(AgentSelectOptionSchema).optional(),
     defaultThinkingOptionId: z.string().optional(),
+    // Daemon-stamped capability tier (deep/standard/fast). Optional: absent on old
+    // daemons and on models neither classified nor user-tagged.
+    tier: ModelTierSchema.optional(),
+    // False when the model can't run the provider's "auto" permission mode.
+    // Optional: absent on old daemons and when supported/unknown.
+    supportsAutoMode: z.boolean().optional(),
 });
 export const ProviderSnapshotEntrySchema = z.object({
     provider: AgentProviderSchema,
@@ -693,6 +791,13 @@ export const AgentSnapshotPayloadSchema = z.object({
     persistence: AgentPersistenceHandleSchema.nullable(),
     runtimeInfo: AgentRuntimeInfoSchema.optional(),
     lastUsage: AgentUsageSchema.optional(),
+    // Honest cumulative token total (Σ across the whole run) from the provider,
+    // for the subagents-track cost readout — the only currency that works for
+    // cost-less local models. Observed subagents source it from the provider's
+    // per-task usage.total_tokens (already cumulative-per-subagent). Purely
+    // additive; absent ⇒ no readout. Old clients ignore it.
+    // See projects/subagents-cleanup/subagents-cleanup.md (Item 3).
+    cumulativeTokens: z.number().optional(),
     lastError: z.string().optional(),
     title: z.string().nullable(),
     labels: z.record(z.string(), z.string()).default({}),
@@ -1224,6 +1329,38 @@ export const ProviderUsageListRequestMessageSchema = z.object({
     type: z.literal("provider.usage.list.request"),
     requestId: z.string(),
 });
+// Daemon-wide "fun stats" counters — see docs/data-model.md ActivityStatsStore.
+// Every field defaults to 0 so old and new daemons/clients stay compatible as
+// counters are added later.
+export const ActivityCountersSchema = z.object({
+    messagesSent: z.number().default(0),
+    messagesReceived: z.number().default(0),
+    tokensSent: z.number().default(0),
+    tokensReceived: z.number().default(0),
+    agentsCreated: z.number().default(0),
+    runsOrchestrated: z.number().default(0),
+    subagentsInvoked: z.number().default(0),
+    backgroundTasksInvoked: z.number().default(0),
+    thoughts: z.number().default(0),
+    toolsCalled: z.number().default(0),
+    artifactsCreated: z.number().default(0),
+    schedulesExecuted: z.number().default(0),
+});
+export const StatsActivityGetRequestMessageSchema = z.object({
+    type: z.literal("stats.activity.get.request"),
+    requestId: z.string(),
+});
+export const StatsActivityGetResponseMessageSchema = z.object({
+    type: z.literal("stats.activity.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        today: ActivityCountersSchema,
+        yesterday: ActivityCountersSchema,
+        last7Days: ActivityCountersSchema,
+        last30Days: ActivityCountersSchema,
+        allTime: ActivityCountersSchema,
+    }),
+});
 export const AgentContextGetUsageRequestMessageSchema = z.object({
     type: z.literal("agent.context.get_usage.request"),
     agentId: z.string(),
@@ -1359,6 +1496,56 @@ export const AgentSubagentStopResponseMessageSchema = z.object({
     type: z.literal("agent.subagent.stop.response"),
     payload: AgentActionResponsePayloadSchema,
 });
+// A background shell task launched by a provider's own Bash tool (Claude:
+// run_in_background). Not an agent, not a subagent — a plain shell process
+// the daemon tracks for the parent agent's Background Tasks track.
+// COMPAT(backgroundShellTasks): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
+export const BackgroundShellTaskInfoSchema = z.object({
+    id: z.string(),
+    parentAgentId: z.string(),
+    provider: z.string(),
+    command: z.string().optional(),
+    description: z.string().optional(),
+    status: z.enum(["running", "idle", "error", "closed"]),
+    requiresAttention: z.boolean().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    archivedAt: z.string().optional(),
+});
+// Pushed with the full current set of background shell tasks for a parent
+// agent whenever any of them changes (start/progress/settle/clear) — same
+// full-list reconciliation shape as TerminalsChangedSchema.
+export const BackgroundShellTasksChangedSchema = z.object({
+    type: z.literal("background_shell_tasks_changed"),
+    payload: z.object({
+        parentAgentId: z.string(),
+        tasks: z.array(BackgroundShellTaskInfoSchema),
+    }),
+});
+// Stop a running background shell task. The daemon resolves it to the owning
+// provider session's task and calls stopTask, same as agent.subagent.stop.
+export const AgentBackgroundTaskStopRequestMessageSchema = z.object({
+    type: z.literal("agent.background_task.stop.request"),
+    parentAgentId: z.string(),
+    taskId: z.string(),
+    requestId: z.string(),
+});
+export const AgentBackgroundTaskStopResponseMessageSchema = z.object({
+    type: z.literal("agent.background_task.stop.response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+// Clear one or more terminal background shell tasks from the track. Still-live
+// tasks are stopped best-effort first.
+export const AgentBackgroundTaskClearRequestMessageSchema = z.object({
+    type: z.literal("agent.background_task.clear.request"),
+    parentAgentId: z.string(),
+    taskIds: z.array(z.string()),
+    requestId: z.string(),
+});
+export const AgentBackgroundTaskClearResponseMessageSchema = z.object({
+    type: z.literal("agent.background_task.clear.response"),
+    payload: AgentActionResponsePayloadSchema,
+});
 // Switch a running agent to an Agent Personality (or clear with null). The
 // daemon re-resolves the id against the roster + the agent's cwd provider
 // snapshot and applies the full personality live — system prompt, identity
@@ -1525,6 +1712,80 @@ export const CheckoutGitLogAppendedNotificationSchema = z.object({
         entries: z.array(GitOperationLogEntrySchema),
     }),
 });
+// ── Orchestration runs (agent-orchestration) ────────────────────────────────
+// Daemon-owned multi-agent Run projection + control. Gated by
+// server_info.features.agentOrchestration. See projects/agent-orchestration.
+export const RunsGetSnapshotRequestSchema = z.object({
+    type: z.literal("runs.get_snapshot.request"),
+    requestId: z.string(),
+});
+export const RunsGetSnapshotResponseSchema = z.object({
+    type: z.literal("runs.get_snapshot.response"),
+    payload: z.object({
+        runs: z.array(RunSchema),
+        requestId: z.string(),
+    }),
+});
+// Single-run push, broadcast on every phase/status change. Clients merge by id.
+export const RunsUpdatedNotificationSchema = z.object({
+    type: z.literal("runs.updated.notification"),
+    payload: z.object({
+        run: RunSchema,
+    }),
+});
+// Answer an attended run's `gate` phase (approve or reject, with an optional
+// note). `accepted` is false when the run wasn't awaiting a gate.
+export const RunsGateRespondRequestSchema = z.object({
+    type: z.literal("runs.gate_respond.request"),
+    runId: z.string(),
+    phaseId: z.string(),
+    approved: z.boolean(),
+    note: z.string().optional(),
+    requestId: z.string(),
+});
+export const RunsGateRespondResponseSchema = z.object({
+    type: z.literal("runs.gate_respond.response"),
+    payload: z.object({
+        runId: z.string(),
+        accepted: z.boolean(),
+        requestId: z.string(),
+    }),
+});
+export const RunsCancelRequestSchema = z.object({
+    type: z.literal("runs.cancel.request"),
+    runId: z.string(),
+    requestId: z.string(),
+});
+export const RunsCancelResponseSchema = z.object({
+    type: z.literal("runs.cancel.response"),
+    payload: z.object({
+        runId: z.string(),
+        canceled: z.boolean(),
+        requestId: z.string(),
+    }),
+});
+// Delete every finished (done/failed/canceled) run from disk and memory.
+// Active/paused runs are left untouched. Gated by
+// server_info.features.runsClear.
+export const RunsClearRequestSchema = z.object({
+    type: z.literal("runs.clear.request"),
+    requestId: z.string(),
+});
+export const RunsClearResponseSchema = z.object({
+    type: z.literal("runs.clear.response"),
+    payload: z.object({
+        runIds: z.array(z.string()),
+        requestId: z.string(),
+    }),
+});
+// Broadcast to every connected client (including the requester) so all
+// caches drop the same runs, mirroring runs.updated.notification's upsert.
+export const RunsClearedNotificationSchema = z.object({
+    type: z.literal("runs.cleared.notification"),
+    payload: z.object({
+        runIds: z.array(z.string()),
+    }),
+});
 // Namespaced successor to checkout_commit_request: per-file selection and
 // structured errors. Gated by server_info.features.checkoutGitCommit; the flat
 // RPC stays accepted for old clients.
@@ -2223,6 +2484,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     RefreshProvidersSnapshotRequestMessageSchema,
     ProviderDiagnosticRequestMessageSchema,
     ProviderUsageListRequestMessageSchema,
+    StatsActivityGetRequestMessageSchema,
     AgentContextGetUsageRequestMessageSchema,
     ResumeAgentRequestMessageSchema,
     ImportAgentRequestMessageSchema,
@@ -2239,6 +2501,8 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentFeatureRequestMessageSchema,
     AgentDetachRequestMessageSchema,
     AgentSubagentStopRequestMessageSchema,
+    AgentBackgroundTaskStopRequestMessageSchema,
+    AgentBackgroundTaskClearRequestMessageSchema,
     AgentPersonalitySetRequestMessageSchema,
     AgentRewindRequestMessageSchema,
     AgentPermissionResponseMessageSchema,
@@ -2250,6 +2514,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitCommitAgentRequestSchema,
     CheckoutGitRollbackRequestSchema,
     CheckoutGitGetOperationLogRequestSchema,
+    RunsGetSnapshotRequestSchema,
+    RunsGateRespondRequestSchema,
+    RunsCancelRequestSchema,
+    RunsClearRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -2526,6 +2794,8 @@ export const ServerInfoStatusPayloadSchema = z
         artifacts: z.boolean().optional(),
         // COMPAT(observedSubagents): added in v0.4.3, drop the gate when daemon floor >= v0.4.3.
         observedSubagents: z.boolean().optional(),
+        // COMPAT(backgroundShellTasks): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
+        backgroundShellTasks: z.boolean().optional(),
         // COMPAT(textEditor): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
         textEditor: z.boolean().optional(),
         // COMPAT(projectSearch): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
@@ -2552,6 +2822,16 @@ export const ServerInfoStatusPayloadSchema = z
         checkoutGitRollback: z.boolean().optional(),
         // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
         checkoutGitLog: z.boolean().optional(),
+        // COMPAT(agentTeams): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
+        agentTeams: z.boolean().optional(),
+        // COMPAT(modelTierOverrides): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
+        modelTierOverrides: z.boolean().optional(),
+        // COMPAT(agentOrchestration): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
+        agentOrchestration: z.boolean().optional(),
+        // COMPAT(activityStats): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
+        activityStats: z.boolean().optional(),
+        // COMPAT(runsClear): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
+        runsClear: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3109,6 +3389,11 @@ export const CancelAgentResponseMessageSchema = z.object({
         requestId: z.string(),
         agentId: z.string(),
         agent: AgentSnapshotPayloadSchema.nullable(),
+        // Whether an in-flight run was actually interrupted. False when the agent
+        // had nothing running (already finished, still initializing), so clients
+        // can say "nothing to stop" instead of silently no-oping. Purely additive;
+        // absent ⇒ unknown (old daemon). See projects/subagents-cleanup/subagents-cleanup.md (Item 2).
+        cancelled: z.boolean().optional(),
     }),
 });
 export const ClearAgentAttentionResponseMessageSchema = z.object({
@@ -4701,6 +4986,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentFeatureResponseMessageSchema,
     AgentDetachResponseMessageSchema,
     AgentSubagentStopResponseMessageSchema,
+    AgentBackgroundTaskStopResponseMessageSchema,
+    AgentBackgroundTaskClearResponseMessageSchema,
+    BackgroundShellTasksChangedSchema,
     AgentPersonalitySetResponseMessageSchema,
     AgentRewindResponseMessageSchema,
     UpdateAgentResponseMessageSchema,
@@ -4723,6 +5011,12 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitRollbackResponseSchema,
     CheckoutGitGetOperationLogResponseSchema,
     CheckoutGitLogAppendedNotificationSchema,
+    RunsGetSnapshotResponseSchema,
+    RunsUpdatedNotificationSchema,
+    RunsGateRespondResponseSchema,
+    RunsCancelResponseSchema,
+    RunsClearResponseSchema,
+    RunsClearedNotificationSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,
@@ -4775,6 +5069,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     RefreshProvidersSnapshotResponseMessageSchema,
     ProviderDiagnosticResponseMessageSchema,
     ProviderUsageListResponseMessageSchema,
+    StatsActivityGetResponseMessageSchema,
     AgentContextGetUsageResponseMessageSchema,
     ListCommandsResponseSchema,
     ListTerminalsResponseSchema,

package/dist/model-tiers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Model → tier classification, shared by the daemon (stamps `model.tier` at
+ * ingest) and the app (reads `model.tier`). Pure and dependency-free — no zod,
+ * no I/O.
+ *
+ * Deliberately NO name-pattern guessing: the official model ids are public
+ * record, so we classify what we KNOW (the shipped catalog) and leave everything
+ * else `undefined` = "Unknown". Size-in-the-name heuristics are unreliable
+ * (a Qwen-32B coder ≠ a Qwen-32B instruct), so we don't pretend — the user tags
+ * an Unknown model with an override and that's it.
+ *
+ * Resolution order for a single model:
+ *   1. user override (a per-model tag persisted in host config),
+ *   2. the shipped catalog of known models,
+ * else undefined ("Unknown"). At generation the consumer's context-window
+ * heuristic still fills a slot so a team can bind, but that's a last resort, not
+ * a claim about the model's tier.
+ */
+import type { AgentModelDefinition, ModelTier } from "./agent-types.js";
+export declare const KNOWN_MODEL_TIERS: Readonly<Record<string, ModelTier>>;
+export declare function catalogTier(modelId: string): ModelTier | undefined;
+/**
+ * Infer a model's tier from the shipped catalog alone (no guessing). Undefined
+ * for models we don't ship an id for — those read as "Unknown" until the user
+ * tags one.
+ */
+export declare function inferModelTier(model: Pick<AgentModelDefinition, "id">): ModelTier | undefined;
+/**
+ * The tier to stamp on a model at ingest: an explicit user override wins,
+ * otherwise the catalog. Undefined ("Unknown") leaves the model tier-less until
+ * the user tags it; the consumer's generation heuristic still binds a slot.
+ */
+export declare function resolveModelTier(model: Pick<AgentModelDefinition, "id">, override: ModelTier | undefined): ModelTier | undefined;
+//# sourceMappingURL=model-tiers.d.ts.map

package/dist/model-tiers.js

@@ -0,0 +1,92 @@
+/**
+ * Model → tier classification, shared by the daemon (stamps `model.tier` at
+ * ingest) and the app (reads `model.tier`). Pure and dependency-free — no zod,
+ * no I/O.
+ *
+ * Deliberately NO name-pattern guessing: the official model ids are public
+ * record, so we classify what we KNOW (the shipped catalog) and leave everything
+ * else `undefined` = "Unknown". Size-in-the-name heuristics are unreliable
+ * (a Qwen-32B coder ≠ a Qwen-32B instruct), so we don't pretend — the user tags
+ * an Unknown model with an override and that's it.
+ *
+ * Resolution order for a single model:
+ *   1. user override (a per-model tag persisted in host config),
+ *   2. the shipped catalog of known models,
+ * else undefined ("Unknown"). At generation the consumer's context-window
+ * heuristic still fills a slot so a team can bind, but that's a last resort, not
+ * a claim about the model's tier.
+ */
+// Shipped catalog of known, official model ids (public record). Matched
+// case-insensitively against the exact model id; decorated ids that miss here
+// fall through to patterns.
+export const KNOWN_MODEL_TIERS = {
+    // Anthropic (Claude) — the full Claude Code manifest. Tiering rule: 1M-context
+    // Opus variants are "deep", non-1M Opus and Sonnet are "standard", Haiku is
+    // "fast". Fable (1M, most powerful) is "deep".
+    "claude-fable-5": "deep",
+    "claude-opus-4-8[1m]": "deep",
+    "claude-opus-4-8": "standard",
+    "claude-opus-4-7[1m]": "deep",
+    "claude-opus-4-7": "standard",
+    "claude-opus-4-6[1m]": "deep",
+    "claude-opus-4-6": "standard",
+    "claude-sonnet-5": "standard",
+    "claude-sonnet-4-6[1m]": "standard",
+    "claude-sonnet-4-6": "standard",
+    "claude-haiku-4-5": "fast",
+    "claude-haiku-4-5-20251001": "fast",
+    // OpenAI (GPT / o-series)
+    "gpt-5": "deep",
+    "gpt-5-mini": "fast",
+    "gpt-5-nano": "fast",
+    o3: "deep",
+    "o3-mini": "fast",
+    "o4-mini": "fast",
+    "gpt-4.1": "standard",
+    "gpt-4.1-mini": "fast",
+    "gpt-4o": "standard",
+    "gpt-4o-mini": "fast",
+    // Google (Gemini)
+    "gemini-2.5-pro": "deep",
+    "gemini-2.5-flash": "fast",
+    "gemini-2.5-flash-lite": "fast",
+    "gemini-2.0-flash": "fast",
+    // DeepSeek
+    "deepseek-r1": "deep",
+    "deepseek-v3": "deep",
+    "deepseek-chat": "standard",
+    "deepseek-reasoner": "deep",
+    // Alibaba (Qwen) hosted tiers
+    "qwen-max": "deep",
+    "qwen-plus": "standard",
+    "qwen-turbo": "fast",
+    // xAI (Grok)
+    "grok-4": "deep",
+    "grok-3": "deep",
+    "grok-3-mini": "fast",
+    // Mistral
+    "mistral-large-latest": "deep",
+    "mistral-large": "deep",
+    "mistral-medium": "standard",
+    "mistral-small": "fast",
+};
+export function catalogTier(modelId) {
+    return KNOWN_MODEL_TIERS[modelId.toLowerCase()];
+}
+/**
+ * Infer a model's tier from the shipped catalog alone (no guessing). Undefined
+ * for models we don't ship an id for — those read as "Unknown" until the user
+ * tags one.
+ */
+export function inferModelTier(model) {
+    return catalogTier(model.id);
+}
+/**
+ * The tier to stamp on a model at ingest: an explicit user override wins,
+ * otherwise the catalog. Undefined ("Unknown") leaves the model tier-less until
+ * the user tags it; the consumer's generation heuristic still binds a slot.
+ */
+export function resolveModelTier(model, override) {
+    return override ?? inferModelTier(model);
+}
+//# sourceMappingURL=model-tiers.js.map