@wrongstack/core 0.8.2 → 0.8.5

package/dist/index.js

@@ -93,7 +93,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve6) => setTimeout(resolve6, delays[i]));
+      await new Promise((resolve7) => setTimeout(resolve7, delays[i]));
     }
   }
   throw lastErr;
@@ -2692,7 +2692,7 @@ var InMemoryAgentBridge = class {
       );
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -2704,7 +2704,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve6,
+        resolve: resolve7,
         reject,
         timer
       });
@@ -2930,7 +2930,7 @@ var ToolExecutor = class {
         return { result, tool, durationMs: Date.now() - start };
       }
       if (hasMalformedArguments(use.input)) {
-        const result = this.malformedInputResult(use);
+        const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
@@ -3137,11 +3137,18 @@ var ToolExecutor = class {
       is_error: true
     };
   }
-  malformedInputResult(use) {
+  malformedInputResult(use, raw) {
+    let content = `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`;
+    if (raw) {
+      const max = 800;
+      const excerpt = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
+      content += ` Common cause: a string field (e.g. code in old_string/new_string) contains literal newlines, quotes, or backslashes that must be JSON-escaped, or the payload was cut off mid-stream. The raw arguments received were:
+${excerpt}`;
+    }
     return {
       type: "tool_result",
       tool_use_id: use.id,
-      content: `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`,
+      content,
       is_error: true
     };
   }
@@ -3197,6 +3204,18 @@ function hasMalformedArguments(input) {
   const keys = Object.keys(obj);
   return keys.length === 1 && MALFORMED_ARG_MARKERS.includes(keys[0]);
 }
+function extractMalformedRaw(input) {
+  if (!hasMalformedArguments(input)) return void 0;
+  const obj = input;
+  const value = obj[Object.keys(obj)[0]];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
@@ -3536,6 +3555,7 @@ function sanitizeJsonString(s) {
   let out = s.trim();
   out = stripSingleLineComments(out);
   out = out.replace(/,(\s*[}\]])/g, "$1");
+  out = escapeControlCharsInStrings(out);
   try {
     JSON.parse(out);
     return out;
@@ -3543,6 +3563,43 @@ function sanitizeJsonString(s) {
     return null;
   }
 }
+function escapeControlCharsInStrings(s) {
+  let inString = false;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' && (i === 0 || s[i - 1] !== "\\")) {
+      inString = !inString;
+      out += c;
+      continue;
+    }
+    const code = c.charCodeAt(0);
+    if (inString && code < 32) {
+      switch (c) {
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+      }
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
 function stripSingleLineComments(s) {
   let inString = false;
   const chars = [];
@@ -3868,7 +3925,8 @@ function resolveWstackPaths(opts) {
     projectSpecs: path6.join(projectDir, "specs"),
     projectTaskGraphs: path6.join(projectDir, "task-graphs"),
     projectSddSession: path6.join(projectDir, "sdd-session.json"),
-    projectPlan: path6.join(projectDir, "plan.json")
+    projectPlan: path6.join(projectDir, "plan.json"),
+    projectAutophase: path6.join(projectDir, "autophase")
   };
 }
 
@@ -3965,11 +4023,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path26, errors) {
+function walk2(value, schema, path28, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path26 || "<root>",
+        path: path28 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3978,7 +4036,7 @@ function walk2(value, schema, path26, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path26 || "<root>",
+        path: path28 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3988,19 +4046,19 @@ function walk2(value, schema, path26, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path26, req), message: "required property missing" });
+        errors.push({ path: joinPath(path28, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path26, key), errors);
+          walk2(obj[key], subSchema, joinPath(path28, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path26}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path28}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -5321,9 +5379,7 @@ var RecoveryLock = class {
       hostname: this.hostname,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const tmp = `${this.file}.tmp`;
-    await fsp2.writeFile(tmp, JSON.stringify(lock), { mode: 384 });
-    await fsp2.rename(tmp, this.file);
+    await atomicWrite(this.file, JSON.stringify(lock), { mode: 384 });
   }
   /**
    * Release the lock. Idempotent — silently succeeds if the file is
@@ -6565,8 +6621,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
       try {
         await Promise.race([
           Promise.resolve(iter.return?.()),
-          new Promise((resolve6) => {
-            drainTimer = setTimeout(resolve6, 500);
+          new Promise((resolve7) => {
+            drainTimer = setTimeout(resolve7, 500);
           })
         ]);
       } finally {
@@ -6627,7 +6683,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve6, reject) => {
+      await new Promise((resolve7, reject) => {
         let settled = false;
         const onAbort = () => {
           if (settled) return;
@@ -6640,7 +6696,7 @@ async function runProviderWithRetry(opts) {
           settled = true;
           clearTimeout(t2);
           signal.removeEventListener("abort", onAbort);
-          resolve6();
+          resolve7();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -7303,12 +7359,18 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   policyProvider;
   /**
-   * Overhead factor applied to the rough message-token estimate to produce a
-   * figure comparable to the real API request size (system prompt + tool defs).
-   * Without this factor, raw message tokens undercount real load by 15-50% in
-   * short conversations, causing premature compaction triggers.
+   * Calibration factor applied to the estimator output. The estimator is now
+   * expected to already include messages + system prompt + tool definitions
+   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+   * as a constant so a future calibration against real provider tokenization
+   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+   * threshold-check math.
+   *
+   * Historical note: was 1.3 when the estimator only counted messages — that
+   * double-counted system+tools once the estimator was upgraded, firing
+   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
    */
-  static OVERHEAD_FACTOR = 1.3;
+  static OVERHEAD_FACTOR = 1;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -8255,8 +8317,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink10 } = await import('fs/promises');
-      await unlink10(this.goalPath);
+      const { unlink: unlink12 } = await import('fs/promises');
+      await unlink12(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -8278,7 +8340,7 @@ ${recentJournal}` : "No prior iterations.",
   }
 };
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 
 // src/coordination/subagent-budget.ts
@@ -8428,12 +8490,12 @@ var SubagentBudget = class _SubagentBudget {
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
-          return new Promise((resolve6) => {
+          return new Promise((resolve7) => {
             let resolved = false;
             const respond = (d) => {
               if (resolved) return;
               resolved = true;
-              resolve6(d);
+              resolve7(d);
             };
             const fallback = setTimeout(
               () => respond("stop"),
@@ -11474,7 +11536,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((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -11483,7 +11545,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve6(result);
+              resolve7(result);
             }
           };
           this.on("task.completed", handler);
@@ -11913,7 +11975,7 @@ function providerErrorToSubagentError(err, message, cause) {
 
 // src/execution/parallel-eternal-engine.ts
 function sleep2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
@@ -12694,7 +12756,7 @@ function makeSpawnTool(director, roster) {
           catalog: roster
         });
         const dispatchRole = dispatchResult.role;
-        if (roster && roster[dispatchRole]) {
+        if (roster?.[dispatchRole]) {
           cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
         } else {
           const def = dispatchResult.definition;
@@ -13184,6 +13246,13 @@ var Director = class {
         extendCounts.delete(guardKey);
         return;
       }
+      if (payload.kind === "cost" && this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+        const totalCost = this.usage.snapshot().total?.cost ?? 0;
+        if (totalCost >= this.maxFleetCostUsd) {
+          payload.deny();
+          return;
+        }
+      }
       extendCounts.set(guardKey, prior + 1);
       setImmediate(() => {
         const extra = {};
@@ -13548,11 +13617,11 @@ var Director = class {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve6;
+        let resolve7;
         const promise = new Promise((res) => {
-          resolve6 = res;
+          resolve7 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve6 });
+        this.taskWaiters.set(id, { promise, resolve: resolve7 });
         return promise;
       })
     );
@@ -13868,7 +13937,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve6) => {
+        const result = await new Promise((resolve7) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -13877,7 +13946,7 @@ function createDelegateTool(opts) {
             if (timer) clearTimeout(timer);
             offTool();
             offIter();
-            resolve6(value);
+            resolve7(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -14682,6 +14751,13 @@ var TaskTracker = class {
   opts;
   graph = null;
   transitions = [];
+  /**
+   * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
+   * with a phase's pre-built task graph without re-creating it).
+   */
+  setGraph(graph) {
+    this.graph = graph;
+  }
   async createGraph(specId, title) {
     this.graph = {
       id: crypto.randomUUID(),
@@ -14754,10 +14830,6 @@ var TaskTracker = class {
     this.graph.updatedAt = now;
     this.persist();
   }
-  /**
-   * Update node fields (title, description, priority, estimateHours, tags).
-   * Does NOT change status. Use updateNodeStatus for status changes.
-   */
   updateNode(id, patch) {
     if (!this.graph) throw new Error("No graph loaded");
     const node = this.graph.nodes.get(id);
@@ -14835,8 +14907,7 @@ var TaskTracker = class {
     }
     return computeTaskProgress(this.graph);
   }
-  getTransitions(taskId) {
-    if (!taskId) return [...this.transitions];
+  getTransitions(_taskId) {
     return [...this.transitions];
   }
   unblockDependents(completedId) {
@@ -14876,18 +14947,12 @@ var TaskTracker = class {
    * Fire-and-forget persistence with attached error handler.
    * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
    * avoid forcing an async cascade through every caller; if the store
-   * rejects, the configured `onPersistError` is invoked so failures are
-   * surfaced instead of swallowed by an unhandled promise rejection.
+   * is missing or throwing, the error is surfaced via onPersistError.
    */
   persist() {
     if (!this.graph) return;
     this.opts.store.saveGraph(this.graph).catch((err) => {
-      if (this.opts.onPersistError) this.opts.onPersistError(err);
-      else
-        console.warn(
-          "[task-tracker] saveGraph failed:",
-          err instanceof Error ? err.message : String(err)
-        );
+      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn("[task-tracker] saveGraph failed:", err instanceof Error ? err.message : String(err));
     });
   }
 };
@@ -15508,10 +15573,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      const path26 = await import('path');
+      const fsp18 = await import('fs/promises');
+      const path28 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp16.mkdir(path26.dirname(this.sessionPath), { recursive: true });
+      await fsp18.mkdir(path28.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -15520,8 +15585,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp16 = await import('fs/promises');
-      const raw = await fsp16.readFile(this.sessionPath, "utf8");
+      const fsp18 = await import('fs/promises');
+      const raw = await fsp18.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -15535,8 +15600,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      await fsp16.unlink(this.sessionPath);
+      const fsp18 = await import('fs/promises');
+      await fsp18.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -16221,15 +16286,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path26 = [];
+  const path28 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path26.unshift(current);
+    path28.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path26;
+  return path28;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17024,9 +17089,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve6) => {
+    const timeout = new Promise((resolve7) => {
       timer = setTimeout(
-        () => resolve6({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve7({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -17209,7 +17274,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path26 = opts.path ?? "/metrics";
+  const path28 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -17219,7 +17284,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path26) {
+    if (url === path28) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -17265,14 +17330,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve6();
+      resolve7();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -17283,9 +17348,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path26}`,
-    close: () => new Promise((resolve6, reject) => {
-      server.close((err) => err ? reject(err) : resolve6());
+    url: `${protocol}://${host}:${boundPort}${path28}`,
+    close: () => new Promise((resolve7, reject) => {
+      server.close((err) => err ? reject(err) : resolve7());
     })
   };
 }
@@ -17984,6 +18049,12 @@ async function extractTar(buf, destDir) {
     const relPath = stripTopDir(fullPath);
     if (relPath && relPath !== "." && relPath !== "..") {
       const destPath = path6.join(destDir, relPath);
+      const resolvedDest = path6.resolve(destPath);
+      const resolvedRoot = path6.resolve(destDir);
+      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path6.sep)) {
+        offset += 512 + Math.ceil(size / 512) * 512;
+        continue;
+      }
       if (typeflag === 53 || typeflag === 0) {
         if (relPath.endsWith("/") || typeflag === 53) {
           await fsp2.mkdir(destPath, { recursive: true });
@@ -19403,8 +19474,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir11 } = await import('fs/promises');
-      await mkdir11(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir13 } = await import('fs/promises');
+      await mkdir13(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -19680,7 +19751,7 @@ var SecurityScannerOrchestrator = class {
       const delay = Math.round(policy.delayMs(attempt));
       const status = isProviderErr ? err.status : 0;
       console.warn(`[SecurityScanner] retry ${attempt + 1} after ${delay}ms (status=${status}) \u2014 ${errAsErr.message}`);
-      await new Promise((resolve6) => setTimeout(resolve6, delay));
+      await new Promise((resolve7) => setTimeout(resolve7, delay));
       return this.completeWithRetry(provider, request, abortController, attempt + 1);
     }
   }
@@ -20326,16 +20397,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile30 } = await import('fs/promises');
-      const content = await readFile30(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile32 } = await import('fs/promises');
+      const content = await readFile32(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile30 } = await import('fs/promises');
-      const content = await readFile30(join(reportsDir, match), "utf-8");
+      const { readFile: readFile32 } = await import('fs/promises');
+      const content = await readFile32(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -21177,12 +21248,12 @@ function makeContinueToNextIterationTool() {
 // src/core/iteration-limit.ts
 function requestLimitExtension(opts) {
   const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let resolved = false;
     const timerFired = () => {
       if (!resolved) {
         resolved = true;
-        resolve6(0);
+        resolve7(0);
       }
     };
     const timer = setTimeout(timerFired, timeoutMs);
@@ -21191,14 +21262,14 @@ function requestLimitExtension(opts) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve6(0);
+        resolve7(0);
       }
     };
     const grant = (extra) => {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve6(Math.max(0, extra));
+        resolve7(Math.max(0, extra));
       }
     };
     events.emit("iteration.limit_reached", {
@@ -21212,7 +21283,7 @@ function requestLimitExtension(opts) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve6(100);
+          resolve7(100);
         }
       });
     }
@@ -21781,13 +21852,13 @@ var Agent = class {
     }
   }
   waitForConfirm(info) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       this.events.emit("tool.confirm_needed", {
         tool: info.tool,
         input: info.input,
         toolUseId: info.toolUseId,
         suggestedPattern: info.suggestedPattern,
-        resolve: resolve6
+        resolve: resolve7
       });
     });
   }
