@wrongstack/core 0.303.0 → 0.305.0

package/dist/core/agent-types.d.ts

@@ -2,17 +2,17 @@
  * Agent type definitions — extracted from agent.ts to break circular
  * dependencies and keep the Agent class focused on runtime logic.
  */
-import { Pipeline } from '../kernel/pipeline.js';
 import type { ExtensionRegistry } from '../extension/registry.js';
 import type { Container } from '../kernel/container.js';
 import type { EventBus } from '../kernel/events.js';
+import { Pipeline } from '../kernel/pipeline.js';
 import type { ProviderRegistry } from '../registry/provider-registry.js';
 import type { ToolRegistry } from '../registry/tool-registry.js';
 import type { ContentBlock, TextBlock, ToolResultBlock, ToolUseBlock } from '../types/blocks.js';
+import type { LoopDetectionConfig } from '../types/config.js';
 import type { WrongStackError } from '../types/errors.js';
 import type { Tracer } from '../types/observability.js';
 import type { PermissionPolicy } from '../types/permission.js';
-import type { LoopDetectionConfig } from '../types/config.js';
 import type { Request, Response } from '../types/provider.js';
 import type { Tool } from '../types/tool.js';
 import type { ToolExecutorLike } from '../types/tool-executor.js';
@@ -44,6 +44,8 @@ export interface AgentInit {
     perIterationOutputCapBytes?: number | undefined;
     autoExtendLimit?: boolean | undefined;
     autonomousContinue?: boolean | undefined;
+    /** Rebuild the host system prompt from the live direct/catalog tool surfaces before each run. */
+    refreshSystemPrompt?: boolean | undefined;
     confirmAwaiter?: import('../types/tool-executor.js').ConfirmAwaiter | undefined;
     permissionPolicy?: PermissionPolicy | undefined;
     tracer?: Tracer | undefined;

package/dist/core/agent.d.ts

@@ -33,6 +33,7 @@ export declare class Agent {
     /** Resolved loop-detector settings (see `tools.loopDetection`). */
     readonly loopDetection: ResolvedLoopDetectionConfig;
     private readonly autonomousContinue;
+    private readonly refreshSystemPrompt;
     readonly tracer: Tracer | undefined;
     readonly extensions: ExtensionRegistry;
     private readonly _toolHandler;

package/dist/core/context.d.ts

@@ -21,6 +21,17 @@ export interface TodoItem {
     kanbanBoardId?: string | undefined;
     /** Durable Kanban card represented by this todo row. */
     kanbanTaskId?: string | undefined;
+    /**
+     * Titles of the unfinished work this row waits on, derived from the Kanban
+     * card's dependencies. Always board-derived, never model-supplied.
+     *
+     * A blocked item is genuinely `pending` — it has not started — so this is an
+     * extra field rather than a fourth status. What was missing was never the
+     * state but the *reason*: the board computes readiness on every mutation,
+     * then the projection dropped it, leaving blocked work indistinguishable
+     * from ready work on screen and in the model's context.
+     */
+    blockedBy?: string[] | undefined;
 }
 export interface RunOptions {
     signal?: AbortSignal | undefined;
@@ -333,6 +344,10 @@ export declare class Context implements RunEnv {
     /** Wait until every exact conversation-state event queued so far is in the writer buffer. */
     flushConversationJournal(): Promise<void>;
     private conversationJournalBytes;
+    private _journalDropCount;
+    private _journalDropWarnAt;
+    /** Throttled notice that a conversation event never reached the journal. */
+    private warnConversationJournalDrop;
     private enqueueConversationJournal;
     private startConversationJournalDrain;
     get state(): ConversationState;

package/dist/core/conversation-state.d.ts

@@ -88,6 +88,20 @@ export declare class ConversationState {
      * cap determines the starting index for the sum but does not gate it.
      */
     private overflowCount;
+    /**
+     * Front eviction must not retain a `tool_result` after evicting the
+     * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
+     * at the retention cap, so an unsafe boundary would create a fresh orphan on
+     * nearly every append and make the request-time repair discard protocol
+     * history continuously.
+     *
+     * Move the boundary backward to retain the complete exchange for one more
+     * eviction cycle. Moving it forward would also drop non-protocol text/images
+     * that may share either message. The temporary one-message cap overshoot is
+     * the minimum lossless representation; once enough newer messages exist, the
+     * next eviction boundary naturally moves past both halves together.
+     */
+    private protocolSafeDropCount;
     /**
      * Append a content block to the trailing user message's content array.
      * Mutates only that one message (a single indexed assignment) — avoids

package/dist/core/fallback-profile-manager.d.ts

@@ -98,14 +98,60 @@ export declare class FallbackProfileManager {
         model: string;
     }): FallbackChain;
     /**
-     * Resolve every usable configured target as an uncapped last-resort chain.
+     * Resolve every usable configured target as a bounded last-resort chain.
      * Normal smart defaults stay bounded; callers append this only after the
-     * preferred chain and only when automatic fallback is enabled.
+     * preferred chain and only when automatic fallback is enabled. The cap
+     * ({@link MAX_LAST_RESORT_CANDIDATES}) prevents a config with many providers
+     * from producing a degenerate chain of doomed requests during a systemic
+     * outage — by this point the smart default, bridge, and default profile
+     * have already failed.
      */
     resolveAllConfigured(exclude?: {
         providerId: string;
         model: string;
     }): FallbackChain;
+    /**
+     * Effective cap for the last-resort append. Reads the user-configurable
+     * {@link Config.fallbackMaxLastResortCandidates} when set and valid;
+     * otherwise falls back to the compiled-in default
+     * {@link MAX_LAST_RESORT_CANDIDATES}.
+     */
+    private lastResortCap;
+    /**
+     * Build the complete fallback candidate chain shared by the agent-loop
+     * extension and the one-shot orchestrator. Centralizes the bridge → primary →
+     * selected → default-profile → all-configured ladder and the fromExplicitSource
+     * gate so both consumers produce identical ordering and depth semantics.
+     *
+     * Layering (each step deduped against all prior):
+     *  1. Bridge (emergency continuity route).
+     *  2. Configured primary, when the live context drifted from it.
+     *  3. The selected chain (explicit refs → named profile → smart default),
+     *     via {@link resolveEffective}.
+     *  4. The "default" profile — extra depth, ONLY when the chain was auto-derived.
+     *  5. Every other configured provider — last resort, ONLY when the chain was
+     *     auto-derived AND `effectiveFallbackAuto` is true.
+     *
+     * Returns the empty chain when `closedWorld` is true and no explicit
+     * refs/profile resolved — a model allowlist never leaks to unlisted models.
+     *
+     * @internal caller-aware options (primary, closedWorld) are accepted because
+     *   the agent loop has context the manager does not own; the resolution
+     *   pipeline itself is identical for both callers.
+     */
+    resolveCandidates(current: {
+        providerId: string;
+        model: string;
+    }, opts?: {
+        fallbackModels?: readonly string[] | undefined;
+        fallbackProfile?: string | undefined;
+        fallbackAuto?: boolean | undefined;
+        primary?: {
+            providerId: string;
+            model: string;
+        } | undefined;
+        closedWorld?: boolean | undefined;
+    }): FallbackChain;
     checkProvider(providerId: string): ProviderHealth;
     /**
      * Atomically replace the active immutable snapshot while preserving this
@@ -127,4 +173,26 @@ export declare class FallbackProfileManager {
      */
     private smartDefault;
 }
+/**
+ * Maximum number of candidates the last-resort append ({@link FallbackProfileManager.resolveAllConfigured})
+ * may produce. By the time this append fires, the smart default, the bridge, and the
+ * default profile have all failed — in a systemic outage every additional entry is a
+ * doomed request. The cap bounds the blast radius without starving legitimate diversity
+ * (3× the smart-default depth of 4). Exposed for tests and for callers that want to
+ * surface it in config tooling.
+ */
+export declare const MAX_LAST_RESORT_CANDIDATES = 12;
+/**
+ * Deduplicate fallback chain entries by `providerId/model`, dropping the
+ * current (already-active) model and any repeat. Preserves first-occurrence
+ * order so the layering produced by {@link FallbackProfileManager.resolveCandidates}
+ * determines which entry wins when the same model appears at multiple depths.
+ *
+ * Shared by both the agent-loop and one-shot paths so dedup semantics can never
+ * drift between them.
+ */
+export declare function dedupeChain(entries: readonly FallbackChainEntry[], current: {
+    providerId: string;
+    model: string;
+}): FallbackChain;
 //# sourceMappingURL=fallback-profile-manager.d.ts.map