@wrongstack/core 0.313.0 → 0.316.1

package/dist/core/model-ref.js

@@ -1,26 +1,8 @@
-// src/core/model-ref.ts
-function parseModelRef(ref) {
-  const trimmed = ref.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash !== -1) {
-    return {
-      provider: trimmed.slice(0, slash) || void 0,
-      model: trimmed.slice(slash + 1).trim()
-    };
-  }
-  const parts = trimmed.split(/\s+/);
-  if (parts.length >= 2) {
-    return { provider: parts[0], model: parts.slice(1).join(" ") };
-  }
-  return { model: trimmed };
-}
-function formatModelRef(ref, defaultProvider) {
-  const provider = ref.provider ?? defaultProvider;
-  return provider ? `${provider}/${ref.model}` : ref.model;
-}
-function normalizeModelRef(ref, defaultProvider) {
-  return formatModelRef(parseModelRef(ref), defaultProvider);
-}
+import {
+  formatModelRef,
+  normalizeModelRef,
+  parseModelRef
+} from "../chunk-RJIZEJ42.js";
 export {
   formatModelRef,
   normalizeModelRef,

package/dist/core/provider-runner.d.ts

@@ -1,9 +1,10 @@
+import type { ProviderModelStatusTracker } from '../coordination/provider-status-tracker.js';
 import type { EventBus } from '../kernel/events.js';
+import type { AgentContext } from '../types/context.js';
 import type { Logger } from '../types/logger.js';
 import type { Tracer } from '../types/observability.js';
 import type { Provider, Request, Response } from '../types/provider.js';
 import type { RetryPolicy } from '../types/retry-policy.js';
-import type { AgentContext } from '../types/context.js';
 export interface RunProviderOptions {
     provider: Provider;
     request: Request;
@@ -13,12 +14,46 @@ export interface RunProviderOptions {
     retry: RetryPolicy;
     logger: Logger;
     tracer?: Tracer | undefined;
+    /**
+     * Shared provider/model waiting room. When present this runner refuses to
+     * put a quarantined (provider, model) pair on the wire and reports every
+     * wire outcome back into it. See {@link runProviderWithRetry}.
+     */
+    statusTracker?: ProviderModelStatusTracker | undefined;
 }
+/**
+ * Marks a ProviderError whose failure has already been written to the waiting
+ * room, so an outer layer (the `fallback-model` extension) does not count the
+ * same wire failure twice. `Symbol.for` because the error crosses esbuild
+ * subpath-bundle boundaries where class identity is not preserved.
+ */
+export declare const PROVIDER_FAILURE_TRACKED: unique symbol;
+/** True when a previous layer already recorded this error in the waiting room. */
+export declare function isProviderFailureTracked(err: unknown): boolean;
 /**
  * Call a provider with the retry policy applied. Emits `provider.retry`
  * before each retry and `provider.error` once when the retries are
  * exhausted. Streaming providers route through the streaming-response
  * builder so deltas reach the renderer.
+ *
+ * ## Waiting-room middleware
+ *
+ * This function is the ONE funnel every agent-loop provider call passes
+ * through — leader turns, subagent turns, and every hop the `fallback-model`
+ * extension takes (its chain calls back into this runner). When
+ * `statusTracker` is supplied it therefore acts as the last line of defence
+ * for the provider waiting room:
+ *
+ * - **Pre-flight**: a quarantined (provider, model) pair never reaches the
+ *   wire. A synthetic fallback-worthy 429 is thrown instead, so an outer
+ *   fallback chain rotates to the next candidate exactly as it would for a
+ *   real rate limit — but no HTTP request, and no billing, happens.
+ * - **Post-flight**: every success and every terminal failure is recorded,
+ *   independent of which extensions are installed. Before this, the ONLY
+ *   writer was the `fallback-model` extension; anything running without it
+ *   (or any failure whose class identity did not survive a bundle boundary)
+ *   left the waiting room empty and the same doomed model was picked again
+ *   on the very next spawn.
  */
 export declare function runProviderWithRetry(opts: RunProviderOptions): Promise<Response>;
 //# sourceMappingURL=provider-runner.d.ts.map

package/dist/core/request-conversation-binding.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The conversation that owns one concrete LLM request.
+ *
+ * The request pipeline is SHARED: one instance serves every conversation the
+ * process is running, and its payload is a bare `Request` with no session on
+ * it. That was fine when a process meant a conversation. With four WebUI tabs
+ * it means a middleware can only answer "what did the project configure",
+ * never "what did THIS tab configure" — which is how a reasoning effort chosen
+ * in one tab ended up on every other tab's next request.
+ *
+ * A side-channel rather than a field on `Request`, for the same reason
+ * `request-provider-binding.ts` is one: `Request` is the wire shape, and
+ * adding non-wire fields to it invites providers to serialise them.
+ *
+ * Binding is best-effort by design. A request built outside the agent loop
+ * (compaction, one-shot helpers, the brain) carries no conversation, and every
+ * reader must fall back to the process-wide answer — which is exactly the
+ * behaviour those callers had before.
+ *
+ * @module request-conversation-binding
+ */
+import type { Request } from '../types/provider.js';
+/** The slice of a conversation a request-pipeline middleware may consult. */
+export interface RequestConversation {
+    /** The conversation's own meta bag — per-session preferences live here. */
+    meta: Record<string, unknown>;
+}
+export declare function bindRequestConversation(request: Request, conversation: RequestConversation): void;
+export declare function conversationBoundToRequest(request: Request): RequestConversation | undefined;
+/**
+ * Carry the binding onto a request a middleware just copied.
+ *
+ * Middleware conventionally returns `{ ...req }`, which is a NEW object and
+ * therefore unbound — so the middleware after it would see no conversation.
+ */
+export declare function inheritRequestConversation(from: Request, to: Request): void;
+//# sourceMappingURL=request-conversation-binding.d.ts.map

package/dist/core/session-notes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Same-session agent notes — ephemeral inbox on the live Context.
+ *
+ * Distinct from `/btw` (user mid-run steering) and from mailbox (durable
+ * cross-session mail). A note is posted in-process, queued here, and folded
+ * into the recipient's conversation at the next iteration boundary.
+ *
+ * @module session-notes
+ */
+import type { Context } from './context.js';
+export type SessionNoteKind = 'note' | 'result' | 'ask' | 'steer';
+export interface SessionNote {
+    from: string;
+    kind: SessionNoteKind;
+    body: string;
+    subject?: string | undefined;
+}
+/** Queue a note for this agent's next iteration. Returns pending count. */
+export declare function enqueueSessionNote(ctx: Context, note: SessionNote): number;
+export declare function pendingSessionNoteCount(ctx: Context): number;
+/** Read and clear pending notes in FIFO order. */
+export declare function consumeSessionNotes(ctx: Context): SessionNote[];
+/** Compact block the agent reads at the iteration boundary. */
+export declare function buildSessionNoteBlock(notes: SessionNote[]): string;
+//# sourceMappingURL=session-notes.d.ts.map

package/dist/core/system-prompt-builder.d.ts

@@ -7,7 +7,7 @@ import type { BuildContext, ModelCapabilities, SystemPromptBuilder, SystemPrompt
 import type { SystemPromptContributor } from '../types/system-prompt-contributor.js';
 import { type InstructionBundle, type InstructionBundlePaths } from './instruction-bundle.js';
 import { type InstructionTemplateContext } from './instruction-template.js';
-export { type EffectiveShell, effectiveShell, shellGuidanceBlock } from './system-prompt-shell.js';
+export { effectiveShell, shellGuidanceBlock } from './system-prompt-shell.js';
 export declare const LAYER_1_IDENTITY: string;
 /**
  * Compose the layer-1 identity from the bundled default plus any override.
@@ -155,7 +155,8 @@ export declare class DefaultSystemPromptBuilder implements SystemPromptBuilder {
      * join, leave, or change status.
      */
     private _toolsUsageCache?;
-    private _instructionBundle?;
+    /** Instruction bundle per identity variant — see `instructions()`. */
+    private readonly _instructionBundles;
     /**
      * Cached rendered identity layer. Keyed the same way as `_toolsUsageCache`:
      * the ToolRegistry snapshot keeps the array reference stable until a registry
@@ -206,6 +207,14 @@ export declare class DefaultSystemPromptBuilder implements SystemPromptBuilder {
      * provider's prefix cache before the identity block is reached.
      */
     private buildIdentity;
+    /**
+     * The instruction bundle for one identity variant.
+     *
+     * Cached per variant rather than once for the builder: four conversations
+     * share this instance and each picks its own identity, so a single memoised
+     * bundle handed whichever variant loaded first to all of them. At most three
+     * entries exist ('default' | 'lite' | 'pro').
+     */
     private instructions;
     /**
      * Cached plan content keyed by (planPath, mtimeMs). The plan is read

package/dist/core/system-prompt-variants.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The shared catalogue of system-prompt identity variants - Lite / Standard /
+ * Pro - plus the per-variant token estimate every surface shows before a user
+ * commits to one.
+ *
+ * This lives in core because three surfaces need the same answer: the CLI's
+ * startup menu, the WebUI's new-session modal, and any host that wants to
+ * report which variant a session is running. Each of them would otherwise
+ * re-derive the label set, the ordering, and - worse - the token count. A
+ * count computed a second way drifts from the one the builder actually emits,
+ * which is the number the user is choosing on.
+ */
+import { type SystemInstructionVariant } from './instruction-bundle.js';
+/** Menu order + display labels. `default` is shown as "Standard". */
+export declare const SYSTEM_PROMPT_VARIANT_OPTIONS: ReadonlyArray<{
+    variant: SystemInstructionVariant;
+    label: string;
+    hint: string;
+}>;
+/** All selectable variants, in menu order. */
+export declare const SYSTEM_PROMPT_VARIANTS: readonly SystemInstructionVariant[];
+/** Narrow an untrusted value (WS payload, config file, CLI flag) to a variant. */
+export declare function isSystemInstructionVariant(value: unknown): value is SystemInstructionVariant;
+/** Human label for a variant; falls back to the raw id for an unknown value. */
+export declare function systemPromptVariantLabel(variant: SystemInstructionVariant): string;
+/** Instruction dirs used to resolve the identity text per variant. */
+export interface SystemPromptVariantPaths {
+    /** Profile override directory, e.g. `~/.wrongstack/profiles/<name>/instructions`. */
+    globalDir?: string | undefined;
+    /** Project override directory, e.g. `<project>/.wrongstack/instructions`. */
+    projectDir?: string | undefined;
+}
+/**
+ * Estimate the tokens of the system identity block each variant injects.
+ *
+ * Resolution goes through the same `loadInstructionBundle` the
+ * SystemPromptBuilder runs (bundled -> global -> project, later layers override
+ * `system.identity`), and composition goes through the builder's own
+ * `buildIdentityLayer`. Calling the real composer matters: when the identity
+ * came from the *project* layer, WS-016 makes the builder emit the bundled
+ * identity PLUS a `<project-supplied-instructions>` delimiter block PLUS the
+ * project text rather than replacing the identity. Counting
+ * `bundle.system.identity` alone therefore under-reports a project override by
+ * the whole bundled prompt - exactly the case a repo that ships its own
+ * `system-pro.md` hits.
+ *
+ * The figure is an **upper bound**, not `/context` parity: `buildIdentityLayer`
+ * is called without an `InstructionTemplateContext`, which by its own contract
+ * keeps the full text, so `ws:if` blocks for tools the live request never
+ * registers are still counted. Erring high is the right direction for a picker
+ * whose purpose is comparing variant cost, and every figure is rendered with a
+ * leading tilde.
+ */
+export declare function countSystemPromptTokens(paths: SystemPromptVariantPaths): Promise<Record<SystemInstructionVariant, number>>;
+/**
+ * Read the variant the user explicitly saved to the profile config file.
+ *
+ * The config loader materializes `systemPrompt: { variant: 'default' }` for
+ * every config (see the config-loader defaults), so the in-memory Config cannot
+ * distinguish "user chose Standard" from "never chose". Only the raw file can:
+ * {@link persistSystemPromptVariant} writes the key explicitly, so its presence
+ * on disk is the signal that a selection was made. Absence (first run, or a
+ * config edited before this feature existed) returns undefined, and the caller
+ * shows the full picker instead of a one-line confirmation.
+ */
+export declare function readSavedSystemPromptVariant(configPath: string): Promise<SystemInstructionVariant | undefined>;
+/**
+ * Persist the chosen variant to the profile config file so the next boot can
+ * offer a one-line "Continue with these?" gate. Mirrors the launch-choices
+ * writer: read the existing JSON, mutate only the `systemPrompt` block, write
+ * back atomically with mode 0600. Other fields (including encrypted secrets)
+ * pass through round-trip unchanged.
+ *
+ * @throws when the config file exists but is corrupt (same policy as the
+ * launch-choices writer - never overwrite unreadable user config silently).
+ */
+export declare function persistSystemPromptVariant(configPath: string, variant: SystemInstructionVariant): Promise<void>;
+//# sourceMappingURL=system-prompt-variants.d.ts.map