@@ -22504,12 +22575,12 @@ ${mem}`);
     }
   }
   async gitStatus(root) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       let settled = false;
       const finish = (s) => {
         if (settled) return;
         settled = true;
-        resolve6(s);
+        resolve7(s);
       };
       let proc;
       const timer = setTimeout(() => {
@@ -23261,6 +23332,1174 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+// src/autophase/phase-graph-builder.ts
+var PhaseGraphBuilder = class _PhaseGraphBuilder {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async build() {
+    const graphId = crypto.randomUUID();
+    const phases = /* @__PURE__ */ new Map();
+    const phaseIds = [];
+    for (let i = 0; i < this.opts.phases.length; i++) {
+      const tmpl = this.opts.phases[i];
+      const phaseId = crypto.randomUUID();
+      phaseIds.push(phaseId);
+      const store = this.opts.externalTaskStore ?? new DefaultTaskStore();
+      const tracker = new TaskTracker({ store });
+      const taskGraph = await tracker.createGraph(phaseId, `${tmpl.name} Tasks`);
+      if (tmpl.taskTemplates && tmpl.taskTemplates.length > 0) {
+        for (const tt of tmpl.taskTemplates) {
+          tracker.addNode({
+            title: tt.title,
+            description: tt.description,
+            type: tt.type,
+            priority: tt.priority,
+            status: "pending",
+            estimateHours: tt.estimateHours,
+            tags: tt.tags ?? []
+          });
+        }
+      }
+      const phase = {
+        id: phaseId,
+        name: tmpl.name,
+        description: tmpl.description,
+        status: "pending",
+        taskGraph,
+        dependsOn: i > 0 ? [phaseIds[i - 1]] : [],
+        nextPhases: i < this.opts.phases.length - 1 ? [phaseIds[i + 1]] : [],
+        parallelizable: tmpl.parallelizable,
+        priority: tmpl.priority,
+        estimateHours: tmpl.estimateHours,
+        assignedAgents: [],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      phases.set(phaseId, phase);
+    }
+    const phaseArray = Array.from(phases.values());
+    for (let i = 0; i < phaseArray.length; i++) {
+      const phase = phaseArray[i];
+      phase.nextPhases = i < phaseArray.length - 1 ? [phaseArray[i + 1].id] : [];
+      phase.dependsOn = i > 0 ? [phaseArray[i - 1].id] : [];
+    }
+    const graph = {
+      id: graphId,
+      title: this.opts.title,
+      description: this.opts.description ?? "",
+      phases,
+      rootPhaseIds: phaseIds.length > 0 ? [phaseIds[0]] : [],
+      activePhaseIds: [],
+      completedPhaseIds: [],
+      failedPhaseIds: [],
+      autonomous: this.opts.autonomous ?? true,
+      stopOnComplete: true,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    return graph;
+  }
+  /**
+   * Var olan bir TaskGraph'tan fazlar oluştur.
+   * Task'ları priority/type göre gruplayarak fazlara ayırır.
+   */
+  static fromTaskGraph(taskGraph, options) {
+    const tasksPerPhase = options.tasksPerPhase ?? 5;
+    const nodes = Array.from(taskGraph.nodes.values());
+    const sorted = [...nodes].sort((a, b) => {
+      const prioOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (prioOrder[a.priority] ?? 4) - (prioOrder[b.priority] ?? 4);
+    });
+    const groups = [];
+    for (let i = 0; i < sorted.length; i += tasksPerPhase) {
+      groups.push(sorted.slice(i, i + tasksPerPhase));
+    }
+    const phaseTemplates = groups.map((group, idx) => {
+      const hasCritical = group.some((t2) => t2.priority === "critical");
+      const totalHours = group.reduce((sum, t2) => sum + (t2.estimateHours ?? 2), 0);
+      return {
+        name: `Phase ${idx + 1}: ${group[0]?.title.slice(0, 30) ?? "Tasks"}`,
+        description: group.map((t2) => t2.title).join(", "),
+        priority: hasCritical ? "critical" : "high",
+        estimateHours: totalHours,
+        parallelizable: false,
+        taskTemplates: group.map((t2) => ({
+          title: t2.title,
+          description: t2.description,
+          type: t2.type,
+          priority: t2.priority,
+          estimateHours: t2.estimateHours ?? 2,
+          tags: t2.tags ?? []
+        }))
+      };
+    });
+    const builder = new _PhaseGraphBuilder({
+      ...options,
+      phases: phaseTemplates
+    });
+    return builder.build();
+  }
+};
+
+// src/autophase/phase-orchestrator.ts
+var PhaseOrchestrator = class {
+  graph;
+  ctx;
+  opts;
+  events;
+  stopped = false;
+  paused = false;
+  runningPhases = /* @__PURE__ */ new Set();
+  tickInterval = null;
+  trackerCache = /* @__PURE__ */ new Map();
+  taskRetryCounts = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.ctx = opts.ctx;
+    this.events = opts.events ?? this.createNoopEventBus();
+    this.opts = {
+      maxConcurrentPhases: opts.maxConcurrentPhases ?? 1,
+      maxConcurrentTasks: opts.maxConcurrentTasks ?? 2,
+      maxRetries: opts.maxRetries ?? 2,
+      autonomous: opts.autonomous ?? true,
+      phaseDelayMs: opts.phaseDelayMs ?? 0,
+      stopOnFailure: opts.stopOnFailure ?? true,
+      events: this.events
+    };
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Tüm faz akışını başlat.
+   * Autonomous mode'da: kök faz(lar)ı başlatır, bitince sonrakini otomatik başlatır.
+   */
+  async start() {
+    this.stopped = false;
+    this.paused = false;
+    this.graph.startedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    let readyPhases = this.getReadyPhases();
+    while (readyPhases.length > 0 && !this.stopped) {
+      const batch = readyPhases.slice(0, this.opts.maxConcurrentPhases);
+      await Promise.all(batch.map((p) => this.startPhase(p)));
+      if (this.opts.phaseDelayMs > 0) {
+        await this.delay(this.opts.phaseDelayMs);
+      }
+      readyPhases = this.getReadyPhases().filter(
+        (p) => !this.runningPhases.has(p.id) && p.status !== "completed" && p.status !== "failed"
+      );
+    }
+    if (this.opts.autonomous) {
+      this.tickInterval = setInterval(() => this.tick(), 1e3);
+    }
+  }
+  /** Duraklat — aktif fazlar çalışmaya devam eder ama yeni faz başlamaz */
+  pause() {
+    this.paused = true;
+  }
+  /** Devam et — yeni fazlar başlayabilir */
+  resume() {
+    this.paused = false;
+    this.tick().catch((err) => {
+      console.error("[phase-orchestrator] tick failed:", err instanceof Error ? err.message : String(err));
+    });
+  }
+  /** Tamamen durdur — aktif fazlar da durdurulur */
+  stop() {
+    this.stopped = true;
+    if (this.tickInterval) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+    for (const phaseId of this.runningPhases) {
+      const phase = this.graph.phases.get(phaseId);
+      if (phase) {
+        this.updatePhaseStatus(phase, "paused");
+      }
+    }
+  }
+  // ─── Tick Loop (Autonomous) ───────────────────────────────────────────────
+  async tick() {
+    if (this.stopped || this.paused) return;
+    const active = this.getActivePhases();
+    const queued = this.getReadyPhases();
+    this.emit("autonomous.tick", {
+      activePhases: active.map((p) => p.id),
+      queuedPhases: queued.map((p) => p.id)
+    });
+    this.ctx.onTick?.({ activePhases: active, readyPhases: queued });
+    const availableSlots = this.opts.maxConcurrentPhases - active.length;
+    if (availableSlots > 0 && queued.length > 0) {
+      for (const phase of queued.slice(0, availableSlots)) {
+        if (phase.status === "pending") {
+          await this.startPhase(phase);
+        }
+      }
+    }
+    if (this.isComplete()) {
+      this.onGraphComplete();
+      return;
+    }
+    if (this.opts.stopOnFailure && this.graph.failedPhaseIds.length > 0) {
+      const failedPhase = this.graph.phases.get(this.graph.failedPhaseIds[0]);
+      if (failedPhase) {
+        this.onGraphFailed(failedPhase);
+      }
+      return;
+    }
+  }
+  // ─── Phase Execution ──────────────────────────────────────────────────────
+  async startPhase(phase) {
+    if (phase.status !== "pending" && phase.status !== "ready") return;
+    this.updatePhaseStatus(phase, "running");
+    phase.startedAt = Date.now();
+    this.runningPhases.add(phase.id);
+    this.graph.activePhaseIds.push(phase.id);
+    this.emit("phase.started", { phaseId: phase.id, name: phase.name });
+    try {
+      await this.executePhaseTasks(phase);
+      const failedTasks = this.getFailedTaskCount(phase);
+      const completedTasks = this.getCompletedTaskCount(phase);
+      this.emit("phase.allTasksDone", {
+        phaseId: phase.id,
+        completed: completedTasks,
+        failed: failedTasks
+      });
+      if (failedTasks > 0 && this.opts.stopOnFailure) {
+        this.updatePhaseStatus(phase, "failed");
+        phase.completedAt = Date.now();
+        phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+        this.runningPhases.delete(phase.id);
+        this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+        this.emit("phase.failed", {
+          phaseId: phase.id,
+          name: phase.name,
+          error: `${failedTasks} task(s) failed`
+        });
+        this.ctx.onPhaseFail?.(phase, new Error(`${failedTasks} task(s) failed`));
+      } else {
+        this.updatePhaseStatus(phase, "completed");
+        phase.completedAt = Date.now();
+        phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+        this.runningPhases.delete(phase.id);
+        this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+        this.graph.completedPhaseIds.push(phase.id);
+        this.emit("phase.completed", {
+          phaseId: phase.id,
+          name: phase.name,
+          durationMs: phase.actualDurationMs
+        });
+        this.ctx.onPhaseComplete?.(phase);
+      }
+    } catch (error) {
+      this.updatePhaseStatus(phase, "failed");
+      phase.completedAt = Date.now();
+      phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+      this.runningPhases.delete(phase.id);
+      this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+      this.graph.failedPhaseIds.push(phase.id);
+      this.emit("phase.failed", {
+        phaseId: phase.id,
+        name: phase.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.ctx.onPhaseFail?.(phase, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async executePhaseTasks(phase) {
+    const pendingTasks = this.getExecutableTasks(phase);
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, this.opts.maxConcurrentTasks);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, phase))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "fulfilled") {
+          this.markTaskCompleted(phase, task);
+        } else {
+          this.markTaskFailed(phase, task, result.reason);
+        }
+      }
+      const newReady = this.getExecutableTasks(phase);
+      pendingTasks.length = 0;
+      pendingTasks.push(...newReady);
+    }
+  }
+  async executeSingleTask(task, phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "in_progress");
+    return this.ctx.executeTask(task, phase.id);
+  }
+  markTaskCompleted(phase, task) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "completed");
+    this.emit("phase.taskCompleted", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title
+    });
+  }
+  markTaskFailed(phase, task, error) {
+    const tracker = this.getTrackerForPhase(phase);
+    const taskKey = `${phase.id}:${task.id}`;
+    const currentRetries = this.taskRetryCounts.get(taskKey) ?? 0;
+    if (currentRetries < this.opts.maxRetries) {
+      this.taskRetryCounts.set(taskKey, currentRetries + 1);
+      tracker.updateNodeStatus(task.id, "pending", `Retry ${currentRetries + 1}/${this.opts.maxRetries}`);
+      this.emit("phase.taskRetrying", {
+        phaseId: phase.id,
+        taskId: task.id,
+        taskTitle: task.title,
+        attempt: currentRetries + 1,
+        maxRetries: this.opts.maxRetries
+      });
+    } else {
+      tracker.updateNodeStatus(task.id, "failed", error instanceof Error ? error.message : String(error));
+      this.emit("phase.taskFailed", {
+        phaseId: phase.id,
+        taskId: task.id,
+        taskTitle: task.title,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  getReadyPhases() {
+    const ready = [];
+    for (const phase of this.graph.phases.values()) {
+      if (phase.status !== "pending") continue;
+      const depsDone = phase.dependsOn.every((depId) => {
+        const dep = this.graph.phases.get(depId);
+        return dep?.status === "completed" || dep?.status === "skipped";
+      });
+      if (depsDone || phase.parallelizable) {
+        ready.push(phase);
+      }
+    }
+    const prioOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    ready.sort((a, b) => (prioOrder[a.priority] ?? 4) - (prioOrder[b.priority] ?? 4));
+    return ready;
+  }
+  getActivePhases() {
+    return Array.from(this.graph.phases.values()).filter((p) => p.status === "running");
+  }
+  getExecutableTasks(phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    return tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && tracker.canStart(n.id)).sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+    });
+  }
+  getTrackerForPhase(phase) {
+    if (this.trackerCache.has(phase.id)) {
+      return this.trackerCache.get(phase.id);
+    }
+    const store = new DefaultTaskStore();
+    const tracker = new TaskTracker({ store });
+    tracker.setGraph(phase.taskGraph);
+    this.trackerCache.set(phase.id, tracker);
+    return tracker;
+  }
+  getFailedTaskCount(phase) {
+    return this.getTrackerForPhase(phase).getAllNodes({ status: ["failed"] }).length;
+  }
+  getCompletedTaskCount(phase) {
+    return this.getTrackerForPhase(phase).getAllNodes({ status: ["completed"] }).length;
+  }
+  updatePhaseStatus(phase, status) {
+    const from = phase.status;
+    phase.status = status;
+    phase.updatedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.statusChange", { phaseId: phase.id, from, to: status });
+  }
+  isComplete() {
+    const allPhases = Array.from(this.graph.phases.values());
+    return allPhases.every(
+      (p) => p.status === "completed" || p.status === "skipped" || p.status === "failed"
+    );
+  }
+  onGraphComplete() {
+    this.graph.completedAt = Date.now();
+    const durationMs = this.graph.completedAt - (this.graph.startedAt ?? this.graph.completedAt);
+    this.emit("graph.completed", { graphId: this.graph.id, durationMs });
+    this.stop();
+  }
+  onGraphFailed(failedPhase) {
+    this.emit("graph.failed", {
+      graphId: this.graph.id,
+      failedPhaseId: failedPhase.id,
+      error: `Phase "${failedPhase.name}" failed`
+    });
+    this.stop();
+  }
+  // ─── Progress ─────────────────────────────────────────────────────────────
+  getProgress() {
+    const phases = Array.from(this.graph.phases.values());
+    let pending = 0;
+    let ready = 0;
+    let running = 0;
+    let paused = 0;
+    let completed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let totalTasks = 0;
+    let completedTasks = 0;
+    let failedTasks = 0;
+    let estimatedHours = 0;
+    let actualHours = 0;
+    for (const p of phases) {
+      switch (p.status) {
+        case "pending":
+          pending++;
+          break;
+        case "ready":
+          ready++;
+          break;
+        case "running":
+          running++;
+          break;
+        case "paused":
+          paused++;
+          break;
+        case "completed":
+          completed++;
+          break;
+        case "failed":
+          failed++;
+          break;
+        case "skipped":
+          skipped++;
+          break;
+      }
+      estimatedHours += p.estimateHours;
+      if (p.actualDurationMs) actualHours += p.actualDurationMs / 36e5;
+      const tracker = this.getTrackerForPhase(p);
+      const progress = tracker.getProgress();
+      totalTasks += progress.total;
+      completedTasks += progress.completed;
+      failedTasks += progress.failed;
+    }
+    const totalPhases = phases.length;
+    const done = completed + skipped;
+    return {
+      totalPhases,
+      pending,
+      ready,
+      running,
+      paused,
+      completed,
+      failed,
+      skipped,
+      percentComplete: totalPhases > 0 ? Math.round(done / totalPhases * 100) : 0,
+      totalTasks,
+      completedTasks,
+      failedTasks,
+      estimatedHours,
+      actualHours
+    };
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return !this.stopped && this.runningPhases.size > 0;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  // ─── Agent Assignment ─────────────────────────────────────────────────────
+  assignAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    if (!phase.assignedAgents.includes(agentId)) {
+      phase.assignedAgents.push(agentId);
+      this.emit("agent.assigned", { phaseId, agentId });
+    }
+  }
+  releaseAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    phase.assignedAgents = phase.assignedAgents.filter((id) => id !== agentId);
+    this.emit("agent.released", { phaseId, agentId });
+  }
+  // ─── Events ───────────────────────────────────────────────────────────────
+  emit(event, payload) {
+    this.events.emit(event, payload);
+  }
+  createNoopEventBus() {
+    return {
+      emit: () => {
+      },
+      on: () => {
+      },
+      off: () => {
+      },
+      once: () => {
+      },
+      listeners: /* @__PURE__ */ new Map(),
+      wildcards: /* @__PURE__ */ new Set(),
+      setLogger: () => {
+      },
+      onAny: () => {
+      },
+      offAny: () => {
+      },
+      emitAsync: async () => [],
+      waitFor: async () => {
+      }
+    };
+  }
+  delay(ms) {
+    return new Promise((resolve7) => setTimeout(resolve7, ms));
+  }
+};
+
+// src/autophase/auto-phase-runner.ts
+var AutoPhaseRunner = class {
+  graph = null;
+  orchestrator = null;
+  opts;
+  progressInterval = null;
+  graphCompletedHandler = (payload) => {
+    const p = payload;
+    if (this.graph && p.graphId === this.graph.id) {
+      this.opts.onComplete?.(this.graph);
+      this.cleanup();
+    }
+  };
+  graphFailedHandler = (payload) => {
+    const p = payload;
+    if (this.graph && p.graphId === this.graph.id) {
+      const failedPhase = this.graph.phases.get(p.failedPhaseId);
+      if (failedPhase) {
+        this.opts.onFail?.(this.graph, failedPhase, new Error(p.error));
+      }
+      this.cleanup();
+    }
+  };
+  /** Stores the unsubscribe function returned by EventBus.on() */
+  unsubscribeCompleted = null;
+  unsubscribeFailed = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async start() {
+    const builder = new PhaseGraphBuilder({
+      title: this.opts.title,
+      description: this.opts.description,
+      phases: this.opts.phases,
+      autonomous: this.opts.autonomous,
+      stopOnFailure: this.opts.stopOnFailure
+    });
+    this.graph = await builder.build();
+    const ctx = {
+      executeTask: this.opts.executeTask,
+      onPhaseComplete: (phase) => {
+        this.opts.onPhaseComplete?.(phase);
+      },
+      onPhaseFail: (phase, error) => {
+        this.opts.onPhaseFail?.(phase, error);
+      },
+      onTick: (tickCtx) => {
+        this.opts.onTick?.(tickCtx);
+      }
+    };
+    this.orchestrator = new PhaseOrchestrator({
+      graph: this.graph,
+      ctx,
+      maxConcurrentPhases: this.opts.maxConcurrentPhases,
+      maxConcurrentTasks: this.opts.maxConcurrentTasks,
+      maxRetries: this.opts.maxRetries,
+      autonomous: this.opts.autonomous,
+      phaseDelayMs: this.opts.phaseDelayMs,
+      stopOnFailure: this.opts.stopOnFailure,
+      events: this.opts.events
+    });
+    if (this.opts.onProgress) {
+      this.progressInterval = setInterval(() => {
+        const progress = this.orchestrator.getProgress();
+        this.opts.onProgress(progress);
+      }, 2e3);
+    }
+    if (this.opts.events) {
+      const events = this.opts.events;
+      const onUntyped = events.on;
+      this.unsubscribeCompleted = onUntyped("graph.completed", this.graphCompletedHandler);
+      this.unsubscribeFailed = onUntyped("graph.failed", this.graphFailedHandler);
+    }
+    await this.orchestrator.start();
+    return this.graph;
+  }
+  pause() {
+    this.orchestrator?.pause();
+  }
+  resume() {
+    this.orchestrator?.resume();
+  }
+  stop() {
+    this.orchestrator?.stop();
+    this.cleanup();
+  }
+  getProgress() {
+    return this.orchestrator?.getProgress() ?? null;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return this.orchestrator?.isRunning() ?? false;
+  }
+  isPaused() {
+    return this.orchestrator?.isPaused() ?? false;
+  }
+  assignAgent(phaseId, agentId) {
+    this.orchestrator?.assignAgent(phaseId, agentId);
+  }
+  releaseAgent(phaseId, agentId) {
+    this.orchestrator?.releaseAgent(phaseId, agentId);
+  }
+  cleanup() {
+    if (this.progressInterval) {
+      clearInterval(this.progressInterval);
+      this.progressInterval = null;
+    }
+    this.unsubscribeCompleted?.();
+    this.unsubscribeCompleted = null;
+    this.unsubscribeFailed?.();
+    this.unsubscribeFailed = null;
+  }
+};
+async function createAutoPhaseFromTaskGraph(taskGraph, options) {
+  const graph = await PhaseGraphBuilder.fromTaskGraph(taskGraph, {
+    title: options.title ?? taskGraph.title,
+    tasksPerPhase: options.tasksPerPhase
+  });
+  const phases = Array.from(graph.phases.values()).map((p) => ({
+    name: p.name,
+    description: p.description,
+    priority: p.priority,
+    estimateHours: p.estimateHours,
+    parallelizable: p.parallelizable
+  }));
+  return new AutoPhaseRunner({
+    ...options,
+    title: options.title ?? taskGraph.title,
+    phases
+  });
+}
+
+// src/autophase/auto-phase-planner.ts
+var VALID_TASK_TYPES = /* @__PURE__ */ new Set([
+  "feature",
+  "bugfix",
+  "refactor",
+  "docs",
+  "test",
+  "chore"
+]);
+var VALID_PRIORITIES = /* @__PURE__ */ new Set([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var AutoPhasePlanner = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /** Hedefi faz+todo planına dönüştür. */
+  async plan() {
+    const prompt = this.buildPrompt();
+    const raw = await this.opts.runOnce(prompt);
+    const phases = this.parse(raw);
+    return { phases, raw, parseFailed: phases.length === 0 };
+  }
+  /** Modelin üreteceği plan için talimat prompt'u. */
+  buildPrompt() {
+    const minP = this.opts.minPhases ?? 3;
+    const maxP = this.opts.maxPhases ?? 8;
+    const todos = this.opts.todosPerPhase ?? 6;
+    const ctx = this.opts.projectContext?.trim();
+    return [
+      "You are an expert software project planner. Break the following goal into",
+      `a dependency-ordered list of ${minP}\u2013${maxP} PHASES. Each phase must contain`,
+      `roughly ${todos} concrete, individually-actionable TODO tasks.`,
+      "",
+      `GOAL: ${this.opts.goal}`,
+      ctx ? `
+PROJECT CONTEXT:
+${ctx}
+` : "",
+      "Rules:",
+      "- Phases run in order; earlier phases are prerequisites for later ones.",
+      "- Each todo must be small enough for one focused work session.",
+      "- Each todo must be self-contained (an agent will execute it in isolation).",
+      '- Prefer concrete verbs ("Add X", "Refactor Y", "Write tests for Z").',
+      "",
+      "Respond with ONLY a JSON array inside a ```json code fence. No prose before",
+      "or after. Schema (TypeScript):",
+      "",
+      "```json",
+      "[",
+      "  {",
+      '    "name": "Phase name",',
+      '    "description": "What this phase accomplishes",',
+      '    "priority": "critical" | "high" | "medium" | "low",',
+      '    "estimateHours": number,',
+      '    "parallelizable": boolean,',
+      '    "tasks": [',
+      "      {",
+      '        "title": "Short task title",',
+      '        "description": "What to do and how to know it is done",',
+      '        "type": "feature" | "bugfix" | "refactor" | "docs" | "test" | "chore",',
+      '        "priority": "critical" | "high" | "medium" | "low",',
+      '        "estimateHours": number,',
+      '        "tags": ["optional", "labels"]',
+      "      }",
+      "    ]",
+      "  }",
+      "]",
+      "```"
+    ].filter((l) => l !== "").join("\n");
+  }
+  /** Ham çıktıdan JSON'u çıkar, doğrula ve PhaseTemplate[]'e dönüştür. */
+  parse(raw) {
+    const json = extractJSONArray(raw);
+    if (!json) return [];
+    let data;
+    try {
+      data = JSON.parse(json);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(data)) return [];
+    const phases = [];
+    for (const entry of data) {
+      const phase = this.coercePhase(entry);
+      if (phase) phases.push(phase);
+    }
+    return phases;
+  }
+  coercePhase(entry) {
+    if (!entry || typeof entry !== "object") return null;
+    const e = entry;
+    const name = typeof e.name === "string" ? e.name.trim() : "";
+    if (!name) return null;
+    const rawTasks = Array.isArray(e.tasks) ? e.tasks : Array.isArray(e.taskTemplates) ? e.taskTemplates : [];
+    const taskTemplates = rawTasks.map((t2) => this.coerceTask(t2)).filter((t2) => t2 !== null);
+    return {
+      name,
+      description: typeof e.description === "string" ? e.description : "",
+      priority: coercePriority(e.priority),
+      estimateHours: coerceHours(e.estimateHours, 4),
+      parallelizable: e.parallelizable === true,
+      taskTemplates
+    };
+  }
+  coerceTask(t2) {
+    if (!t2 || typeof t2 !== "object") return null;
+    const o = t2;
+    const title = typeof o.title === "string" ? o.title.trim() : "";
+    if (!title) return null;
+    const type = VALID_TASK_TYPES.has(o.type) ? o.type : "feature";
+    return {
+      title,
+      description: typeof o.description === "string" ? o.description : "",
+      type,
+      priority: coercePriority(o.priority),
+      estimateHours: coerceHours(o.estimateHours, 2),
+      tags: Array.isArray(o.tags) ? o.tags.map(String) : []
+    };
+  }
+};
+function coercePriority(value) {
+  return VALID_PRIORITIES.has(value) ? value : "medium";
+}
+function coerceHours(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function extractJSONArray(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidates = [];
+  if (fence?.[1]) candidates.push(fence[1]);
+  candidates.push(text);
+  for (const candidate of candidates) {
+    const balanced = firstBalancedArray(candidate);
+    if (balanced) return balanced;
+  }
+  return null;
+}
+function firstBalancedArray(text) {
+  const start = text.indexOf("[");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "[") {
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+var PhaseStore = class {
+  baseDir;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+  }
+  async save(graph) {
+    const filePath = this.getFilePath(graph.id);
+    await fsp2.mkdir(path6.dirname(filePath), { recursive: true });
+    const serialized = this.serializeGraph(graph);
+    await fsp2.writeFile(filePath, JSON.stringify(serialized, null, 2), "utf8");
+  }
+  async load(graphId) {
+    const filePath = this.getFilePath(graphId);
+    try {
+      const raw = await fsp2.readFile(filePath, "utf8");
+      const serialized = JSON.parse(raw);
+      return this.deserializeGraph(serialized);
+    } catch {
+      return null;
+    }
+  }
+  async delete(graphId) {
+    const filePath = this.getFilePath(graphId);
+    try {
+      await fsp2.unlink(filePath);
+    } catch {
+    }
+  }
+  async list() {
+    try {
+      const entries = await fsp2.readdir(this.baseDir, { withFileTypes: true });
+      const graphs = [];
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        try {
+          const raw = await fsp2.readFile(path6.join(this.baseDir, entry.name), "utf8");
+          const serialized = JSON.parse(raw);
+          const done = serialized.completedPhaseIds.length;
+          const total = serialized.phases.length;
+          graphs.push({
+            id: serialized.id,
+            title: serialized.title,
+            updatedAt: serialized.updatedAt,
+            status: done === total ? "completed" : done > 0 ? "in_progress" : "pending"
+          });
+        } catch {
+        }
+      }
+      return graphs.sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch {
+      return [];
+    }
+  }
+  getFilePath(graphId) {
+    return path6.join(this.baseDir, `${graphId}.json`);
+  }
+  serializeGraph(graph) {
+    return {
+      id: graph.id,
+      title: graph.title,
+      description: graph.description,
+      phases: Array.from(graph.phases.values()).map((p) => this.serializePhase(p)),
+      rootPhaseIds: graph.rootPhaseIds,
+      activePhaseIds: graph.activePhaseIds,
+      completedPhaseIds: graph.completedPhaseIds,
+      failedPhaseIds: graph.failedPhaseIds,
+      autonomous: graph.autonomous,
+      stopOnComplete: graph.stopOnComplete,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt,
+      startedAt: graph.startedAt,
+      completedAt: graph.completedAt
+    };
+  }
+  serializePhase(phase) {
+    return {
+      id: phase.id,
+      name: phase.name,
+      description: phase.description,
+      status: phase.status,
+      taskGraph: this.serializeTaskGraph(phase.taskGraph),
+      dependsOn: phase.dependsOn,
+      nextPhases: phase.nextPhases,
+      parallelizable: phase.parallelizable,
+      priority: phase.priority,
+      estimateHours: phase.estimateHours,
+      actualDurationMs: phase.actualDurationMs,
+      startedAt: phase.startedAt,
+      completedAt: phase.completedAt,
+      assignedAgents: phase.assignedAgents,
+      metadata: phase.metadata,
+      createdAt: phase.createdAt,
+      updatedAt: phase.updatedAt
+    };
+  }
+  serializeTaskGraph(graph) {
+    return {
+      id: graph.id,
+      specId: graph.specId,
+      title: graph.title,
+      nodes: Array.from(graph.nodes.values()).map((n) => this.serializeTaskNode(n)),
+      edges: graph.edges,
+      rootNodes: graph.rootNodes,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt
+    };
+  }
+  serializeTaskNode(node) {
+    return { ...node };
+  }
+  deserializeGraph(serialized) {
+    const phases = /* @__PURE__ */ new Map();
+    for (const sp of serialized.phases) {
+      phases.set(sp.id, this.deserializePhase(sp));
+    }
+    return {
+      id: serialized.id,
+      title: serialized.title,
+      description: serialized.description,
+      phases,
+      rootPhaseIds: serialized.rootPhaseIds,
+      activePhaseIds: serialized.activePhaseIds,
+      completedPhaseIds: serialized.completedPhaseIds,
+      failedPhaseIds: serialized.failedPhaseIds,
+      autonomous: serialized.autonomous,
+      stopOnComplete: serialized.stopOnComplete,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt
+    };
+  }
+  deserializePhase(serialized) {
+    return {
+      id: serialized.id,
+      name: serialized.name,
+      description: serialized.description,
+      status: serialized.status,
+      taskGraph: this.deserializeTaskGraph(serialized.taskGraph),
+      dependsOn: serialized.dependsOn,
+      nextPhases: serialized.nextPhases,
+      parallelizable: serialized.parallelizable,
+      priority: serialized.priority,
+      estimateHours: serialized.estimateHours,
+      actualDurationMs: serialized.actualDurationMs,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt,
+      assignedAgents: serialized.assignedAgents,
+      metadata: serialized.metadata,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+  deserializeTaskGraph(serialized) {
+    const nodes = /* @__PURE__ */ new Map();
+    for (const sn of serialized.nodes) {
+      nodes.set(sn.id, sn);
+    }
+    return {
+      id: serialized.id,
+      specId: serialized.specId,
+      title: serialized.title,
+      nodes,
+      edges: serialized.edges ?? [],
+      rootNodes: serialized.rootNodes ?? [],
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+};
+var CheckpointManager = class {
+  store;
+  maxCheckpoints;
+  checkpoints = /* @__PURE__ */ new Map();
+  baseDir;
+  constructor(opts) {
+    this.store = opts.store;
+    this.maxCheckpoints = opts.maxCheckpoints ?? 10;
+    this.baseDir = opts.baseDir ?? path6.join(opts.store.baseDir, ".checkpoints");
+  }
+  async initialize() {
+    await fsp2.mkdir(this.baseDir, { recursive: true });
+    await this.loadFromDisk();
+  }
+  async saveCheckpoint(graph, label) {
+    await this.store.save(graph);
+    const activePhase = Array.from(graph.phases.values()).find(
+      (p) => p.status === "running" || p.status === "paused"
+    );
+    const checkpoint = {
+      id: crypto.randomUUID(),
+      graphId: graph.id,
+      phaseId: activePhase?.id ?? graph.rootPhaseIds[0] ?? "",
+      phaseStatus: activePhase?.status ?? "pending",
+      taskStatuses: activePhase ? Array.from(activePhase.taskGraph.nodes.values()).map((t2) => ({
+        taskId: t2.id,
+        status: t2.status,
+        title: t2.title
+      })) : [],
+      timestamp: Date.now(),
+      label
+    };
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    await this.saveToDisk(checkpoint);
+    await this.pruneCheckpoints();
+    return checkpoint;
+  }
+  async restoreCheckpoint(checkpointId) {
+    let checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) {
+      await this.loadFromDisk();
+      checkpoint = this.checkpoints.get(checkpointId);
+    }
+    if (!checkpoint) return null;
+    const graph = await this.store.load(checkpoint.graphId);
+    if (!graph) return null;
+    const phase = graph.phases.get(checkpoint.phaseId);
+    if (phase) {
+      phase.status = checkpoint.phaseStatus;
+      phase.updatedAt = Date.now();
+      for (const ts of checkpoint.taskStatuses) {
+        const task = phase.taskGraph.nodes.get(ts.taskId);
+        if (task) {
+          task.status = ts.status;
+          task.updatedAt = Date.now();
+        }
+      }
+    }
+    graph.updatedAt = Date.now();
+    return graph;
+  }
+  listCheckpoints(graphId) {
+    const all = Array.from(this.checkpoints.values());
+    const filtered = graphId ? all.filter((c) => c.graphId === graphId) : all;
+    return filtered.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  async deleteCheckpoint(checkpointId) {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) return false;
+    this.checkpoints.delete(checkpointId);
+    await this.deleteFromDisk(checkpointId);
+    return true;
+  }
+  async saveToDisk(checkpoint) {
+    await fsp2.mkdir(this.baseDir, { recursive: true });
+    const filePath = path6.join(this.baseDir, `${checkpoint.graphId}.json`);
+    const serialized = {
+      ...checkpoint
+    };
+    let existing = [];
+    try {
+      const raw = await fsp2.readFile(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    } catch {
+    }
+    existing.push(serialized);
+    await fsp2.writeFile(filePath, JSON.stringify(existing, null, 2), "utf8");
+  }
+  async deleteFromDisk(checkpointId) {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.baseDir);
+    } catch {
+      return;
+    }
+    for (const filename of entries) {
+      if (!filename.endsWith(".json")) continue;
+      const filePath = path6.join(this.baseDir, filename);
+      try {
+        const raw = await fsp2.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) continue;
+        const existing = parsed;
+        const filtered = existing.filter((c) => c.id !== checkpointId);
+        if (filtered.length !== existing.length) {
+          if (filtered.length === 0) {
+            await fsp2.unlink(filePath);
+          } else {
+            await fsp2.writeFile(filePath, JSON.stringify(filtered, null, 2), "utf8");
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  async loadFromDisk() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.baseDir);
+    } catch {
+      return;
+    }
+    for (const filename of entries) {
+      if (!filename.endsWith(".json")) continue;
+      const filePath = path6.join(this.baseDir, filename);
+      try {
+        const raw = await fsp2.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) continue;
+        const checkpoints = parsed;
+        for (const sc of checkpoints) {
+          const checkpoint = {
+            id: sc.id,
+            graphId: sc.graphId,
+            phaseId: sc.phaseId,
+            phaseStatus: sc.phaseStatus,
+            taskStatuses: sc.taskStatuses,
+            timestamp: sc.timestamp,
+            label: sc.label
+          };
+          this.checkpoints.set(checkpoint.id, checkpoint);
+        }
+      } catch {
+      }
+    }
+  }
+  async pruneCheckpoints() {
+    const all = Array.from(this.checkpoints.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    while (all.length > this.maxCheckpoints) {
+      const oldest = all.shift();
+      if (oldest) {
+        this.checkpoints.delete(oldest.id);
+        await this.deleteFromDisk(oldest.id);
+      }
+    }
+  }
+};
+
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map