@wrongstack/core 0.32.0 → 0.51.3

package/dist/{events-BrQiweXN.d.ts → events-Bt44ikPN.d.ts}

@@ -1,11 +1,139 @@
 import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-7u93AcGD.js';
 
+/**
+ * Brain coordination primitives.
+ *
+ * Brain is an authority layer above a leader/director but below the human. It is
+ * intentionally modeled as a decision interface first, not as an autonomous
+ * bypass: callers ask for a decision, Brain either answers within policy or
+ * escalates to the human.
+ */
+
+type BrainDecisionSource = 'autophase' | 'director' | 'tool' | 'user' | 'system';
+type BrainRisk = 'low' | 'medium' | 'high' | 'critical';
+type BrainFallback = 'ask_human' | 'deny' | 'continue';
+interface BrainDecisionOption {
+    id: string;
+    label: string;
+    consequence?: string;
+    risk?: BrainRisk;
+    recommended?: boolean;
+}
+interface BrainDecisionRequest {
+    id: string;
+    source: BrainDecisionSource;
+    question: string;
+    context?: string;
+    options?: BrainDecisionOption[];
+    risk: BrainRisk;
+    /** What a non-LLM/default Brain should do when policy cannot decide safely. */
+    fallback: BrainFallback;
+}
+type BrainDecision = {
+    type: 'answer';
+    optionId?: string;
+    text: string;
+    rationale?: string;
+} | {
+    type: 'ask_human';
+    prompt: string;
+    options?: BrainDecisionOption[];
+    rationale?: string;
+} | {
+    type: 'deny';
+    reason: string;
+};
+interface BrainArbiter {
+    decide(request: BrainDecisionRequest): Promise<BrainDecision>;
+}
+/**
+ * Event-emitting decorator for any Brain implementation. Hosts wire this around
+ * their actual arbiter so TUI/session surfaces can render Brain decisions
+ * without coupling to the caller that requested the decision.
+ */
+declare class ObservableBrainArbiter implements BrainArbiter {
+    private readonly inner;
+    private readonly events;
+    constructor(inner: BrainArbiter, events: EventBus);
+    decide(request: BrainDecisionRequest): Promise<BrainDecision>;
+}
+interface BrainDecisionQueueOptions {
+    /** Safety fallback if the human never answers. Default: no timeout. */
+    timeoutMs?: number;
+}
+/**
+ * Bridge between an `ask_human` Brain decision and the UI. It emits the visible
+ * ask-human event, then resolves when the TUI emits `brain.human_answered`.
+ */
+declare class BrainDecisionQueue {
+    private readonly events;
+    private readonly opts;
+    private readonly pending;
+    private readonly offAnswer;
+    constructor(events: EventBus, opts?: BrainDecisionQueueOptions);
+    requestHumanDecision(request: BrainDecisionRequest): Promise<BrainDecision>;
+    dispose(): void;
+}
+/**
+ * Decorator that turns `ask_human` into an actual awaited human decision.
+ * The wrapped Brain remains policy-only; this layer owns the UI/event bridge.
+ */
+declare class HumanEscalatingBrainArbiter implements BrainArbiter {
+    private readonly inner;
+    private readonly queue;
+    constructor(inner: BrainArbiter, queue: BrainDecisionQueue);
+    decide(request: BrainDecisionRequest): Promise<BrainDecision>;
+}
+interface DefaultBrainArbiterOptions {
+    /** Allow deterministic auto-answering for low-risk requests. Default true. */
+    allowLowRiskAutoAnswer?: boolean;
+}
+/**
+ * Conservative deterministic Brain implementation.
+ *
+ * It only auto-answers low-risk requests when the caller provided a recommended
+ * option. Everything else follows the request fallback. This gives hosts a safe
+ * policy object to wire before an LLM-backed Brain exists.
+ */
+declare class DefaultBrainArbiter implements BrainArbiter {
+    private readonly allowLowRiskAutoAnswer;
+    constructor(opts?: DefaultBrainArbiterOptions);
+    decide(request: BrainDecisionRequest): Promise<BrainDecision>;
+}
+declare function formatHumanPrompt(request: BrainDecisionRequest): string;
+
 /**
  * EventBus — observe-only typed event bus.
  * Subscribers cannot modify or cancel. Subscriber exceptions are caught.
  */
 
 interface EventMap {
+    'brain.decision_requested': {
+        request: BrainDecisionRequest;
+        at: number;
+    };
+    'brain.decision_answered': {
+        request: BrainDecisionRequest;
+        decision: BrainDecision;
+        at: number;
+    };
+    'brain.decision_ask_human': {
+        request: BrainDecisionRequest;
+        decision: BrainDecision;
+        at: number;
+    };
+    'brain.human_answered': {
+        id: string;
+        optionId?: string;
+        deny?: boolean;
+        text?: string;
+        at: number;
+    };
+    'brain.decision_denied': {
+        request: BrainDecisionRequest;
+        decision: BrainDecision;
+        at: number;
+    };
     'session.started': {
         id: string;
     };
@@ -174,6 +302,12 @@ interface EventMap {
         /** Provider's max context window. */
         maxContext: number;
     };
+    /** Fired when the active model's resolved context window changes. */
+    'ctx.max_context': {
+        providerId: string;
+        modelId: string;
+        maxContext: number;
+    };
     'token.threshold': {
         used: number;
         limit: number;
@@ -654,4 +788,4 @@ declare class ScopedEventBus extends EventBus {
     get scopedListenerCount(): number;
 }
 
-export { EventBus as E, type Listener as L, ScopedEventBus as S, type EventLogger as a, type EventMap as b, type EventName as c };
+export { type BrainArbiter as B, DefaultBrainArbiter as D, EventBus as E, HumanEscalatingBrainArbiter as H, type Listener as L, ObservableBrainArbiter as O, ScopedEventBus as S, type BrainDecision as a, type BrainDecisionOption as b, BrainDecisionQueue as c, type BrainDecisionRequest as d, type BrainDecisionSource as e, type BrainFallback as f, type BrainRisk as g, type DefaultBrainArbiterOptions as h, type EventLogger as i, type EventMap as j, type EventName as k, formatHumanPrompt as l };

package/dist/execution/index.d.ts

@@ -1,15 +1,15 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-BAi4WI2d.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-p4tP9tGF.js';
 import { m as Provider, d as Context } from '../context-7u93AcGD.js';
 import { a as Compactor, C as CompactReport } from '../compactor-D1RHFRmF.js';
 import { M as MessageSelector } from '../selector-DmXxpFyM.js';
-import { E as EventBus } from '../events-BrQiweXN.js';
+import { E as EventBus } from '../events-Bt44ikPN.js';
 import { b as MiddlewareHandler } from '../system-prompt-CM6zOhd2.js';
 import { a as SessionEventBridge, J as JournalEntry } from '../goal-store-BeRsj7YX.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BUEGM4JP.js';
-import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-ysfO_DlX.js';
-import { D as DoneCondition } from '../multi-agent-C8Z1i__e.js';
-import { A as AgentFactory } from '../agent-subagent-runner-DpZTLdBe.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-DOXSgtom.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-ZRCf7sTu.js';
+import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-mAWBdLyJ.js';
+import { D as DoneCondition } from '../multi-agent-Ba9Ni2hC.js';
+import { A as AgentFactory } from '../agent-subagent-runner-DfvlBx5N.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-BuKq0q89.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { a as WstackPaths } from '../wstack-paths-eMXnY1_X.js';
 import '../retry-policy-KF18W4dg.js';
@@ -566,6 +566,30 @@ declare class EternalAutonomyEngine {
 }
 
 type ParallelEngineState = 'idle' | 'running' | 'stopped';
+type ParallelIterationStage = {
+    phase: 'idle';
+} | {
+    phase: 'decompose';
+} | {
+    phase: 'fanout';
+    slots: number;
+} | {
+    phase: 'await';
+    taskIds: string[];
+} | {
+    phase: 'aggregate';
+    successCount: number;
+    total: number;
+    goalComplete: boolean;
+} | {
+    phase: 'sleep';
+    ms: number;
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'error';
+    message: string;
+};
 interface ParallelEternalOptions {
     /** The coordinating agent — NOT a subagent. Owns container/tools/providers. */
     agent: Agent;
@@ -586,6 +610,8 @@ interface ParallelEternalOptions {
     iterationTimeoutMs?: number;
     onIteration?: (entry: JournalEntry) => void;
     onError?: (err: Error, iteration: number) => void;
+    /** Per-tick phase notifications for live UI/status updates. */
+    onStage?: (stage: ParallelIterationStage) => void;
     gitStatusReader?: () => Promise<string>;
     now?: () => Date;
     compactor?: Compactor;
@@ -685,7 +711,7 @@ 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: `() => autonomyMode === 'eternal'`.
+     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is active.
      */
     enabled: () => boolean;
     /** Number of journal entries to include in the recent-tail block. Default 5. */
@@ -728,4 +754,4 @@ declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOp
  */
 declare function buildGoalPreamble(goal: string): string;
 
-export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, type IterationStage, type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, type IterationStage, type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, type ParallelIterationStage, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };

package/dist/execution/index.js

@@ -6521,8 +6521,14 @@ var ParallelEternalEngine = class {
           await this.runOneIteration();
         } catch (err) {
           this.consecutiveFailures++;
-          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
-          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+          this.opts.onError?.(
+            err instanceof Error ? err : new Error(String(err)),
+            this.consecutiveFailures
+          );
+          await this.appendFailure(
+            "engine error",
+            err instanceof Error ? err.message : String(err)
+          );
         }
         if (this.stopRequested) break;
         await sleep2(2e3);
@@ -6538,14 +6544,19 @@ var ParallelEternalEngine = class {
    * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
    */
   async runOneIteration() {
+    const emit = (stage) => {
+      this.opts.onStage?.(stage);
+    };
     this.iterations++;
     const goal = await loadGoal(this.goalPath);
     if (!goal) {
       this.stopRequested = true;
+      emit({ phase: "stopped" });
       return false;
     }
     if (goal.goalState !== "active") {
       this.stopRequested = true;
+      emit({ phase: "stopped" });
       return false;
     }
     if (!this.coordinator) {
@@ -6558,10 +6569,13 @@ var ParallelEternalEngine = class {
       const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
       this.coordinator.setRunner?.(runner);
     }
+    emit({ phase: "decompose" });
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
+      emit({ phase: "sleep", ms: 2e3 });
       return false;
     }
+    emit({ phase: "fanout", slots: Math.min(this.slots, tasks.length) });
     const fanOut = await this.fanOut(goal, tasks);
     this.iterationsSinceCompact++;
     const successCount = fanOut.results.filter((r) => r.status === "success").length;
@@ -6578,12 +6592,20 @@ var ParallelEternalEngine = class {
       status,
       note
     });
+    emit({
+      phase: "aggregate",
+      successCount,
+      total: fanOut.results.length,
+      goalComplete: fanOut.goalComplete
+    });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
       this.state = "stopped";
+      emit({ phase: "stopped" });
       return true;
     }
     await this.maybeCompact();
+    emit({ phase: "sleep", ms: 2e3 });
     return fanOut.allSuccessful;
   }
   // -------------------------------------------------------------------------
@@ -6597,7 +6619,9 @@ var ParallelEternalEngine = class {
         (t) => dispatchAgent(t, { classifier: this.dispatchClassifier }).catch(() => null)
       )
     ) : [];
-    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
+    const recentJournal = goal.journal.slice(-5).map(
+      (e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`
+    ).join("\n");
     const directivePreamble = [
       "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 parallel task slot \u2550\u2550\u2550",
       "",
@@ -6640,35 +6664,44 @@ ${personaLine}Task: ${task}
         role: route?.role ?? "generic",
         method: route?.method ?? "none"
       });
-      spawnPromises.push((async () => {
-        try {
-          await coordinator.spawn(
-            route ? {
-              id: subagentId,
-              name: route.definition.config.name,
-              role: route.role,
-              tools: route.definition.config.tools,
-              systemPromptOverride: route.definition.config.prompt,
-              timeoutMs: this.timeoutMs
-            } : {
-              id: subagentId,
-              name: `slot-${subagentId.slice(-6)}`,
-              // Let the coordinator apply its default budget (roster or generic).
-              // Hardcoding low limits here defeats the x10 budget improvement.
-              timeoutMs: this.timeoutMs
-            }
-          );
-          subagentIds.push(subagentId);
-          taskIds.push(taskId);
-          await coordinator.assign(spec);
-        } catch {
-        }
-      })());
+      spawnPromises.push(
+        (async () => {
+          try {
+            await coordinator.spawn(
+              route ? {
+                id: subagentId,
+                name: route.definition.config.name,
+                role: route.role,
+                tools: route.definition.config.tools,
+                systemPromptOverride: route.definition.config.prompt,
+                timeoutMs: this.timeoutMs
+              } : {
+                id: subagentId,
+                name: `slot-${subagentId.slice(-6)}`,
+                // Let the coordinator apply its default budget (roster or generic).
+                // Hardcoding low limits here defeats the x10 budget improvement.
+                timeoutMs: this.timeoutMs
+              }
+            );
+            subagentIds.push(subagentId);
+            taskIds.push(taskId);
+            await coordinator.assign(spec);
+          } catch {
+          }
+        })()
+      );
     }
     await Promise.all(spawnPromises);
     if (taskIds.length === 0) {
-      return { results: [], allSuccessful: false, goalComplete: false, partialOutput: "", routes: routeInfo };
+      return {
+        results: [],
+        allSuccessful: false,
+        goalComplete: false,
+        partialOutput: "",
+        routes: routeInfo
+      };
     }
+    this.opts.onStage?.({ phase: "await", taskIds: [...taskIds] });
     let results = [];
     try {
       const ctrl = new AbortController();