@wrongstack/core 0.265.1 → 0.268.0

package/dist/{agent-bridge-DrkBxszZ.d.ts → agent-bridge-UhojbpWx.d.ts}

@@ -1,4 +1,4 @@
-import { B as BridgeTransport, a as BridgeMessage, A as AgentBridge, b as AgentBridgeConfig } from './agent-subagent-runner-DM2pP-B6.js';
+import { B as BridgeTransport, a as BridgeMessage, A as AgentBridge, b as AgentBridgeConfig } from './agent-subagent-runner-Bvtf1o9K.js';
 
 /**
  * In-memory pub/sub transport for agent-to-agent messaging.

package/dist/{agent-subagent-runner-DM2pP-B6.d.ts → agent-subagent-runner-Bvtf1o9K.d.ts}

@@ -1,12 +1,12 @@
-import { c as ToolCallPipelinePayload, d as ToolWrapper, E as ExtensionRegistry, S as SystemPromptContributor, e as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, f as ToolExecutorLike, g as AgentInit, h as AgentInput, R as RunResult } from './index-CEDeNodM.js';
-import { C as Container, R as ReadonlyPipeline, a as Renderer } from './pipeline-DPDxH_7m.js';
-import { E as EventBus, a as EventName, L as Listener } from './brain-BXd_61kQ.js';
-import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-CN0khdlj.js';
+import { c as ToolCallPipelinePayload, d as ToolWrapper, E as ExtensionRegistry, S as SystemPromptContributor, e as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, f as ToolExecutorLike, g as AgentInit, h as AgentInput, R as RunResult } from './index-gCv830d7.js';
+import { C as Container, R as ReadonlyPipeline, a as Renderer } from './pipeline-BDNvENyV.js';
+import { E as EventBus, a as EventName, L as Listener } from './brain-69wzMKp1.js';
+import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-C3s_lvdK.js';
 import { L as Logger } from './logger-B63L5bTg.js';
 import { T as Tracer } from './observability-D-HZN_mF.js';
-import { P as PermissionPolicy } from './permission-B9SB45lp.js';
-import { U as Usage, C as Context, J as JSONSchema, R as Request, b as Response, g as ContentBlock, n as TextBlock, T as Tool, P as Provider, o as RunOptions } from './context-MRk5PhNv.js';
-import { W as WireFamily, H as HookEvent, e as HookMatcher, I as InProcessHook, h as Config } from './config-BMCj_XDs.js';
+import { P as PermissionPolicy } from './permission-Bd-57Lbl.js';
+import { U as Usage, C as Context, J as JSONSchema, R as Request, b as Response, g as ContentBlock, p as TextBlock, T as Tool, P as Provider, s as RunOptions } from './context-C0U8B9NF.js';
+import { W as WireFamily, H as HookEvent, f as HookMatcher, I as InProcessHook, i as Config } from './config-VKfOZ-6X.js';
 
 /**
  * Single fleet-wide event with subagent attribution. Whatever a child
@@ -510,6 +510,17 @@ interface SubagentConfig {
      * fully enforce (e.g., preventing delegation by removing the delegate tool).
      */
     disabledTools?: string[] | undefined;
+    /**
+     * Capability allowlist for this subagent's `AutoApprovePermissionPolicy`.
+     * Subagents run non-interactively, so the policy auto-approves only tools
+     * whose declared capabilities intersect this list; everything else is
+     * denied by the subagent guard. Defaults (when omitted) to the read-only
+     * safe set `['fs.read', 'net.outbound']`. Widen it per-spawn when a task
+     * legitimately needs more — e.g. `/techstack` adds `'fs.write'` so the
+     * subagent can write its report. Never grant `shell.*` unless the task
+     * truly requires arbitrary command execution.
+     */
+    allowedCapabilities?: readonly string[] | undefined;
     model?: string | undefined;
     priority?: number | undefined;
     /**
@@ -819,6 +830,13 @@ interface SlashCommand {
      * If absent, `/help <name>` falls back to `description`.
      */
     help?: string | undefined;
