@wrongstack/core 0.6.4 → 0.6.6

package/dist/{events-BHuIHekD.d.ts → events-CJqwQl8G.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-CDRyrkKQ.js';
+import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-DN5v-uQX.js';
 
 /**
  * EventBus — observe-only typed event bus.
@@ -298,6 +298,22 @@ interface EventMap {
         input?: unknown;
         outputBytes?: number;
     };
+    /**
+     * Periodic progress snapshot emitted by the subagent runner every ~25
+     * iterations so the user can track what a subagent is doing without
+     * looking at the FleetPanel. The leader's TUI surfaces this as a
+     * chat history entry: "AGENT#2 💬 L25 · 47 tools · $0.023 · doing grep..."
+     * Fired on a best-effort basis — slow subagents may skip emissions if
+     * the 25-iteration window passes while the agent is between tool calls.
+     */
+    'subagent.iteration_summary': {
+        subagentId: string;
+        iteration: number;
+        toolCalls: number;
+        costUsd: number;
+        currentTool?: string;
+        partialText?: string;
+    };
     'subagent.task_completed': {
         subagentId: string;
         taskId: string;

package/dist/execution/index.d.ts

@@ -1,20 +1,21 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-FoxBjULX.js';
-import { g as Provider, a2 as Context } from '../context-CDRyrkKQ.js';
-import { a as Compactor, C as CompactReport } from '../compactor-RIPuTtWK.js';
-import { M as MessageSelector } from '../selector-C7HqnZJU.js';
-import { E as EventBus } from '../events-BHuIHekD.js';
-import { c as MiddlewareHandler } from '../system-prompt-Dl2QY1_B.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BGGuP_Ar.js';
-import { r as Agent, R as RunResult, j as SystemPromptContributor } from '../index-BOn9NK7D.js';
-import { D as DoneCondition } from '../multi-agent-CxSb-9dQ.js';
-import { J as JournalEntry } from '../goal-store-DVCfj7Ff.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-BF7QfYVE.js';
+import { g as Provider, a2 as Context } from '../context-DN5v-uQX.js';
+import { a as Compactor, C as CompactReport } from '../compactor-C8NhpSt5.js';
+import { M as MessageSelector } from '../selector-DDb_mq9X.js';
+import { E as EventBus } from '../events-CJqwQl8G.js';
+import { c as MiddlewareHandler } from '../system-prompt-gL06H9P4.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-DfC6g6KV.js';
+import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-DcnXDPdY.js';
+import { D as DoneCondition } from '../multi-agent-D5IbASk_.js';
+import { J as JournalEntry } from '../goal-store-HHgaq5ue.js';
+import { A as AgentFactory } from '../agent-subagent-runner-DsSm9lKN.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { W as WstackPaths } from '../wstack-paths-86YPFktR.js';
-import '../retry-policy-LKS8MHsB.js';
+import '../retry-policy-BZSIMxrJ.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-CfMdAJ_l.js';
+import '../secret-scrubber-CT7wefiO.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -333,6 +334,13 @@ interface EternalAutonomyOptions {
     /** Side-channel notifications (logging, UI updates). */
     onIteration?: (entry: JournalEntry) => void;
     onError?: (err: Error, iteration: number) => void;
+    /**
+     * Per-iteration phase notifications for live UI updates (TUI status bar,
+     * etc.). Fires at each major stage transition: idle → decide → execute →
+     * reflect → (sleep | paused | stopped). Fire-and-forget — the engine
+     * does not await the callback.
+     */
+    onStage?: (stage: IterationStage) => void;
     /**
      * Optional injected git status reader — production code uses git, tests
      * stub this out so they don't shell out.
@@ -381,6 +389,33 @@ interface EternalAutonomyOptions {
     transientBackoffMaxMs?: number;
 }
 type EternalEngineState = 'idle' | 'running' | 'stopped';
+/**
+ * Per-iteration phase emitted via `onStage` so UIs can render the
+ * engine's live location in the sense-decide-execute-reflect loop.
+ */
+type IterationStage = {
+    phase: 'idle';
+} | {
+    phase: 'decide';
+    reason: string;
+} | {
+    phase: 'execute';
+    task: string;
+} | {
+    phase: 'reflect';
+    status: 'success' | 'failure' | 'aborted' | 'skipped';
+    note?: string;
+} | {
+    phase: 'sleep';
+    ms: number;
+} | {
+    phase: 'paused';
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'error';
+    message: string;
+};
 declare class EternalAutonomyEngine {
     private readonly opts;
     private state;
@@ -480,6 +515,74 @@ declare class EternalAutonomyEngine {
     private persistEngineState;
 }
 
+type ParallelEngineState = 'idle' | 'running' | 'stopped';
+interface ParallelEternalOptions {
+    /** The coordinating agent — NOT a subagent. Owns container/tools/providers. */
+    agent: Agent;
+    /** Project root (used for goal.json path). */
+    projectRoot: string;
+    /**
+     * Number of parallel subagent slots per tick.
+     * Default: 4. Range 1–16; values >8 are for high-throughput machines.
+     */
+    parallelSlots?: number;
+    /** Per-subagent default timeout in ms. Default: 300_000 (5 min). */
+    iterationTimeoutMs?: number;
+    onIteration?: (entry: JournalEntry) => void;
+    onError?: (err: Error, iteration: number) => void;
+    gitStatusReader?: () => Promise<string>;
+    now?: () => Date;
+    compactor?: Compactor;
+    compactEveryNIterations?: number;
+    aggressiveCompactRatio?: number;
+    maxContextTokens?: number;
+    /** Override the default agent factory (uses main agent if not provided). */
+    subagentFactory?: AgentFactory;
+}
+/**
+ * Sense → Decide → Fan-out (4–8 parallel agents) → Aggregate → Loop.
+ *
+ * Each tick:
+ *   1. Sense    — load goal, todos, git status
+ *   2. Decide   — decompose goal into N parallel sub-tasks
+ *   3. Fan-out  — spawn N subagents simultaneously, await all
+ *   4. Aggregate — write journal, update todos, check [GOAL_COMPLETE]
+ *   5. Loop     — continue until stop() or mission complete
+ *
+ * Uses DefaultMultiAgentCoordinator + AgentSubagentRunner for subagent lifecycle.
+ */
+declare class ParallelEternalEngine {
+    private readonly opts;
+    private state;
+    private stopRequested;
+    private iterationsSinceCompact;
+    private iterations;
+    private consecutiveFailures;
+    private readonly goalPath;
+    private readonly slots;
+    private readonly timeoutMs;
+    private coordinator;
+    private agentFactory;
+    constructor(opts: ParallelEternalOptions);
+    get currentState(): ParallelEngineState;
+    stop(): void;
+    prime(): Promise<void>;
+    run(): Promise<void>;
+    /**
+     * Execute one tick: decompose → fan-out → aggregate → compact.
+     * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
+     */
+    runOneIteration(): Promise<boolean>;
+    private fanOut;
+    private decomposeGoal;
+    private readGitStatus;
+    private brainstormSubtasks;
+    private maybeCompact;
+    private appendIterationEntry;
+    private appendFailure;
+    private persistState;
+}
+
 /**
  * System-prompt contributor that surfaces eternal-autonomy state to the
  * model on every turn.
@@ -549,4 +652,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, 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, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };