@wrongstack/core 0.313.1 → 0.316.2

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

package/dist/design/index.js

@@ -28,12 +28,12 @@ import {
   setActiveKit,
   setDesignOverrides,
   verifyFiles
-} from "../chunk-5DSMEVA4.js";
+} from "../chunk-K6BXGITA.js";
+import "../chunk-FC2ZGRF3.js";
+import "../chunk-SAFHACFA.js";
 import {
   isDesignStack
 } from "../chunk-G5S3S5ZN.js";
-import "../chunk-WEBMSQP2.js";
-import "../chunk-YNCVSFGF.js";
 
 // src/execution/design-materialize.ts
 var SCALE_PREFIXES = [

package/dist/execution/auto-compaction-middleware.d.ts

@@ -138,6 +138,17 @@ export declare class AutoCompactionMiddleware {
      *  the middleware passes every iteration straight through without estimating
      *  tokens or compacting. */
     setEnabled(enabled: boolean): void;
+    /**
+     * Is auto-compaction on for THIS conversation?
+     *
+     * `contextAutoCompact` is a per-tab preference, and a WebUI runs four tabs
+     * through this one middleware instance. The host used to express "off" by
+     * removing the middleware from the shared pipeline, which turned it off for
+     * every tab at once; a session that sets its own value now decides for
+     * itself, and `this._enabled` remains the answer for hosts that keep no
+     * per-session value.
+     */
+    private enabledFor;
     handler(): MiddlewareHandler<Context>;
     /**
      * Full-request token total for the current context.

package/dist/execution/autonomy-brain.d.ts

@@ -26,7 +26,8 @@ import type { EventBus } from '../kernel/events.js';
 import type { Provider } from '../types/provider.js';
 import type { BrainCircuitBreaker } from './brain-circuit.js';
 import { type BrainLlmTarget, DEFAULT_BRAIN_MAX_TOKENS, readLlmDenyKind, buildBrainUserMessage, withDecisionDigest, completeBrainLlm, completeBrainLlmDetailed, extractConfidence, isNonAnswer, parseFreeTextDecision, parseOptionDecision } from './autonomy-brain-llm.js';
-export { type BrainLlmTarget, DEFAULT_BRAIN_MAX_TOKENS, buildBrainUserMessage, withDecisionDigest, completeBrainLlm, completeBrainLlmDetailed, extractConfidence, isNonAnswer, parseFreeTextDecision, parseOptionDecision, readLlmDenyKind, };
+export type { BrainLlmTarget };
+export { DEFAULT_BRAIN_MAX_TOKENS, buildBrainUserMessage, withDecisionDigest, completeBrainLlm, completeBrainLlmDetailed, extractConfidence, isNonAnswer, parseFreeTextDecision, parseOptionDecision, readLlmDenyKind, };
 export interface AutonomyBrainOptions {
     /** LLM provider for decision-making. Ignored when `targets` is non-empty. */
     provider?: Provider | undefined;

package/dist/execution/autonomy-prompt-contributor.d.ts

@@ -14,6 +14,7 @@
  * counter) changes each turn without invalidating the upstream prefix
  * cache.
  */
+import type { BuildContext } from '../types/system-prompt.js';
 import type { SystemPromptContributor } from '../types/system-prompt-contributor.js';
 export interface AutonomyPromptContributorOptions {
     /** Absolute path to the project's `goal.json`. */
@@ -24,9 +25,13 @@ export interface AutonomyPromptContributorOptions {
      * leak into interactive runs that happen to have a goal on disk and
      * teach the model loop-control markers it shouldn't emit.
      *
-     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is active.
+     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is
+     * active. Receives the build context so the answer can come from the
+     * CONVERSATION being built for (`ctx.autonomy`) rather than a process-wide
+     * mode ref — with four tabs on one process, that ref is whichever tab last
+     * changed it.
      */
-    enabled: () => boolean;
+    enabled: (ctx: BuildContext) => boolean;
     /** Number of journal entries to include in the recent-tail block. Default 5. */
     journalTailSize?: number | undefined;
 }

package/dist/execution/compaction-core.d.ts

@@ -1,7 +1,7 @@
 import { estimateMessageTokens } from '../utils/token-estimate.js';
-export { buildSmartDigest, type ContentScore, extractText, hasLargeToolResult, hasToolUse, scoreMessage, } from './compaction-scoring.js';
-export { collapseAcknowledgedToolReceipts, eliseAcknowledgedToolResults, eliseOldToolResults, type EliseResult, findPreserveStart, isElidedResultContent, isElidedToolInput, normalizePathKey, readPathOf, setCompactionDebugLogger, summarizeToolResultElision, summarizeToolUseInputElision, } from './compaction-elision.js';
-export { buildLosslessDigest, type DedupResult, dedupStaleReads, elideMessageToolIo, enforceHardBudget, findExchangeStart, findSafeBoundary, type HardBudgetResult, hasTextContent, headTailTruncate, truncateMessageText, } from './compaction-budget.js';
-export { CompactionSummaryCache, type CompactionSummaryCacheOptions, compactionSummaryKey, isPlaceholderSummary, PLACEHOLDER_SUMMARIES, } from './compaction-summary-cache.js';
+export { type ContentScore, buildSmartDigest, extractText, hasLargeToolResult, hasToolUse, scoreMessage, } from './compaction-scoring.js';
+export { type EliseResult, collapseAcknowledgedToolReceipts, eliseAcknowledgedToolResults, eliseOldToolResults, findPreserveStart, isElidedResultContent, isElidedToolInput, normalizePathKey, readPathOf, setCompactionDebugLogger, summarizeToolResultElision, summarizeToolUseInputElision, } from './compaction-elision.js';
+export { buildLosslessDigest, dedupStaleReads, elideMessageToolIo, enforceHardBudget, findExchangeStart, findSafeBoundary, hasTextContent, headTailTruncate, truncateMessageText } from './compaction-budget.js';
+export { CompactionSummaryCache, compactionSummaryKey, isPlaceholderSummary, PLACEHOLDER_SUMMARIES } from './compaction-summary-cache.js';
 export declare const estimateMessages: typeof estimateMessageTokens;
 //# sourceMappingURL=compaction-core.d.ts.map

package/dist/execution/eternal-autonomy.d.ts

@@ -12,7 +12,7 @@
  * user wants "sittin sene". Failures are logged and the loop continues
  * with a different source on the next tick.
  */
-export type { EternalAutonomyOptions, EternalEngineState, IterationStage } from './eternal-autonomy-types.js';
+export type { EternalAutonomyOptions, EternalEngineState, IterationStage, } from './eternal-autonomy-types.js';
 import type { EternalAutonomyOptions, EternalEngineState } from './eternal-autonomy-types.js';
 export declare class EternalAutonomyEngine {
     private readonly opts;