@wrongstack/core 0.5.5 → 0.5.7

package/dist/director-state-BmYi3DGA.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Director state checkpoint — written incrementally throughout a fleet
+ * run so a crashed director can be inspected (and eventually resumed)
+ * instead of leaving only a final `fleet.json` manifest after `shutdown()`.
+ *
+ * Schema is JSON-friendly and deliberately denormalized. Each mutation
+ * triggers an atomic-write of the whole file — small payloads (typically
+ * < 10 KB even with dozens of subagents) make this cheap.
+ */
+interface DirectorSubagentState {
+    id: string;
+    name?: string;
+    role?: string;
+    provider?: string;
+    model?: string;
+    spawnedAt: string;
+}
+interface DirectorTaskState {
+    taskId: string;
+    subagentId?: string;
+    description?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'timeout';
+    assignedAt?: string;
+    completedAt?: string;
+    iterations?: number;
+    toolCalls?: number;
+    durationMs?: number;
+    error?: string;
+}
+interface DirectorStateSnapshot {
+    version: 1;
+    directorRunId: string;
+    updatedAt: string;
+    spawnCount: number;
+    maxSpawns?: number;
+    spawnDepth: number;
+    maxSpawnDepth: number;
+    directorBudget?: {
+        maxCostUsd?: number;
+    };
+    subagents: DirectorSubagentState[];
+    tasks: DirectorTaskState[];
+    /** Aggregated usage snapshot. Optional — populated by the Director on save when available. */
+    usage?: unknown;
+}
+declare function loadDirectorState(filePath: string): Promise<DirectorStateSnapshot | null>;
+/**
+ * In-memory accumulator with atomic-write checkpoint. The Director keeps
+ * an instance, mutates it on every spawn/assign/complete/fail event, and
+ * the instance debounces writes so a burst of activity collapses into a
+ * single disk hit.
+ *
+ * Supports crash recovery: use `loadDirectorState()` to read an existing
+ * checkpoint, then call `DirectorStateCheckpoint.resume(snapshot)` to
+ * re-attach to a fleet mid-flight. The lock mechanism ensures no two
+ * directors can claim the same checkpoint.
+ */
+declare class DirectorStateCheckpoint {
+    private snapshot;
+    private readonly filePath;
+    private readonly lockPath;
+    private timer;
+    private readonly debounceMs;
+    private writing;
+    private rewriteRequested;
+    constructor(filePath: string, init: {
+        directorRunId: string;
+        maxSpawns?: number;
+        spawnDepth: number;
+        maxSpawnDepth: number;
+        directorBudget?: {
+            maxCostUsd?: number;
+        };
+    }, debounceMs?: number);
+    /**
+     * Attempt to acquire the lock for this checkpoint. Call this before
+     * resuming a crashed director run. If it returns false, another
+     * director process is still running this fleet — do not resume.
+     */
+    acquireLock(): Promise<boolean>;
+    /**
+     * Release the lock on graceful shutdown. Call `flush()` first to ensure
+     * the final checkpoint state is on disk before removing the lock.
+     * Without this, the next resume will see a stale-lock and refuse.
+     */
+    releaseLock(): Promise<void>;
+    /**
+     * Resume from a snapshot previously loaded via `loadDirectorState()`.
+     * Use this when `--resume <runId>` is triggered — the snapshot has
+     * the full fleet state (subagents, tasks) from before the crash; the
+     * checkpoint continues from there.
+     */
+    resume(snapshot: DirectorStateSnapshot): void;
+    current(): DirectorStateSnapshot;
+    recordSpawn(sub: DirectorSubagentState, spawnCount: number): void;
+    recordTaskAssigned(task: DirectorTaskState): void;
+    recordTaskStatus(taskId: string, patch: Partial<DirectorTaskState> & {
+        status: DirectorTaskState['status'];
+    }): void;
+    setUsage(usage: unknown): void;
+    /** Force a synchronous flush — used by Director.shutdown(). */
+    flush(): Promise<void>;
+    private bumpUpdatedAt;
+    private schedule;
+    private persist;
+}
+
+export { DirectorStateCheckpoint as D, type DirectorStateSnapshot as a, type DirectorSubagentState as b, type DirectorTaskState as c, loadDirectorState as l };

package/dist/{events-qnDZbrtb.d.ts → events-DPQKFX7W.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-CLZXPPYk.js';
+import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-CDRyrkKQ.js';
 
 /**
  * EventBus — observe-only typed event bus.

package/dist/execution/index.d.ts

@@ -1,19 +1,19 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-DSvmOBe6.js';
-import { g as Provider, a2 as Context } from '../context-CLZXPPYk.js';
-import { a as Compactor, C as CompactReport } from '../compactor-BWhJXxsW.js';
-import { M as MessageSelector } from '../selector-DB2-byKH.js';
-import { E as EventBus } from '../events-qnDZbrtb.js';
-import { c as MiddlewareHandler } from '../system-prompt-DI4Dtc1I.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BgM0BIpz.js';
-import { r as Agent, R as RunResult } from '../index-DPLJw_ZI.js';
-import { D as DoneCondition } from '../multi-agent-Cv8wk47i.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-DbAFkHdP.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-DPQKFX7W.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 } from '../index-j2WyAyML.js';
+import { D as DoneCondition } from '../multi-agent-Cpp7FXUl.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-LLUxJmYY.js';
+import '../retry-policy-LKS8MHsB.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-BhJTNr9v.js';
+import '../secret-scrubber-CfMdAJ_l.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -252,6 +252,13 @@ interface AutonomousRunnerOptions {
         toolCalls: number;
     }) => void;
     onDone?: (result: AutonomousResult) => void;
+    /**
+     * When true and `doneCondition.type === 'directive'`, the runner
+     * runs the agent with `autonomousContinue: true` so the agent loop
+     * handles its own [continue]/[done] markers internally (no outer
+     * re-invocation needed). The runner still provides iteration/timeouts.
+     */
+    enableAutonomousContinue?: boolean;
 }
 declare class AutonomousRunner {
     private readonly opts;

package/dist/execution/index.js

@@ -1414,6 +1414,14 @@ var DoneConditionChecker = class {
           };
         }
         break;
+      case "directive":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return { done: true, reason: `max iterations (${this.condition.maxIterations}) reached`, ...state };
+        }
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
+        }
+        break;
     }
     return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
   }
@@ -1433,10 +1441,16 @@ var AutonomousRunner = class {
     const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
       this.toolCalls++;
     });
+    const offIterationCompleted = this.opts.agent.events?.on?.("iteration.completed", () => {
+      if (this.opts.enableAutonomousContinue && this.opts.doneCondition.type === "directive") {
+        this.iterations++;
+      }
+    });
     try {
       return await this.runLoop();
     } finally {
       offToolExecuted?.();
+      offIterationCompleted?.();
     }
   }
   async runLoop() {
@@ -1460,12 +1474,14 @@ var AutonomousRunner = class {
       const ctrl = new AbortController();
       const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
       try {
+        const isDirectiveMode = this.opts.doneCondition.type === "directive" && this.opts.enableAutonomousContinue;
         const result = await this.opts.agent.run("", {
           signal: ctrl.signal,
-          maxIterations: 1,
-          executionStrategy: "sequential"
+          maxIterations: isDirectiveMode ? this.opts.doneCondition.maxIterations ?? 100 : 1,
+          executionStrategy: "sequential",
+          autonomousContinue: isDirectiveMode ? true : void 0
         });
-        this.iterations++;
+        if (!isDirectiveMode) this.iterations++;
         if (result.status === "done") {
           this.lastOutput = result.finalText;
         }