@wrongstack/core 0.7.5 → 0.7.7

package/dist/defaults/index.js

@@ -1,5 +1,5 @@
 import * as crypto2 from 'crypto';
-import { randomBytes, randomUUID, createCipheriv, createDecipheriv } from 'crypto';
+import { randomBytes, randomUUID, createCipheriv, createDecipheriv, createHash } from 'crypto';
 import * as fsp from 'fs/promises';
 import * as path3 from 'path';
 import * as fs5 from 'fs';
@@ -88,7 +88,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -1225,7 +1225,7 @@ function walk(node, vault, transform) {
   if (Array.isArray(node)) {
     return node.map((item) => walk(item, vault, transform));
   }
-  const out = {};
+  const out = /* @__PURE__ */ Object.create(null);
   for (const [k, v] of Object.entries(node)) {
     if (typeof v === "string" && isSecretField(k)) {
       out[k] = transform(v, k);
@@ -2752,7 +2752,9 @@ var DefaultSecretVault = class {
     try {
       const buf = fs5.readFileSync(this.keyFile);
       if (buf.length !== KEY_BYTES) {
-        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
+        throw new Error(
+          `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`
+        );
       }
       this.key = buf;
       return this.key;
@@ -2767,7 +2769,9 @@ var DefaultSecretVault = class {
       if (err.code !== "EEXIST") throw err;
       const buf = fs5.readFileSync(this.keyFile);
       if (buf.length !== KEY_BYTES) {
-        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
+        throw new Error(
+          `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`
+        );
       }
       this.key = buf;
       return this.key;
@@ -2828,10 +2832,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   const encrypted = encryptConfigSecrets(merged, vault);
   await fsp.mkdir(path3.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
-  try {
-    await fsp.chmod(configPath, 384);
-  } catch {
-  }
+  await restrictFilePermissions(configPath);
 }
 async function migratePlaintextSecrets(configPath, vault) {
   let raw;
@@ -2850,12 +2851,26 @@ async function migratePlaintextSecrets(configPath, vault) {
   const migrated = walkCount(parsed, vault, counter);
   if (counter.n === 0) return { migrated: 0, file: configPath };
   await atomicWrite(configPath, JSON.stringify(migrated, null, 2), { mode: 384 });
-  try {
-    await fsp.chmod(configPath, 384);
-  } catch {
-  }
+  await restrictFilePermissions(configPath);
   return { migrated: counter.n, file: configPath };
 }
+async function restrictFilePermissions(filePath) {
+  if (process.platform === "win32") {
+    try {
+      const { execFile: execFile2 } = await import('child_process');
+      const { promisify: promisify2 } = await import('util');
+      const execFileAsync = promisify2(execFile2);
+      await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${process.env.USERNAME}:(F)`]);
+    } catch {
+      console.warn(`[secret-vault] Could not restrict permissions on ${filePath} \u2014 config file may be readable by other users on this system.`);
+    }
+  } else {
+    try {
+      await fsp.chmod(filePath, 384);
+    } catch {
+    }
+  }
+}
 function walkCount(node, vault, counter) {
   if (node === null || node === void 0) return node;
   if (typeof node !== "object") return node;
@@ -3822,8 +3837,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
       try {
         await Promise.race([
           Promise.resolve(iter.return?.()),
-          new Promise((resolve2) => {
-            drainTimer = setTimeout(resolve2, 500);
+          new Promise((resolve3) => {
+            drainTimer = setTimeout(resolve3, 500);
           })
         ]);
       } finally {
@@ -3884,7 +3899,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve3, reject) => {
         let settled = false;
         const onAbort = () => {
           if (settled) return;
@@ -3897,7 +3912,7 @@ async function runProviderWithRetry(opts) {
           settled = true;
           clearTimeout(t);
           signal.removeEventListener("abort", onAbort);
-          resolve2();
+          resolve3();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -5417,7 +5432,8 @@ var AutonomousRunner = class {
 init_atomic_write();
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
-  return path3.join(projectRoot, ".wrongstack", "goal.json");
+  const hash = createHash("sha256").update(path3.resolve(projectRoot)).digest("hex").slice(0, 12);
+  return path3.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
 }
 async function loadGoal(filePath) {
   let raw;
@@ -6032,7 +6048,7 @@ ${recentJournal}` : "No prior iterations.",
   }
 };
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/coordination/subagent-budget.ts
@@ -6169,12 +6185,12 @@ var SubagentBudget = class _SubagentBudget {
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
-          return new Promise((resolve2) => {
+          return new Promise((resolve3) => {
             let resolved = false;
             const respond = (d) => {
               if (resolved) return;
               resolved = true;
-              resolve2(d);
+              resolve3(d);
             };
             const fallback = setTimeout(
               () => respond("stop"),
@@ -9172,7 +9188,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -9181,7 +9197,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve2(result);
+              resolve3(result);
             }
           };
           this.on("task.completed", handler);
@@ -9582,7 +9598,7 @@ function providerErrorToSubagentError(err, message, cause) {
 
 // src/execution/parallel-eternal-engine.ts
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
@@ -10171,7 +10187,7 @@ var InMemoryAgentBridge = class {
       );
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -10183,7 +10199,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         timer
       });
@@ -11311,11 +11327,11 @@ var Director = class {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve2;
+        let resolve3;
         const promise = new Promise((res) => {
-          resolve2 = res;
+          resolve3 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve2 });
+        this.taskWaiters.set(id, { promise, resolve: resolve3 });
         return promise;
       })
     );
@@ -11631,7 +11647,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve2) => {
+        const result = await new Promise((resolve3) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -11640,7 +11656,7 @@ function createDelegateTool(opts) {
             if (timer) clearTimeout(timer);
             offTool();
             offIter();
-            resolve2(value);
+            resolve3(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -14830,6 +14846,276 @@ function createAutoExecutor(opts) {
   });
 }
 
+// src/sdd/sdd-task-decomposer.ts
+var SddTaskDecomposer = class {
+  constructor(tracker, graph, opts = {}) {
+    this.tracker = tracker;
+    this.graph = graph;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+  }
+  tracker;
+  graph;
+  slots;
+  wave = 0;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /**
+   * Return the next batch of runnable tasks.
+   * Returns `allDone: true` when every node is completed.
+   * Returns `deadlocked: true` when no batch can be produced because
+   * all remaining tasks are blocked by failed nodes.
+   */
+  nextBatch() {
+    if (this.isDone()) {
+      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
+    }
+    const pending = this.pendingReadyNodes();
+    if (pending.length === 0) {
+      const hasBlockedTasks = this.hasAnyBlockedTasks();
+      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
+    }
+    const batch = pending.slice(0, this.slots);
+    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
+  }
+  /**
+   * Advance the wave counter after a batch completes.
+   * Call this once per `nextBatch()` result that was fan-out.
+   */
+  acknowledgeBatch(_completedTaskIds) {
+    this.wave++;
+  }
+  /**
+   * True when every node in the graph is completed.
+   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+   */
+  isDone() {
+    const progress = this.tracker.getProgress();
+    return progress.total > 0 && progress.completed === progress.total;
+  }
+  /**
+   * Total waves produced so far.
+   */
+  getWaveCount() {
+    return this.wave;
+  }
+  // -------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------
+  /**
+   * Return pending nodes whose blockers are all completed.
+   * Sorted by priority (critical first), then by creation time.
+   */
+  pendingReadyNodes() {
+    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
+    const ready = [];
+    for (const node of allPending) {
+      if (this.tracker.canStart(node.id)) {
+        ready.push(node);
+      }
+    }
+    const priorityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    ready.sort((a, b) => {
+      const pr = priorityRank[a.priority] - priorityRank[b.priority];
+      if (pr !== 0) return pr;
+      return a.createdAt - b.createdAt;
+    });
+    return ready;
+  }
+  /** True when at least one non-completed, non-failed task is blocked. */
+  hasAnyBlockedTasks() {
+    const nodes = this.tracker.getAllNodes({
+      status: ["pending", "in_progress", "blocked"]
+    });
+    return nodes.some((n) => n.status === "blocked");
+  }
+};
+var SddParallelRun = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+    this.timeoutMs = opts.taskTimeoutMs ?? 3e5;
+    this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
+  }
+  opts;
+  slots;
+  timeoutMs;
+  decomposer;
+  coordinator = null;
+  stopRequested = false;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /** Trigger stop — causes run() to abort after the current wave. */
+  stop() {
+    this.stopRequested = true;
+    this.coordinator?.stopAll();
+  }
+  /** Execute all waves until completion or deadlock. Returns final summary. */
+  async run() {
+    this.stopRequested = false;
+    const startTime = Date.now();
+    let totalCompleted = 0;
+    let totalFailed = 0;
+    let totalWaves = 0;
+    this.buildCoordinator();
+    while (!this.stopRequested && !this.decomposer.isDone()) {
+      const batch = this.decomposer.nextBatch();
+      if (batch.deadlocked) {
+        break;
+      }
+      if (batch.tasks.length === 0 && batch.allDone) {
+        break;
+      }
+      const waveResult = await this.executeWave(batch);
+      totalWaves++;
+      totalCompleted += waveResult.successCount;
+      totalFailed += waveResult.failCount;
+      this.decomposer.acknowledgeBatch(batch.tasks.map((t) => t.id));
+      this.opts.onWave?.(waveResult);
+      const progress = this.buildProgress();
+      this.opts.onProgress?.(progress);
+      if (this.stopRequested) break;
+    }
+    const finalProgress = this.opts.tracker.getProgress();
+    return {
+      totalWaves,
+      totalCompleted,
+      totalFailed,
+      totalDurationMs: Date.now() - startTime,
+      deadlocked: !this.decomposer.isDone() && this.stopRequested === false,
+      stopRequested: this.stopRequested,
+      finalProgress
+    };
+  }
+  // -------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------
+  buildCoordinator() {
+    const config = {
+      coordinatorId: `sdd-parallel-${randomUUID().slice(0, 8)}`,
+      maxConcurrent: this.slots,
+      doneCondition: { type: "all_tasks_done" }
+    };
+    this.coordinator = new DefaultMultiAgentCoordinator(config);
+    const runner = makeAgentSubagentRunner({ factory: this.opts.subagentFactory ?? this.defaultFactory() });
+    this.coordinator.setRunner?.(runner);
+  }
+  defaultFactory() {
+    return async (config) => ({
+      agent: this.opts.agent,
+      events: this.opts.agent.events
+    });
+  }
+  async executeWave(batch) {
+    const wave = batch.wave;
+    const tasks = batch.tasks;
+    const waveStart = Date.now();
+    for (const task of tasks) {
+      this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    }
+    const progress = computeTaskProgress(this.opts.graph);
+    const taskIds = tasks.map(() => randomUUID());
+    const subagentIds = tasks.map((_, i) => `sdd-wave${wave}-${i}`);
+    const directivePreamble = [
+      "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
+      "",
+      `Wave ${wave + 1} of ~${Math.ceil(progress.total / this.slots)}`,
+      `Graph: ${this.opts.graph.title}`,
+      `Parallel slots: ${tasks.length}`,
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
+      "\u2022 Mark the task [done] in the tracker when complete.",
+      "\u2022 Do not ask for confirmation.",
+      "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
+    ].join("\n");
+    const spawns = subagentIds.map(
+      (subagentId) => this.coordinator.spawn({
+        id: subagentId,
+        name: subagentId,
+        role: "executor",
+        timeoutMs: this.timeoutMs
+      })
+    );
+    const spawnResults = await Promise.all(spawns);
+    if (!spawnResults.every((r) => r.subagentId)) {
+      throw new Error("One or more subagent spawns failed");
+    }
+    const assignPromises = tasks.map((task, i) => {
+      const spec = {
+        id: taskIds[i],
+        description: [
+          directivePreamble,
+          "",
+          `\u2500\u2500 TASK ${i + 1}/${tasks.length} \u2500\u2500`,
+          `[${task.priority.toUpperCase()}] ${task.title}`,
+          "",
+          task.description
+        ].join("\n"),
+        subagentId: subagentIds[i],
+        timeoutMs: this.timeoutMs
+      };
+      return this.coordinator.assign(spec);
+    });
+    await Promise.all(assignPromises);
+    let results;
+    try {
+      results = await this.coordinator.awaitTasks(taskIds);
+    } catch (err) {
+      results = taskIds.map((id) => ({
+        subagentId: "",
+        taskId: id,
+        status: "failed",
+        error: { kind: "unknown", message: String(err), retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      }));
+    }
+    const successCount = results.filter((r) => r.status === "success").length;
+    const failCount = results.length - successCount;
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const taskId = taskIds[i];
+      if (result.status === "success") {
+        this.opts.tracker.updateNodeStatus(taskId, "completed");
+      } else {
+        const errMsg = result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error";
+        this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+      }
+    }
+    return {
+      wave,
+      batch,
+      results,
+      successCount,
+      failCount,
+      durationMs: Date.now() - waveStart,
+      stopRequested: this.stopRequested
+    };
+  }
+  buildProgress() {
+    const gp = this.opts.tracker.getProgress();
+    return {
+      wave: this.decomposer.getWaveCount(),
+      total: gp.total,
+      completed: gp.completed,
+      inProgress: gp.inProgress,
+      failed: gp.failed,
+      blocked: gp.blocked,
+      pending: gp.pending,
+      percent: gp.percentComplete,
+      deadlocked: false
+    };
+  }
+};
+
 // src/observability/metrics.ts
 var RESERVOIR_SIZE = 1024;
 function labelKey(labels) {
@@ -14989,9 +15275,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve2) => {
+    const timeout = new Promise((resolve3) => {
       timer = setTimeout(
-        () => resolve2({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve3({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -15230,14 +15516,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve2();
+      resolve3();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -15249,8 +15535,8 @@ async function startMetricsServer(opts) {
   return {
     port: boundPort,
     url: `${protocol}://${host}:${boundPort}${path18}`,
-    close: () => new Promise((resolve2, reject) => {
-      server.close((err) => err ? reject(err) : resolve2());
+    close: () => new Promise((resolve3, reject) => {
+      server.close((err) => err ? reject(err) : resolve3());
     })
   };
 }
@@ -15868,6 +16154,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, makeLLMClassifier, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, makeLLMClassifier, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map