+    /**
+     * When true, this command does not appear in the slash-picker list
+     * triggered by typing `/` alone. It is still dispatchable and
+     * searchable when the user types a matching prefix (e.g. `/f`).
+     * Defaults to false.
+     */
+    hidden?: boolean | undefined;
     /**
      * Execute the command.
      * @param args Everything after the command name (trimmed by dispatch).

package/dist/{brain-BXd_61kQ.d.ts → brain-69wzMKp1.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, C as Context, j as ToolProgressEvent, T as Tool } from './context-MRk5PhNv.js';
+import { U as Usage, C as Context, j as ToolProgressEvent, T as Tool, k as ToolOutputMetadata } from './context-C0U8B9NF.js';
 
 type MemoryScope = 'project-agents' | 'project-memory' | 'user-memory';
 type MemoryType = 'fact' | 'decision' | 'convention' | 'preference' | 'reference' | 'anti_pattern';
@@ -287,6 +287,43 @@ interface EventMap {
         pattern: string;
         decision: 'always' | 'deny';
     };
+    /**
+     * Fired when the agent loop detects that the model is repeating the same
+     * response shape over and over — a tight loop that would otherwise burn
+     * iterations indefinitely. The loop breaks with status `max_iterations`
+     * after `repeatCount` consecutive identical iterations.
+     *
+     * Two flavours caught by the same safety valve:
+     *  - `kind: 'tool'` — the same tool(s) called with effectively the same
+     *    inputs (catches k2p7's tendency to retry identical tool calls when
+     *    a tool returns an unexpected empty result).
+     *  - `kind: 'message'` — the same assistant text repeated, with no tool
+     *    calls. K2P7 and other weak-instruction-following models can echo
+     *    their last assistant turn verbatim across many iterations in
+     *    autonomous-continue mode. The fingerprint also matches this case
+     *    so the safety valve catches it too.
+     *  - `kind: 'mixed'` — both: the response contains tool calls AND text,
+     *    and the combined fingerprint (tool names + text) repeats.
+     *
+     * UIs can render a warning chip. The `kind` field is additive — older
+     * subscribers that only read `tools` continue to work.
+     */
+    'tool.loop_detected': {
+        ctx: Context;
+        /** Comma-separated tool names involved in the loop, or empty string for pure message loops. */
+        tools: string;
+        /** Number of consecutive identical iterations detected. */
+        repeatCount: number;
+        /** 0-based iteration index where the loop was detected. */
+        iteration: number;
+        /**
+         * Shape of the loop. `tool` = identical tool calls; `message` = identical
+         * text-only response; `mixed` = both tool calls and text repeated.
+         * Defaults to `tool` for backward compatibility with subscribers that
+         * pre-date the field.
+         */
+        kind?: 'tool' | 'message' | 'mixed' | undefined;
+    };
     /**
      * `output` is a truncated preview of the tool's serialized result text
      * (capped at ~400 chars by the emitter). UIs render this inline in the
@@ -326,6 +363,13 @@ interface EventMap {
          * actual lines the model received and forwards it here. Undefined
          * for tools without a meaningful line count. */
         outputLines?: number | undefined;
+        /**
+         * Parsed context-management metadata for the result the model saw. This is
+         * intentionally compact: file/symbol/error/path-integrity hints, not the
+         * full output body. Compaction uses it to distinguish seen information from
+         * information later referenced by the assistant.
+         */
+        metadata?: ToolOutputMetadata | undefined;
     };
     /**
      * Fired by the `delegate` tool right before it hands work to a subagent
@@ -453,6 +497,21 @@ interface EventMap {
         load: number;
         /** Provider's max context window in tokens. */
         maxContext: number;
