@wrongstack/core 0.313.1 → 0.316.1

package/dist/coordination/model-tier.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Model tier resolution — the deterministic "how expensive should this job be?"
+ * layer that sits on top of the existing fallback-profile and model-matrix
+ * primitives.
+ *
+ * A tier binds three things that were previously configured independently:
+ *
+ *   fallbackProfile  →  which models, in what failover order
+ *   budget           →  maxCostUsd / maxIterations / maxToolCalls / timeoutMs
+ *   modelRuntime     →  reasoning effort, cache ttl, generation params
+ *
+ * Everything here is deterministic: no LLM call, no scoring, no heuristic over
+ * task text. A tier is chosen by an explicit argument, or by a table lookup
+ * with the SAME precedence the model matrix already uses (exact role → the
+ * role's phase → the `*` default). That precedence is deliberately identical so
+ * a reader only has to learn one rule for both tables.
+ *
+ * Fail-safe by construction: an unconfigured or unknown tier resolves to
+ * `undefined` rather than to an invented model id, and callers then fall
+ * through to their existing behavior (matrix → session). A tier can only ever
+ * ADD a decision the config actually expresses.
+ */
+import type { Config, ModelTierLevel, ModelTiersConfig } from '../types/config.js';
+import type { SubagentConfig } from '../types/multi-agent.js';
+import type { ResolvedModelTarget } from './model-matrix.js';
+/** Fallback default when the config names no default tier. */
+export declare const DEFAULT_TIER_ID = "standard";
+/** Where a tier decision came from. Mirrors `ModelMatrixResolutionSource`. */
+export type ModelTierSource = 'explicit' | 'role' | 'phase' | 'default' | 'config-default';
+export interface ModelTierDecision {
+    /** The chosen tier id. */
+    tier: string;
+    /** Which rung of the ladder produced it. */
+    source: ModelTierSource;
+    /** The routing key that matched, when the decision came from the table. */
+    key?: string | undefined;
+    /** True when the tier id has a configured level backing it. */
+    configured: boolean;
+}
+export interface ModelTierBudget {
+    maxCostUsd?: number | undefined;
+    maxIterations?: number | undefined;
+    maxToolCalls?: number | undefined;
+    maxTokens?: number | undefined;
+    timeoutMs?: number | undefined;
+}
+export interface ResolvedTierTarget extends ResolvedModelTarget {
+    tier: string;
+    source: ModelTierSource;
+    /** Budget fields declared by the level, if any. */
+    budget: ModelTierBudget;
+}
+/** The tier config, normalized. Returns undefined when the layer is off. */
+export declare function activeTierConfig(config: Config): ModelTiersConfig | undefined;
+/** All configured level ids, in config order. Empty when the layer is off. */
+export declare function listTierIds(config: Config): string[];
+/** The configured level for a tier id, or undefined. */
+export declare function tierLevel(config: Config, tier: string | undefined): ModelTierLevel | undefined;
+/** True when `tier` names a level this config actually defines. */
+export declare function isConfiguredTier(config: Config, tier: string | undefined): boolean;
+/**
+ * Deterministic tier ladder.
+ *
+ *   1. `explicit`  — the tool/task/caller named a tier outright.
+ *   2. `role`      — routing[<roster role>].
+ *   3. `phase`     — routing[<the role's phase>].
+ *   4. `default`   — the routing table's `*` entry.
+ *   5. config default (`modelTiers.default`), else {@link DEFAULT_TIER_ID}.
+ *
+ * An explicit tier naming no configured level is still returned (with
+ * `configured: false`) rather than silently rewritten — callers surface it as
+ * an error instead of quietly running the job at the wrong expense.
+ */
+export declare function classifyTier(config: Config, input?: {
+    role?: string | undefined;
+    tier?: string | undefined;
+}): ModelTierDecision | undefined;
+/** Extract only the budget fields a level declares. */
+export declare function tierBudget(level: ModelTierLevel | undefined): ModelTierBudget;
+/**
+ * Expand a level into a concrete model target by reusing the model-matrix
+ * expander. A level IS a matrix entry plus a budget, so the profile-as-primary
+ * semantics (chain[0] primary, remainder failover) come for free and stay
+ * identical between the two tables.
+ */
+export declare function tierModelTarget(config: Config, level: ModelTierLevel | undefined): ResolvedModelTarget | undefined;
+/**
+ * Full resolution: classify, then expand. Returns undefined when the layer is
+ * off or the chosen tier has no configured level — in both cases the caller
+ * keeps whatever it already resolved.
+ */
+export declare function resolveTier(config: Config, input?: {
+    role?: string | undefined;
+    tier?: string | undefined;
+}): ResolvedTierTarget | undefined;
+/**
+ * Apply a resolved tier to a subagent config.
+ *
+ * Model fields are FILL-ONLY: an explicit `delegate({ model })` or a `/setmodel`
+ * role pin is a decision the user already made, and a tier is only a default.
+ *
+ * Spend budgets are different, and getting this wrong makes the whole feature
+ * pointless. By the time a spawn reaches here, `applyRosterBudget` /
+ * `instantiateRosterConfig` have ALREADY populated every budget field with the
+ * role's generous default — so a fill-only rule would mean a 'budget' tier
+ * changes the model but never the spend ceiling, which is not a budget at all.
+ * The rule is therefore:
+ *
+ *   - caller-pinned (`cfg.budgetPins`) → never touched; a number the user typed wins.
+ *   - unset                            → set from the tier.
+ *   - set by a roster/generic default  → TIGHTENED to the tier value (min), never raised.
+ *
+ * Tightening only, never raising: a tier must not be able to silently grant a
+ * worker more money than its role was designed to spend.
+ *
+ * `timeoutMs` is excluded from tightening on purpose. Clamping a wall-clock
+ * budget down is the exact shape of the bug that once capped 10-hour roster
+ * agents at ~4 minutes, and a cost label is not a good reason to kill a
+ * long-running job mid-flight. It stays fill-only.
+ */
+export declare function applyTierToSubagentConfig(cfg: SubagentConfig, resolved: ResolvedTierTarget | undefined): void;
+//# sourceMappingURL=model-tier.d.ts.map

package/dist/coordination/multi-agent-coordinator.d.ts

@@ -53,6 +53,30 @@ export declare class DefaultMultiAgentCoordinator extends EventEmitter implement
     private readonly terminating;
     constructor(config: MultiAgentConfig, options?: MultiAgentCoordinatorOptions);
     private currentSessionId;
+    /**
+     * The session that owns a subagent — its spawn-time stamp.
+     *
+     * Every per-subagent emission routes through here instead of
+     * `currentSessionId()`. The fallback covers ids the coordinator never
+     * spawned (a caller reporting `completeTask` for an unknown worker); a
+     * subagent this coordinator created always has its own stamp.
+     */
+    sessionOf(subagentId: string): string;
+    /** Every subagent this coordinator holds for one session. */
+    subagentIdsForSession(sessionId: string): string[];
+    /**
+     * Stop every subagent belonging to ONE session, and drop that session's
+     * still-queued tasks.
+     *
+     * This is what a tab's Stop button needs. `stopAll()` is the wrong tool with
+     * four tabs live — it would kill three other tabs' work — and until subagents
+     * carried a session stamp there was no way to express the narrower intent, so
+     * stopping a run left its workers grinding on in the background.
+     *
+     * Pending tasks pinned to those subagents are drained as aborted so anything
+     * awaiting them (the delegate tool, report-back) resolves instead of hanging.
+     */
+    stopSession(sessionId: string): Promise<void>;
     /**
      * Replace the runner after construction. Used when the runner depends
      * on infrastructure (e.g. FleetBus) that isn't available until after

package/dist/coordination/origin-session.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `callerSessionId` — which conversation is asking?
+ *
+ * Spawning tools run inside the caller's `Context`, and the answer they need
+ * is the run-pinned session: with several tabs sharing one process, the host's
+ * own writer names the session it booted with, not the one that just called
+ * `delegate`. The pinned id is set for the whole run (see `Agent.run`), so it
+ * survives a tab switch mid-run — which the live reading does not.
+ *
+ * The parameter is typed loosely on purpose: tool `execute` receives an opaque
+ * context, and a few hosts pass partial stand-ins.
+ *
+ * @module origin-session
+ */
+export declare function callerSessionId(ctx: unknown, fallback?: string): string | undefined;
+//# sourceMappingURL=origin-session.d.ts.map

package/dist/coordination/provider-status-tracker.d.ts

@@ -22,9 +22,12 @@
  *   | Metric | Threshold | Action |
  *   |--------|-----------|--------|
  *   | consecutive failures ≥ 2 | → `degraded` for 30 s |
- *   | rate-limit hits ≥ 1 | → `blocked` for 5 min |
- *   | consecutive failures ≥ 5 | → `blocked` for 5 min |
- *   | success streak ≥ 3 | → back to `healthy` |
+ *   | rate-limit hits ≥ 1 | → `blocked` for 2 min |
+ *   | consecutive failures ≥ 5 | → `blocked` for 2 min |
+ *   | quota exhaustion (1st) | → `blocked` for 15 min |
+ *   | quota exhaustion (repeat) | → `blocked` 30 min, then capped at 1 h |
+ *   | quota reset time published | → `blocked` until exactly that time |
+ *   | success streak ≥ 3 | → back to `healthy` (also resets quota escalation) |
  *   | `blocked` timeout elapses | → back to `healthy` |
  *
  * - **Error history**: keeps the last N errors per pair, with session id,
@@ -98,16 +101,28 @@ export interface ProviderStatusTrackerConfig {
      */
     blockAfterFailures?: number;
     /**
-     * Duration (ms) the provider stays `blocked`. Default: 300_000 (5 min).
+     * Duration (ms) the provider stays `blocked` for ordinary failures
+     * (rate-limit threshold, consecutive-failure threshold). These are
+     * transient — short cooldowns re-probe quickly instead of parking a
+     * recoverable model for minutes. Default: 120_000 (2 min).
      */
     blockDurationMs?: number;
     /**
-     * Cooldown for an explicit exhausted-credit/quota response when the
+     * Cooldown for the FIRST exhausted-credit/quota response when the
      * provider does not publish a reset hint. These failures enter the waiting
      * room immediately instead of consuming the ordinary rate-limit threshold.
+     * Repeated quota blocks escalate via {@link quotaBlockEscalationMs}.
      * Default: 900_000 (15 min).
      */
     quotaBlockDurationMs?: number;
+    /**
+     * Escalating cooldowns (ms) for REPEATED quota blocks: each time a quota
+     * block expires and the next result is quota-exhausted again, the next
+     * tier applies; the last entry caps the escalation. A recorded success
+     * (or manual unblock/clear) resets the ladder. Default:
+     * [1_800_000, 3_600_000] — 2nd block 30 min, 3rd+ blocks 1 h max.
+     */
+    quotaBlockEscalationMs?: number[];
     /**
      * Consecutive successes needed to leave `degraded` or `blocked` and return
      * to `healthy` (if the timeout hasn't already cleared it). Default: 3.
@@ -159,6 +174,14 @@ export declare class ProviderModelStatusTracker {
         agentId?: string | undefined;
         retryAfterMs?: number | undefined;
     }): ProviderModelState;
+    /**
+     * Quarantine fan-out expiry: the fixed quota cooldown, never the
+     * hint-extended trigger expiry. A weekly-cap reset time applies to the
+     * model that published it; sibling models (and unseen pairs behind the
+     * provider-wide gate) re-open after the base cooldown so one misclassified
+     * or hint-stretched failure cannot silence a whole provider for hours.
+     */
+    private fanOutExpiryFor;
     /**
      * Mark every other tracked pair on the same provider as blocked with the
      * same expiry as the triggering pair. Only pairs already known to the
@@ -205,6 +228,8 @@ export declare class ProviderModelStatusTracker {
     /**
      * Release one entry for an immediate half-open probe on its next real use.
      * History and totals are retained so operators do not lose diagnostics.
+     * The quota escalation streak is also retained on purpose: a probe that
+     * fails with quota exhaustion again keeps climbing the ladder.
      */
     retryNow(providerId: string, model: string): boolean;
     /**
@@ -248,6 +273,13 @@ export declare class ProviderModelStatusTracker {
     getSnapshot(): ProviderStatusSnapshot;
     /** Restore non-expired waiting-room entries from a previous process. */
     restoreSnapshot(value: unknown): number;
+    /**
+     * Cooldown for the Nth consecutive quota block: the base duration for the
+     * first block, then the escalation ladder for repeats, capped at the last
+     * ladder entry. A provider-published reset hint bypasses this entirely
+     * (the pair is closed until that exact time instead).
+     */
+    private quotaBlockDurationForStreak;
     private getOrCreate;
     private freezeStatus;
     private emitStatusChanged;

package/dist/coordination/session-note-hub.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SessionNoteHub — in-process, same-session delivery for agent notes.
+ *
+ * Mailbox is the durable, cross-session letter. This hub is the live talk
+ * channel: register an inbox per running agent, post a note, the recipient
+ * folds it at its next iteration. Fail-closed on session id. No disk, no
+ * capability.mail, no wait.
+ *
+ * @module session-note-hub
+ */
+import type { EventBus } from '../kernel/events.js';
+import type { SessionNote, SessionNoteKind } from '../core/session-notes.js';
+export interface SessionNotePost {
+    sessionId: string;
+    from: string;
+    /** `leader`, a live agent id, `@session`, or `*` (session-local broadcast). */
+    to: string;
+    kind: SessionNoteKind;
+    body: string;
+    subject?: string | undefined;
+    /** Observability bus (typically the leader/session bus). */
+    events?: EventBus | undefined;
+}
+export interface SessionNoteInbox {
+    sessionId: string | (() => string | undefined);
+    agentId: string;
+    aliases?: readonly string[] | undefined;
+    deliver: (note: SessionNote) => void;
+    /** First bus registered for a session is used to emit `session.note`. */
+    events?: EventBus | undefined;
+}
+export interface SessionNotePostResult {
+    delivered: number;
+}
+export declare class SessionNoteHub {
+    private readonly inboxes;
+    private readonly buses;
+    register(inbox: SessionNoteInbox): () => void;
+    post(input: SessionNotePost): SessionNotePostResult;
+}
+/** Process-wide hub. Agent loops register; tools and hosts post. */
+export declare const sessionNoteHub: SessionNoteHub;
+export declare function postSessionNote(input: SessionNotePost): SessionNotePostResult;
+//# sourceMappingURL=session-note-hub.d.ts.map

package/dist/coordination/session-note-tool.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `session_note` — same-session, in-process talk between the leader and
+ * live agents. Not mailbox: nothing is persisted, other sessions never
+ * see it, and `coordination.mail` is not required.
+ *
+ * @module session-note-tool
+ */
+import type { Tool } from '../types/tool.js';
+export declare function makeSessionNoteTool(): Tool;
+//# sourceMappingURL=session-note-tool.d.ts.map

package/dist/core/agent.d.ts

@@ -14,7 +14,7 @@ import type { Tool } from '../types/tool.js';
 import type { ToolExecutorLike } from '../types/tool-executor.js';
 import { type AgentInit, type AgentInput, type AgentPipelines, type ResolvedLoopDetectionConfig, type RunResult } from './agent-types.js';
 import type { Context, RunOptions } from './context.js';
-export { type AgentInit, type AgentInput, type AgentPipelines, createDefaultPipelines, DEFAULT_MAX_ITERATIONS, normalizeInput, type ResolvedLoopDetectionConfig, type RunResult, resolveLoopDetection, type ToolCallPipelinePayload, type UserInputPayload, } from './agent-types.js';
+export { type AgentInit, type AgentInput, type AgentPipelines, createDefaultPipelines, DEFAULT_MAX_ITERATIONS, normalizeInput, type ResolvedLoopDetectionConfig, resolveLoopDetection, type RunResult, type ToolCallPipelinePayload, type UserInputPayload, } from './agent-types.js';
 export declare class Agent {
     readonly container: Container;
     readonly tools: ToolRegistry;

package/dist/core/context.d.ts

@@ -1,15 +1,14 @@
 import type { TextBlock } from '../types/blocks.js';
+import type { AgentContext, ContextMessageLimits, TodoItem } from '../types/context.js';
 import type { ContextEvidenceState } from '../types/context-evidence.js';
 import type { FileEventRecord } from '../types/file-event-record.js';
 import type { Message } from '../types/messages.js';
 import type { Provider, Usage } from '../types/provider.js';
+import type { RunEnv } from '../types/run-env.js';
 import type { SessionEvent, SessionWriter } from '../types/session.js';
 import type { TokenCounter } from '../types/token-counter.js';
 import type { Tool } from '../types/tool.js';
-import type { AgentContext, ContextMessageLimits } from '../types/context.js';
-import type { RunEnv } from '../types/run-env.js';
 import { ConversationState } from './conversation-state.js';
-import type { TodoItem } from '../types/context.js';
 export type { TodoItem };
 export interface RunOptions {
     signal?: AbortSignal | undefined;
@@ -321,9 +320,11 @@ export declare class Context implements RunEnv, AgentContext {
         event: SessionEvent;
         bytes: number;
         writer: SessionWriter;
+        attempts?: number;
     }>;
     _conversationJournalBytes: number;
     _conversationJournalDrain: Promise<void> | null;
+    _conversationJournalLastError: Error | null;
     private static readonly CONVERSATION_JOURNAL_MAX_EVENTS;
     private static readonly CONVERSATION_JOURNAL_MAX_BYTES;
     private static readonly MAX_FILE_EVENTS;
@@ -500,4 +501,22 @@ export declare class Context implements RunEnv, AgentContext {
  * `session` may be missing despite the non-optional type.
  */
 export declare function resolveEventSessionId(ctx: AgentContext): string;
+/**
+ * Session that OWNS this agent — the conversation a surface is showing.
+ *
+ * Different question from {@link resolveEventSessionId}, which answers "where
+ * do this run's journal events go". A subagent spawned with `sessionsRoot`
+ * configured (the real CLI always configures it) is handed its own journal, so
+ * both `ctx.session.id` and the run-pinned id name a private transcript that no
+ * tab is subscribed to. Anything routed BETWEEN agents of one conversation —
+ * mailbox identity and registration, `@session` recipient normalisation,
+ * `session_note` inboxes — has to key off the spawning conversation instead, or
+ * a worker's report reaches nobody.
+ *
+ * `meta.sessionId` is that spawn-time stamp, fixed for the worker's lifetime
+ * (deliberately not a live read of the host's session, which moves whenever the
+ * user switches tabs). Leaders carry no stamp and fall through to the event id,
+ * which for them is the same session and follows resume / session.new.
+ */
+export declare function resolveOwningSessionId(ctx: AgentContext): string;
 //# sourceMappingURL=context.d.ts.map

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
 export { Agent, type RunResult, type UserInputPayload, } from './agent.js';
 export { type AgentInit, type AgentInput, type AgentPipelines, createDefaultPipelines, type ToolCallPipelinePayload, } from './agent-types.js';
 export { buildBtwBlock, consumeBtwNotes, pendingBtwCount, setBtwNote, } from './btw.js';
+export { buildSessionNoteBlock, consumeSessionNotes, enqueueSessionNote, pendingSessionNoteCount, type SessionNote, type SessionNoteKind, } from './session-notes.js';
 export { Context, type ContextInit, type ProviderMemoryEvidence, type RunOptions, type TodoItem, } from './context.js';
 export { type ContinuationInput, type ContinuationSource, detectContinueIntent, type ResolvedContinuation, resolveContinuation, } from './continue-intent.js';
 export { ConversationState, type ReadonlyConversationState, type StateChange, type StateChangeHandler, wrapAsState, } from './conversation-state.js';
@@ -16,4 +17,5 @@ export { runProviderWithRetry } from './provider-runner.js';
 export { setQueuedMessagesSnapshot } from './queued-messages.js';
 export { buildIdentityLayer, DefaultSystemPromptBuilder, type DefaultSystemPromptBuilderOptions, type SystemBlockSource, } from './system-prompt-builder.js';
 export { type DomainGlossaryOptions, renderDomainGlossary, } from './system-prompt-glossary.js';
+export { countSystemPromptTokens, isSystemInstructionVariant, persistSystemPromptVariant, readSavedSystemPromptVariant, SYSTEM_PROMPT_VARIANT_OPTIONS, SYSTEM_PROMPT_VARIANTS, type SystemPromptVariantPaths, systemPromptVariantLabel, } from './system-prompt-variants.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,20 +1,25 @@
 import {
   Agent,
   InputBuilder,
+  buildSessionNoteBlock,
+  consumeSessionNotes,
   createDefaultPipelines,
   detectContinueIntent,
+  enqueueSessionNote,
+  pendingSessionNoteCount,
   resolveContinuation,
   setQueuedMessagesSnapshot
-} from "../chunk-65RDIOR2.js";
-import "../chunk-ZYU2YOJ6.js";
+} from "../chunk-YOPAUVU4.js";
+import "../chunk-RFQMOKWK.js";
+import "../chunk-NIOAGFPB.js";
 import "../chunk-Z2IJUO45.js";
-import "../chunk-YUPMXOGP.js";
-import "../chunk-PFXFQQRT.js";
-import "../chunk-G5AAKEEZ.js";
-import "../chunk-RD6DEE36.js";
-import "../chunk-5RP3QTRL.js";
-import "../chunk-GM54GJBU.js";
-import "../chunk-W4A6QA3D.js";
+import "../chunk-MTL4O5YR.js";
+import "../chunk-HXKZ7OBQ.js";
+import "../chunk-WP7BVANJ.js";
+import "../chunk-JO4MGB6Z.js";
+import "../chunk-PQNS3U7Z.js";
+import "../chunk-IRUTEHCE.js";
+import "../chunk-FWNLEZYG.js";
 import {
   buildBtwBlock,
   consumeBtwNotes,
@@ -28,27 +33,18 @@ import {
   runProviderWithRetry,
   runtimeFallbackChain,
   smartDefaultFallbackChain
-} from "../chunk-H72H4XDU.js";
-import "../chunk-4ZHTKJHM.js";
-import "../chunk-PAAWLLZX.js";
+} from "../chunk-U45AXT5D.js";
+import "../chunk-4SJNS7OB.js";
+import "../chunk-Y5YXDM7D.js";
 import "../chunk-HA4ZYA6T.js";
-import "../chunk-A455ATZB.js";
 import {
   FallbackProfileManager,
   evaluateModelCalendar
 } from "../chunk-WQQON3SV.js";
 import "../chunk-2YU4WVBW.js";
-import "../chunk-H5E77KUJ.js";
-import "../chunk-3E244UDA.js";
-import "../chunk-Y2GE5TSI.js";
-import {
-  formatModelRef,
-  normalizeModelRef,
-  parseModelRef
-} from "../chunk-RJIZEJ42.js";
-import {
-  isFallbackWorthy
-} from "../chunk-NFAYHPRH.js";
+import "../chunk-QSTSJOCK.js";
+import "../chunk-6FHWXLPT.js";
+import "../chunk-UBGDX6FI.js";
 import {
   DefaultSystemPromptBuilder,
   MAX_PENDING_NEXT_STEPS,
@@ -62,33 +58,46 @@ import {
   renderInstructionLayer,
   renderNextStepsBlock,
   writePendingNextSteps
-} from "../chunk-WZO23AWO.js";
+} from "../chunk-M27LIEKV.js";
 import "../chunk-XEBHSJLT.js";
-import "../chunk-VB3H5WWB.js";
-import "../chunk-M2WF6AXG.js";
-import "../chunk-4XV6IR37.js";
+import "../chunk-6NWEVFEL.js";
+import "../chunk-LSMMOS2Z.js";
 import "../chunk-4VWO3ZXL.js";
 import {
   Context,
   ConversationState,
   wrapAsState
-} from "../chunk-EFEHDQGY.js";
-import "../chunk-AWNQ6ED6.js";
-import "../chunk-FSWCWSTS.js";
+} from "../chunk-ZHZ2Y2DH.js";
+import "../chunk-HI3JGZR2.js";
+import {
+  estimateTextTokens
+} from "../chunk-HMLIGAU7.js";
 import "../chunk-TRT2HRWZ.js";
 import "../chunk-LX5QWLBL.js";
-import "../chunk-FAYRX2AD.js";
-import "../chunk-7ZHZE5EO.js";
+import "../chunk-POOOIWE5.js";
+import {
+  atomicWrite
+} from "../chunk-OSGLYW5J.js";
+import "../chunk-FC2ZGRF3.js";
+import "../chunk-THEGTRAG.js";
 import "../chunk-SVT4RNTR.js";
-import "../chunk-WEBMSQP2.js";
-import "../chunk-YNCVSFGF.js";
-import "../chunk-CB2HFKTP.js";
+import "../chunk-SAFHACFA.js";
+import "../chunk-NS52ISWS.js";
+import {
+  formatModelRef,
+  normalizeModelRef,
+  parseModelRef
+} from "../chunk-RJIZEJ42.js";
+import {
+  isFallbackWorthy
+} from "../chunk-3ECENVHL.js";
+import "../chunk-VVBP6KGT.js";
 import "../chunk-KJ2ZTQSL.js";
 import "../chunk-B4AMLZPB.js";
+import "../chunk-PFZO3C6H.js";
 import "../chunk-O37BQ65S.js";
-import "../chunk-WOEZV3Q4.js";
+import "../chunk-25LSLC3G.js";
 import "../chunk-TBRL2RCC.js";
-import "../chunk-PFZO3C6H.js";
 
 // src/core/fallback-doctor.ts
 function diagnoseFallbackConfig(config, tracker, opts) {
@@ -287,6 +296,78 @@ function simulateFallbackFailover(config, opts = {}) {
     summary
   });
 }
+
+// src/core/system-prompt-variants.ts
+import * as fs from "node:fs/promises";
+var SYSTEM_PROMPT_VARIANT_OPTIONS = [
+  { variant: "lite", label: "Lite", hint: "leanest - best for small context windows" },
+  { variant: "default", label: "Standard", hint: "balanced - the default" },
+  { variant: "pro", label: "Pro", hint: "most detailed guidance - uses more tokens" }
+];
+var SYSTEM_PROMPT_VARIANTS = SYSTEM_PROMPT_VARIANT_OPTIONS.map((o) => o.variant);
+var VALID_VARIANTS = new Set(SYSTEM_PROMPT_VARIANTS);
+function isSystemInstructionVariant(value) {
+  return typeof value === "string" && VALID_VARIANTS.has(value);
+}
+function systemPromptVariantLabel(variant) {
+  return SYSTEM_PROMPT_VARIANT_OPTIONS.find((o) => o.variant === variant)?.label ?? variant;
+}
+async function countSystemPromptTokens(paths) {
+  const counts = {};
+  for (const variant of SYSTEM_PROMPT_VARIANTS) {
+    const bundle = await loadInstructionBundle({
+      globalDir: paths.globalDir,
+      projectDir: paths.projectDir,
+      systemVariant: variant
+    });
+    const identity = buildIdentityLayer(
+      bundle.system?.identity,
+      bundle.system?.identitySource,
+      void 0
+    );
+    counts[variant] = estimateTextTokens(identity);
+  }
+  return counts;
+}
+async function readSavedSystemPromptVariant(configPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(configPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const variant = parsed.systemPrompt?.variant;
+    return isSystemInstructionVariant(variant) ? variant : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function persistSystemPromptVariant(configPath, variant) {
+  let fileExists = false;
+  try {
+    await fs.access(configPath);
+    fileExists = true;
+  } catch {
+  }
+  let existing = {};
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    existing = JSON.parse(raw);
+  } catch (err) {
+    if (fileExists) {
+      throw new Error(
+        `Refusing to overwrite corrupt config at ${configPath} (${err.message}). Fix or move the file aside before retrying.`,
+        { cause: err }
+      );
+    }
+    existing = {};
+  }
+  const systemPrompt = existing.systemPrompt ?? {};
+  existing.systemPrompt = { ...systemPrompt, variant };
+  await atomicWrite(configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+}
 export {
   Agent,
   Context,
@@ -295,24 +376,34 @@ export {
   FallbackProfileManager,
   InputBuilder,
   MAX_PENDING_NEXT_STEPS,
+  SYSTEM_PROMPT_VARIANTS,
+  SYSTEM_PROMPT_VARIANT_OPTIONS,
   buildBtwBlock,
   buildIdentityLayer,
+  buildSessionNoteBlock,
   clearPendingNextSteps,
   consumeBtwNotes,
+  consumeSessionNotes,
+  countSystemPromptTokens,
   createDefaultPipelines,
   createFallbackModelExtension,
   detectContinueIntent,
   diagnoseFallbackConfig,
   effectiveFallbackChain,
+  enqueueSessionNote,
   fallbackProfileChain,
   formatModelRef,
   hasNextStepsTag,
+  isSystemInstructionVariant,
   loadInstructionBundle,
   maybeAppendPendingNextSteps,
   normalizeModelRef,
   parseModelRef,
   pendingBtwCount,
+  pendingSessionNoteCount,
+  persistSystemPromptVariant,
   readPendingNextSteps,
+  readSavedSystemPromptVariant,
   renderDomainGlossary,
   renderInstructionLayer,
   renderNextStepsBlock,
@@ -323,6 +414,7 @@ export {
   setQueuedMessagesSnapshot,
   simulateFallbackFailover,
   smartDefaultFallbackChain,
+  systemPromptVariantLabel,
   wrapAsState,
   writePendingNextSteps
 };