+        /** Budget snapshot used for the compaction decision. */
+        budget?: {
+            maxContext: number;
+            inputTokens: number;
+            availableInputTokens: number;
+            remainingInputTokens: number;
+            reservedOutputTokens: number;
+            reservedSafetyTokens: number;
+            load: number;
+            overflowTokens: number;
+        } | undefined;
+        /** Adaptive trigger signals observed alongside token pressure. */
+        signals?: {
+            repeatedReadCount?: number | undefined;
+        } | undefined;
         /** Full compaction report from the compactor. */
         report: {
             before: number;
@@ -478,6 +537,19 @@ interface EventMap {
         level: 'warn' | 'soft' | 'hard';
         tokens: number;
         maxContext: number;
+        budget?: {
+            maxContext: number;
+            inputTokens: number;
+            availableInputTokens: number;
+            remainingInputTokens: number;
+            reservedOutputTokens: number;
+            reservedSafetyTokens: number;
+            load: number;
+            overflowTokens: number;
+        } | undefined;
+        signals?: {
+            repeatedReadCount?: number | undefined;
+        } | undefined;
         load: number;
         fatal: boolean;
     };

package/dist/{compactor-B8pOf45Y.d.ts → compactor-CBQAJoDc.d.ts}

@@ -1,4 +1,4 @@
-import { C as Context } from './context-MRk5PhNv.js';
+import { C as Context } from './context-C0U8B9NF.js';
 
 interface CompactRepairReport {
     removedToolUses: string[];
@@ -39,6 +39,24 @@ interface CompactReport {
      * session log). Undefined when no range was collapsed this pass.
      */
     collapsedDigest?: string | undefined;
+    /**
+     * Compact state digest derived from tool-output instrumentation. It carries
+     * intent, path integrity, referenced tool results, active errors and implicit
+     * facts without copying full tool outputs back into the context window.
+     */
+    evidenceDigest?: string | undefined;
+    /**
+     * Deterministic post-compaction sanity check. This is deliberately local and
+     * cheap; LLM self-verification can be layered on top, but the compactor still
+     * records whether the compacted context retained an intent anchor and path
+     * trail.
+     */
+    quality?: {
+        ok: boolean;
+        hasIntent: boolean;
+        hasPathTrail: boolean;
+        issues: string[];
+    } | undefined;
 }
 interface Compactor {
     compact(ctx: Context, opts?: {

package/dist/{config-BMCj_XDs.d.ts → config-VKfOZ-6X.d.ts}

@@ -1,4 +1,4 @@
-import { k as Capabilities, f as Permission } from './context-MRk5PhNv.js';
+import { l as ReasoningConfig, m as Capabilities, f as Permission, n as ReasoningEffort, o as CacheTtl } from './context-C0U8B9NF.js';
 
 type ContextWindowModeId = 'balanced' | 'frugal' | 'deep' | 'archival';
 type ContextWindowAggressiveOn = 'hard' | 'soft' | 'warn';
@@ -134,12 +134,14 @@ type HookEntry = {
  * Mirror of the models.dev/api.json schema. Top-level is keyed by provider id.
  * We keep `unknown` for fields we don't read so the cached payload stays faithful.
  */
+
 interface ModelsDevModel {
     id: string;
     name: string;
     family?: string | undefined;
     attachment?: boolean | undefined;
     reasoning?: boolean | undefined;
+    reasoningConfig?: ReasoningConfig | undefined;
     tool_call?: boolean | undefined;
     temperature?: boolean | undefined;
     knowledge?: string | undefined;
@@ -155,6 +157,8 @@ interface ModelsDevModel {
         output?: number | undefined;
         cache_read?: number | undefined;
         cache_write?: number | undefined;
+        cache_write_5m?: number | undefined;
+        cache_write_1h?: number | undefined;
         [k: string]: number | undefined;
     };
     limit?: {
@@ -181,7 +185,7 @@ type ModelsDevPayload = Record<string, ModelsDevProvider>;
  * Canonical wire-format families WrongStack knows how to speak natively.
  * Used by the provider registry to pick a transport.
  */
-type WireFamily = 'anthropic' | 'openai' | 'openai-compatible' | 'google' | 'unsupported';
+type WireFamily = 'anthropic' | 'anthropic-oauth' | 'openai' | 'openai-compatible' | 'openai-codex' | 'github-copilot' | 'google' | 'unsupported';
 interface ResolvedProvider {
     id: string;
     name: string;
@@ -202,6 +206,7 @@ interface ResolvedModel {
         maxContext: number;
         maxOutput?: number | undefined;
         knowledge?: string | undefined;
+        reasoningConfig?: ReasoningConfig | undefined;
     };
     cost?: ModelsDevModel['cost'] | undefined;
 }
@@ -224,6 +229,60 @@ interface ModelsRegistry {
     ageSeconds(): Promise<number>;
 }
 
+/**
+ * Runtime reasoning controls the user can set per-session/project. Mapped into
+ * the provider `Request.reasoning` field by the model-runtime request
+ * middleware, gated by the active model's `reasoningConfig` capabilities so
+ * unsupported values are omitted (and warned) instead of triggering provider
+ * 400s. See `resolveReasoningForRequest()` in packages/core.
+ */
+interface ModelRuntimeReasoningConfig {
+    /**
+     * Whether to send explicit reasoning enable/disable.
+     * - 'auto'    → do not send explicit fields; provider/model default wins
+     * - 'on'      → send `reasoning.enabled = true`
+     * - 'off'     → send `reasoning.enabled = false` only when the model supports disable
+     */
+    mode?: 'auto' | 'on' | 'off' | undefined;
+    /** Reasoning effort. Only sent when the model advertises `effortSupported`. */
+    effort?: ReasoningEffort | undefined;
+    /** Preserve thinking across turns. Only sent when `preserveThinking !== 'unsupported'`. */
+    preserve?: boolean | undefined;
+}
+/**
+ * Runtime prompt-cache controls mapped into `Request.cache`. Currently only the
+ * Anthropic TTL toggle (5m vs 1h) is exposed; other providers ignore it.
+ */
+interface ModelRuntimeCacheConfig {
+    ttl?: CacheTtl | undefined;
+}
+/**
+ * Shared runtime controls applied to every provider request, regardless of host
+ * (REPL / TUI / WebUI). The CLI installs a single request-pipeline middleware
+ * that reads these and mutates the outgoing `Request`.
+ */
+interface ModelRuntimeConfig {
+    reasoning?: ModelRuntimeReasoningConfig | undefined;
+    cache?: ModelRuntimeCacheConfig | undefined;
+}
+/**
+ * HQ client connection settings. Same-machine clients can auto-discover the
+ * local HQ auth file; remote clients use this config-backed URL/token pair.
+ */
+interface HqClientConfig {
+    /** Enable HQ publishing. Env WRONGSTACK_HQ_ENABLED still overrides at runtime. */
+    enabled?: boolean | undefined;
+    /** HQ HTTP base URL, e.g. http://host:3499. */
+    url?: string | undefined;
+    /** Client token for /ws/client. Stored encrypted by SecretVault when persisted. */
+    token?: string | undefined;
+    /** Optional HQ data dir for same-machine auth.json discovery. */
+    dataDir?: string | undefined;
+    /** Send raw content previews to HQ instead of redacted previews. */
+    rawContent?: boolean | undefined;
+    /** Override project display name in HQ. */
+    projectAlias?: string | undefined;
+}
 /**
  * Token-saving mode tier levels. Controls how aggressively the system prompt
  * is compacted to reduce per-request token consumption.
@@ -325,6 +384,32 @@ interface ProviderApiKey {
     apiKey: string;
     /** ISO-8601 timestamp the key was added. */
     createdAt: string;
+    /**
+     * How this credential was obtained.
+     * - `api_key`       — manually pasted API key (default)
+     * - `oauth`         — OAuth 2.0 device-code / authorization-code flow
+     * - `session_token` — extracted from browser session (ChatGPT web, etc.)
+     */
+    authMethod?: 'api_key' | 'oauth' | 'session_token' | undefined;
+    /** ISO-8601 expiry. When set, the token manager will refresh before this time. */
+    expiresAt?: string | undefined;
+    /**
+     * OAuth refresh token. Stored encrypted by the secret-vault walker because
+     * the field name contains `Token` (case-insensitive match by vault).
+     */
+    refreshToken?: string | undefined;
+    /** Token type as returned by the OAuth endpoint (e.g. "bearer"). */
+    tokenType?: string | undefined;
+    /** OAuth scope string (e.g. "openai.models.read openai.models.use"). */
+    scope?: string | undefined;
+    /**
+     * ChatGPT account id, extracted from the OAuth access-token JWT
+     * (`https://api.openai.com/auth`.chatgpt_account_id). Sent as the
+     * `chatgpt-account-id` header by the `openai-codex` wire family. Cached
+     * here for display/diagnostics; the provider re-derives it from the live
+     * token at request time so it can never go stale after a refresh.
+     */
+    accountId?: string | undefined;
 }
 interface ProviderConfig {
     type: string;
@@ -362,6 +447,23 @@ interface ProviderConfig {
      * capability overrides. The model id is the key, not a fully qualified id.
      */
     customModels?: Record<string, CustomModelDefinition>;
+    /**
+     * Per-provider OAuth configuration. When present, `wstack auth login <id>`
+     * uses this instead of prompting for a raw API key. Set by the catalog or
+     * by the user via `/settings`.
+     */
+    oauthConfig?: {
+        /** OAuth client id registered with the provider. */
+        clientId?: string | undefined;
+        /** Device authorization endpoint (RFC 8628). */
+        deviceCodeEndpoint?: string | undefined;
+        /** Token endpoint for code exchange and refresh. */
+        tokenEndpoint?: string | undefined;
+        /** Authorization server URL shown to the user for opening in browser. */
+        authorizationEndpoint?: string | undefined;
+        /** Default OAuth scopes to request. */
+        scopes?: string[] | undefined;
+    } | undefined;
 }
 /**
  * One entry in the per-task model matrix. Pins a catalog role, a phase, or
@@ -391,6 +493,14 @@ interface MCPServerConfig {
     permission?: Permission | undefined;
     startupTimeoutMs?: number | undefined;
     requestTimeoutMs?: number | undefined;
+    /**
+     * Lazy connect: when true, the server process is NOT spawned at boot. Its
+     * tools are registered from a cached manifest (discovered on the first ever
+     * connect) and the server only spawns when one of its tools is actually
+     * called, then auto-sleeps after an idle period. Default (false/undefined) =
+     * eager connect at boot.
+     */
+    lazy?: boolean | undefined;
 }
 interface LogConfig {
     level: 'error' | 'warn' | 'info' | 'debug' | 'trace';
@@ -638,6 +748,15 @@ interface Config {
      * Controls what gets written to the persistent JSONL transcript.
      */
     session?: SessionLoggingConfig | undefined;
+    /**
+     * Runtime reasoning / cache controls applied to every provider request
+     * (REPL/TUI/WebUI). Mapped into `Request.reasoning` and `Request.cache` by a
+     * single request-pipeline middleware, gated by the active model's
+     * capabilities. See `ModelRuntimeConfig`.
+     */
+    modelRuntime?: ModelRuntimeConfig | undefined;
+    /** HQ client publishing settings, used by CLI/REPL/TUI/WebUI consistently. */
+    hq?: HqClientConfig | undefined;
     /**
      * Cloud sync configuration. Stored separately in sync.json to avoid
      * accidentally committing the GitHub token to project configs.
@@ -699,4 +818,4 @@ interface ConfigStore {
     watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
 }
 
-export { type AutonomyConfig as A, type ProviderApiKey as B, type ContextWindowAggressiveOn as C, DEFAULT_CONTEXT_WINDOW_MODE_ID as D, type SessionLoggingConfig as E, type FeaturesConfig as F, type SyncCategory as G, type HookEvent as H, type InProcessHook as I, type ToolsConfig as J, formatContextWindowModeList as K, type LaunchConfig as L, type ModelsRegistry as M, getContextWindowMode as N, isContextWindowModeId as O, type ProviderConfig as P, listContextWindowModes as Q, type ResolvedProvider as R, type ShellHook as S, type TokenSavingTier as T, normalizeTokenSavingTier as U, resolveContextWindowPolicy as V, type WireFamily as W, type ModelsDevPayload as a, type ResolvedModel as b, type MCPServerConfig as c, type ModelMatrixEntry as d, type HookMatcher as e, type HookEntry as f, type ContextWindowPolicy as g, type Config as h, type ConfigStore as i, type ConfigLoader as j, type SyncConfig as k, type HookInput as l, type HookOutcome as m, CONTEXT_WINDOW_MODES as n, type CircuitBreakerRuntimeConfig as o, type ContextConfig as p, type ContextWindowConfigLike as q, type ContextWindowMode as r, type ContextWindowModeId as s, type ContextWindowThresholds as t, type CustomModelDefinition as u, type IndexingConfig as v, type LogConfig as w, type ModelsDevModel as x, type ModelsDevProvider as y, type PluginConfig as z };
+export { type AutonomyConfig as A, type ModelRuntimeConfig as B, type ContextWindowAggressiveOn as C, DEFAULT_CONTEXT_WINDOW_MODE_ID as D, type ModelRuntimeReasoningConfig as E, type FeaturesConfig as F, type ModelsDevProvider as G, type HookEvent as H, type InProcessHook as I, type PluginConfig as J, type ProviderApiKey as K, type LaunchConfig as L, type ModelsRegistry as M, type SessionLoggingConfig as N, type SyncCategory as O, type ProviderConfig as P, type ToolsConfig as Q, type ResolvedProvider as R, type ShellHook as S, type TokenSavingTier as T, formatContextWindowModeList as U, getContextWindowMode as V, type WireFamily as W, isContextWindowModeId as X, listContextWindowModes as Y, normalizeTokenSavingTier as Z, resolveContextWindowPolicy as _, type ModelsDevPayload as a, type ResolvedModel as b, type MCPServerConfig as c, type ModelMatrixEntry as d, type ModelsDevModel as e, type HookMatcher as f, type HookEntry as g, type ContextWindowPolicy as h, type Config as i, type ConfigStore as j, type ConfigLoader as k, type SyncConfig as l, type HookInput as m, type HookOutcome as n, CONTEXT_WINDOW_MODES as o, type CircuitBreakerRuntimeConfig as p, type ContextConfig as q, type ContextWindowConfigLike as r, type ContextWindowMode as s, type ContextWindowModeId as t, type ContextWindowThresholds as u, type CustomModelDefinition as v, type HqClientConfig as w, type IndexingConfig as x, type LogConfig as y, type ModelRuntimeCacheConfig as z };

package/dist/{context-MRk5PhNv.d.ts → context-C0U8B9NF.d.ts}

@@ -502,11 +502,32 @@ interface ToolCallContext {
  * invariant — a TOTAL `input` plus a separate `cacheRead` count would bill
  * cached tokens twice and skew cache-hit-ratio reporting.
  */
+type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type CacheTtl = '5m' | '1h';
 interface Usage {
     input: number;
     output: number;
     cacheRead?: number | undefined;
+    /** Back-compat aggregate of all cache-write tokens. Prefer TTL-specific fields when present. */
     cacheWrite?: number | undefined;
+    cacheWrite5m?: number | undefined;
+    cacheWrite1h?: number | undefined;
+}
+interface ReasoningRequest {
+    enabled?: boolean | undefined;
+    effort?: ReasoningEffort | undefined;
+    preserve?: boolean | undefined;
+    display?: 'summarized' | 'omitted' | undefined;
+}
+interface RequestCacheControl {
+    ttl?: CacheTtl | undefined;
+}
+interface ReasoningConfig {
+    default: 'enabled' | 'disabled' | 'adaptive' | 'always_on';
+    disableSupported: boolean;
+    effortSupported: boolean;
+    effortLevels: ReasoningEffort[];
+    preserveThinking: 'unsupported' | 'optional' | 'always_on';
 }
 interface Capabilities {
     tools: boolean;
@@ -533,6 +554,8 @@ interface Request {
         type: 'tool' | undefined;
         name: string;
     };
+    reasoning?: ReasoningRequest | undefined;
+    cache?: RequestCacheControl | undefined;
 }
 type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'refusal';
 interface Response {
@@ -775,6 +798,21 @@ type SessionEvent = {
         phase: string;
         saved: number;
     }>;
+    /** Context budget snapshot used to trigger this compaction. */
+    budget?: {
+        maxContext: number;
+        inputTokens: number;
+        availableInputTokens: number;
+        remainingInputTokens: number;
+        reservedOutputTokens: number;
+        reservedSafetyTokens: number;
+        load: number;
+        overflowTokens: number;
+    } | undefined;
+    /** Adaptive trigger signals observed alongside token pressure. */
+    signals?: {
+        repeatedReadCount?: number | undefined;
+    } | undefined;
     /**
      * Lossless digest of the range collapsed during this compaction (text
      * content preserved; raw tool I/O omitted). Captures *what* was collapsed
@@ -1115,6 +1153,54 @@ interface SessionWriter {
     clearInFlightMarker(reason: 'clean' | 'aborted' | 'recovered'): Promise<void>;
 }
 
+type ToolEvidenceStatus = 'seen' | 'referenced';
+interface ToolOutputMetadata {
+    toolUseId: string;
+    toolName: string;
+    ok: boolean;
+    inputSummary?: string | undefined;
+    summary: string;
+    files: string[];
+    symbols: string[];
+    commands: string[];
+    errors: string[];
+    status: ToolEvidenceStatus;
+    referenceCount: number;
+    seenAt: number;
+    referencedAt?: number | undefined;
+    outputBytes?: number | undefined;
+    outputTokens?: number | undefined;
+    outputLines?: number | undefined;
+}
+interface ContextFileEvidence {
+    path: string;
+    reads: number;
+    writes: number;
+    tools: string[];
+    referenced: boolean;
+    lastToolUseId?: string | undefined;
+}
+interface ContextIntentEvidence {
+    text: string;
+    updatedAt: number;
+}
+interface ContextRepeatedReadEvidence {
+    file: string;
+    count: number;
+    lastToolUseId: string;
+}
+interface ContextEvidenceState {
+    currentIntent?: ContextIntentEvidence | undefined;
+    sessionGoals: string[];
+    implicitFacts: string[];
+    activeErrors: string[];
+    toolCalls: ToolOutputMetadata[];
+    fileGraph: Record<string, ContextFileEvidence>;
+    repeatedReads: ContextRepeatedReadEvidence[];
+    lastReadPath?: string | undefined;
+    updatedAt: number;
+}
+
 interface CacheStats {
     /** Tokens served from cache (cheaper). */
     readTokens: number;
@@ -1340,6 +1426,7 @@ declare class Context implements RunEnv {
     todos: TodoItem[];
     readFiles: Set<string>;
     fileMtimes: Map<string, number>;
+    contextEvidence: ContextEvidenceState;
     systemPrompt: TextBlock[];
     provider: Provider;
     session: SessionWriter;
@@ -1439,4 +1526,4 @@ declare class Context implements RunEnv {
     usage(): Usage;
 }
 
-export { ToolError as $, AgentError as A, type MessageRole as B, Context as C, PluginError as D, ERROR_CODES as E, type FileSnapshot as F, type ProviderErrorBody as G, type ReadonlyConversationState as H, type ImageBlock as I, type JSONSchema as J, type RiskTier as K, type RunEnv as L, type Message as M, SddError as N, SessionError as O, type Provider as P, type StateChange as Q, type Request as R, type SessionEvent as S, type Tool as T, type Usage as U, type StateChangeHandler as V, type StopReason as W, type StreamEvent as X, StreamHangError as Y, type ThinkingBlock as Z, type ToolCallContext as _, type SessionWriter as a, type ToolFinalEvent as a0, type ToolIconId as a1, type ToolStreamEvent as a2, WrongStackError as a3, asBlocks as a4, asText as a5, extractRunEnv as a6, isAgentError as a7, isConfigError as a8, isFsError as a9, isImageBlock as aa, isPluginError as ab, isSddError as ac, isSessionError as ad, isTextBlock as ae, isThinkingBlock as af, isToolError as ag, isToolResultBlock as ah, isToolUseBlock as ai, isWrongStackError as aj, toWrongStackError as ak, wrapAsState as al, type Response as b, type TokenCounter as c, type CacheStats as d, ProviderError as e, type Permission as f, type ContentBlock as g, type SessionMetadata as h, type SessionStore as i, type ToolProgressEvent as j, type Capabilities as k, type ToolUseBlock as l, type ToolResultBlock as m, type TextBlock as n, type RunOptions as o, type ResumedSession as p, type SessionData as q, type SessionSummary as r, type TodoItem as s, ConversationState as t, ConfigError as u, type ContextInit as v, type ErrorCode as w, type ErrorSeverity as x, type ErrorSubsystem as y, FsError as z };
+export { type RunEnv as $, AgentError as A, type ContextFileEvidence as B, Context as C, type ContextInit as D, type ContextIntentEvidence as E, type ContextRepeatedReadEvidence as F, ERROR_CODES as G, type ErrorCode as H, type ErrorSeverity as I, type JSONSchema as J, type ErrorSubsystem as K, type FileSnapshot as L, type Message as M, FsError as N, type ImageBlock as O, type Provider as P, type MessageRole as Q, type Request as R, type SessionEvent as S, type Tool as T, type Usage as U, PluginError as V, type ProviderErrorBody as W, type ReadonlyConversationState as X, type ReasoningRequest as Y, type RequestCacheControl as Z, type RiskTier as _, type SessionWriter as a, SddError as a0, SessionError as a1, type StateChange as a2, type StateChangeHandler as a3, type StopReason as a4, type StreamEvent as a5, StreamHangError as a6, type ThinkingBlock as a7, type ToolCallContext as a8, ToolError as a9, type ToolEvidenceStatus as aa, type ToolFinalEvent as ab, type ToolIconId as ac, type ToolStreamEvent as ad, WrongStackError as ae, asBlocks as af, asText as ag, extractRunEnv as ah, isAgentError as ai, isConfigError as aj, isFsError as ak, isImageBlock as al, isPluginError as am, isSddError as an, isSessionError as ao, isTextBlock as ap, isThinkingBlock as aq, isToolError as ar, isToolResultBlock as as, isToolUseBlock as at, isWrongStackError as au, toWrongStackError as av, wrapAsState as aw, type Response as b, type TokenCounter as c, type CacheStats as d, ProviderError as e, type Permission as f, type ContentBlock as g, type SessionMetadata as h, type SessionStore as i, type ToolProgressEvent as j, type ToolOutputMetadata as k, type ReasoningConfig as l, type Capabilities as m, type ReasoningEffort as n, type CacheTtl as o, type TextBlock as p, type ToolUseBlock as q, type ToolResultBlock as r, type RunOptions as s, type ResumedSession as t, type SessionData as u, type SessionSummary as v, type TodoItem as w, ConversationState as x, ConfigError as y, type ContextEvidenceState as z };