@wrongstack/core 0.8.4 → 0.8.6

package/dist/index.js

@@ -3,7 +3,7 @@ import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash }
 import * as fsp2 from 'fs/promises';
 import { readFile, readdir, stat, mkdir } from 'fs/promises';
 import * as path6 from 'path';
-import { join, extname, relative } from 'path';
+import { join, extname, relative, resolve, sep } from 'path';
 import * as fs2 from 'fs';
 import * as os5 from 'os';
 import { execFile, spawn } from 'child_process';
@@ -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((resolve8) => setTimeout(resolve8, delays[i]));
     }
   }
   throw lastErr;
@@ -830,7 +830,9 @@ var TOKENS = {
   ModelsRegistry: t("ModelsRegistry"),
   ModeStore: t("ModeStore"),
   /** Replaces the entire provider call layer — retry, streaming, tracing. */
-  ProviderRunner: t("ProviderRunner")
+  ProviderRunner: t("ProviderRunner"),
+  /** Optional git-worktree lifecycle manager (per-phase isolation in AutoPhase). */
+  WorktreeManager: t("WorktreeManager")
 };
 
 // src/kernel/run-controller.ts
@@ -2692,7 +2694,7 @@ var InMemoryAgentBridge = class {
       );
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -2704,7 +2706,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve6,
+        resolve: resolve8,
         reject,
         timer
       });
@@ -2930,7 +2932,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 +3139,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 +3206,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 +3557,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 +3565,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 = [];
@@ -3863,12 +3922,14 @@ function resolveWstackPaths(opts) {
     projectLocalConfig: path6.join(projectDir, "config.local.json"),
     inProjectAgentsFile: path6.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
     inProjectSkills: path6.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectWorktrees: path6.join(opts.projectRoot, ".wrongstack", "worktrees"),
     projectHash: hash,
     projectGoal: path6.join(projectDir, "goal.json"),
     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 +4026,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path27, errors) {
+function walk2(value, schema, path28, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path27 || "<root>",
+        path: path28 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3978,7 +4039,7 @@ function walk2(value, schema, path27, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path27 || "<root>",
+        path: path28 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3988,19 +4049,19 @@ function walk2(value, schema, path27, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path27, 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(path27, 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, `${path27}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path28}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -5321,9 +5382,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 +6624,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((resolve8) => {
+            drainTimer = setTimeout(resolve8, 500);
           })
         ]);
       } finally {
@@ -6627,7 +6686,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve6, reject) => {
+      await new Promise((resolve8, reject) => {
         let settled = false;
         const onAbort = () => {
           if (settled) return;
@@ -6640,7 +6699,7 @@ async function runProviderWithRetry(opts) {
           settled = true;
           clearTimeout(t2);
           signal.removeEventListener("abort", onAbort);
-          resolve6();
+          resolve8();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -8261,8 +8320,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink11 } = await import('fs/promises');
-      await unlink11(this.goalPath);
+      const { unlink: unlink12 } = await import('fs/promises');
+      await unlink12(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -8284,7 +8343,7 @@ ${recentJournal}` : "No prior iterations.",
   }
 };
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 
 // src/coordination/subagent-budget.ts
@@ -8434,12 +8493,12 @@ var SubagentBudget = class _SubagentBudget {
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
-          return new Promise((resolve6) => {
+          return new Promise((resolve8) => {
             let resolved = false;
             const respond = (d) => {
               if (resolved) return;
               resolved = true;
-              resolve6(d);
+              resolve8(d);
             };
             const fallback = setTimeout(
               () => respond("stop"),
@@ -11480,7 +11539,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((resolve8, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -11489,7 +11548,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve6(result);
+              resolve8(result);
             }
           };
           this.on("task.completed", handler);
@@ -11919,7 +11978,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((resolve8) => setTimeout(resolve8, ms));
 }
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
@@ -12700,7 +12759,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;
@@ -13190,6 +13249,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 = {};
@@ -13554,11 +13620,11 @@ var Director = class {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve6;
+        let resolve8;
         const promise = new Promise((res) => {
-          resolve6 = res;
+          resolve8 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve6 });
+        this.taskWaiters.set(id, { promise, resolve: resolve8 });
         return promise;
       })
     );
@@ -13874,7 +13940,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve6) => {
+        const result = await new Promise((resolve8) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -13883,7 +13949,7 @@ function createDelegateTool(opts) {
             if (timer) clearTimeout(timer);
             offTool();
             offIter();
-            resolve6(value);
+            resolve8(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -14688,6 +14754,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(),
@@ -14760,10 +14833,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);
@@ -14841,8 +14910,7 @@ var TaskTracker = class {
     }
     return computeTaskProgress(this.graph);
   }
-  getTransitions(taskId) {
-    if (!taskId) return [...this.transitions];
+  getTransitions(_taskId) {
     return [...this.transitions];
   }
   unblockDependents(completedId) {
@@ -14882,18 +14950,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));
     });
   }
 };
@@ -15514,10 +15576,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp17 = await import('fs/promises');
-      const path27 = 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 fsp17.mkdir(path27.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 {
     }
@@ -15526,8 +15588,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp17 = await import('fs/promises');
-      const raw = await fsp17.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;
@@ -15541,8 +15603,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp17 = await import('fs/promises');
-      await fsp17.unlink(this.sessionPath);
+      const fsp18 = await import('fs/promises');
+      await fsp18.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -16227,15 +16289,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path27 = [];
+  const path28 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path27.unshift(current);
+    path28.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path27;
+  return path28;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17030,9 +17092,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve6) => {
+    const timeout = new Promise((resolve8) => {
       timer = setTimeout(
-        () => resolve6({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve8({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -17215,7 +17277,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path27 = opts.path ?? "/metrics";
+  const path28 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -17225,7 +17287,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path27) {
+    if (url === path28) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -17271,14 +17333,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve8, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve6();
+      resolve8();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -17289,9 +17351,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path27}`,
-    close: () => new Promise((resolve6, reject) => {
-      server.close((err) => err ? reject(err) : resolve6());
+    url: `${protocol}://${host}:${boundPort}${path28}`,
+    close: () => new Promise((resolve8, reject) => {
+      server.close((err) => err ? reject(err) : resolve8());
     })
   };
 }
@@ -17990,6 +18052,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 });
@@ -19409,8 +19477,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir12 } = await import('fs/promises');
-      await mkdir12(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir14 } = await import('fs/promises');
+      await mkdir14(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -19686,7 +19754,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((resolve8) => setTimeout(resolve8, delay));
       return this.completeWithRetry(provider, request, abortController, attempt + 1);
     }
   }
@@ -20332,16 +20400,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: readFile31 } = await import('fs/promises');
-      const content = await readFile31(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: readFile31 } = await import('fs/promises');
-      const content = await readFile31(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}` };
@@ -21183,12 +21251,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((resolve8) => {
     let resolved = false;
     const timerFired = () => {
       if (!resolved) {
         resolved = true;
-        resolve6(0);
+        resolve8(0);
       }
     };
     const timer = setTimeout(timerFired, timeoutMs);
@@ -21197,14 +21265,14 @@ function requestLimitExtension(opts) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve6(0);
+        resolve8(0);
       }
     };
     const grant = (extra) => {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve6(Math.max(0, extra));
+        resolve8(Math.max(0, extra));
       }
     };
     events.emit("iteration.limit_reached", {
@@ -21218,7 +21286,7 @@ function requestLimitExtension(opts) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve6(100);
+          resolve8(100);
         }
       });
     }
@@ -21787,13 +21855,13 @@ var Agent = class {
     }
   }
   waitForConfirm(info) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve8) => {
       this.events.emit("tool.confirm_needed", {
         tool: info.tool,
         input: info.input,
         toolUseId: info.toolUseId,
         suggestedPattern: info.suggestedPattern,
-        resolve: resolve6
+        resolve: resolve8
       });
     });
   }
@@ -22510,12 +22578,12 @@ ${mem}`);
     }
   }
   async gitStatus(root) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve8) => {
       let settled = false;
       const finish = (s) => {
         if (settled) return;
         settled = true;
-        resolve6(s);
+        resolve8(s);
       };
       let proc;
       const timer = setTimeout(() => {
@@ -23281,7 +23349,7 @@ var PhaseGraphBuilder = class _PhaseGraphBuilder {
       const tmpl = this.opts.phases[i];
       const phaseId = crypto.randomUUID();
       phaseIds.push(phaseId);
-      const store = new DefaultTaskStore();
+      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) {
@@ -23388,10 +23456,21 @@ var PhaseOrchestrator = class {
   paused = false;
   runningPhases = /* @__PURE__ */ new Set();
   tickInterval = null;
+  trackerCache = /* @__PURE__ */ new Map();
+  taskRetryCounts = /* @__PURE__ */ new Map();
+  // ── Git-worktree isolation (optional) ──────────────────────────────────────
+  worktrees;
+  /** Per-phase worktree handles, keyed by phase id. */
+  phaseWorktrees = /* @__PURE__ */ new Map();
+  /** Serializes all merges back to the base branch (one at a time). */
+  mergeQueue = Promise.resolve();
+  /** Per-phase merge promise, so a phase merges only after its deps do. */
+  phaseMergePromise = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.graph = opts.graph;
     this.ctx = opts.ctx;
     this.events = opts.events ?? this.createNoopEventBus();
+    this.worktrees = opts.worktrees;
     this.opts = {
       maxConcurrentPhases: opts.maxConcurrentPhases ?? 1,
       maxConcurrentTasks: opts.maxConcurrentTasks ?? 2,
@@ -23416,14 +23495,24 @@ var PhaseOrchestrator = class {
     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"
       );
     }
+    await this.drainMerges();
     if (this.opts.autonomous) {
       this.tickInterval = setInterval(() => this.tick(), 1e3);
     }
   }
+  /** Bekleyen tüm faz merge'lerini (dep-sıralı + global seri) bekle. */
+  async drainMerges() {
+    await Promise.allSettled([...this.phaseMergePromise.values()]);
+    await this.mergeQueue.catch(() => {
+    });
+  }
   /** Duraklat — aktif fazlar çalışmaya devam eder ama yeni faz başlamaz */
   pause() {
     this.paused = true;
@@ -23431,7 +23520,9 @@ var PhaseOrchestrator = class {
   /** Devam et — yeni fazlar başlayabilir */
   resume() {
     this.paused = false;
-    void this.tick();
+    this.tick().catch((err) => {
+      console.error("[phase-orchestrator] tick failed:", err instanceof Error ? err.message : String(err));
+    });
   }
   /** Tamamen durdur — aktif fazlar da durdurulur */
   stop() {
@@ -23446,21 +23537,29 @@ var PhaseOrchestrator = class {
         this.updatePhaseStatus(phase, "paused");
       }
     }
+    if (this.worktrees) {
+      for (const handle of this.worktrees.list()) {
+        void this.worktrees.release(handle, { keep: true }).catch(() => {
+        });
+      }
+    }
   }
   // ─── Tick Loop (Autonomous) ───────────────────────────────────────────────
   async tick() {
     if (this.stopped || this.paused) return;
     const active = this.getActivePhases();
-    const ready = this.getReadyPhases();
+    const queued = this.getReadyPhases();
     this.emit("autonomous.tick", {
       activePhases: active.map((p) => p.id),
-      queuedPhases: ready.map((p) => p.id)
+      queuedPhases: queued.map((p) => p.id)
     });
-    this.ctx.onTick?.({ activePhases: active, readyPhases: ready });
+    this.ctx.onTick?.({ activePhases: active, readyPhases: queued });
     const availableSlots = this.opts.maxConcurrentPhases - active.length;
-    if (availableSlots > 0 && ready.length > 0) {
-      for (const phase of ready.slice(0, availableSlots)) {
-        await this.startPhase(phase);
+    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()) {
@@ -23482,6 +23581,16 @@ var PhaseOrchestrator = class {
     phase.startedAt = Date.now();
     this.runningPhases.add(phase.id);
     this.graph.activePhaseIds.push(phase.id);
+    if (this.worktrees && !this.phaseWorktrees.has(phase.id)) {
+      try {
+        const handle = await this.worktrees.allocate(phase.id, {
+          slugHint: phase.name,
+          ownerLabel: phase.name
+        });
+        if (handle.status === "active") this.phaseWorktrees.set(phase.id, handle);
+      } catch {
+      }
+    }
     this.emit("phase.started", { phaseId: phase.id, name: phase.name });
     try {
       await this.executePhaseTasks(phase);
@@ -23497,17 +23606,20 @@ var PhaseOrchestrator = class {
         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`));
+        await this.keepWorktreeForReview(phase);
       } 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,
@@ -23515,12 +23627,14 @@ var PhaseOrchestrator = class {
           durationMs: phase.actualDurationMs
         });
         this.ctx.onPhaseComplete?.(phase);
+        await this.commitAndEnqueueMerge(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,
@@ -23528,10 +23642,57 @@ var PhaseOrchestrator = class {
         error: error instanceof Error ? error.message : String(error)
       });
       this.ctx.onPhaseFail?.(phase, error instanceof Error ? error : new Error(String(error)));
+      await this.keepWorktreeForReview(phase);
+    }
+  }
+  // ─── Worktree integration ───────────────────────────────────────────────────
+  /**
+   * Commit the phase's worktree changes, then enqueue the merge back into the
+   * base branch. Merges run dependency-ordered (a phase merges only after its
+   * `dependsOn` phases) and globally serialized (one at a time) to avoid
+   * concurrent writes to the base tree.
+   */
+  async commitAndEnqueueMerge(phase) {
+    const handle = this.phaseWorktrees.get(phase.id);
+    if (!this.worktrees || !handle) return;
+    try {
+      await this.worktrees.commitAll(handle, `autophase(${phase.name}): ${phase.id}`);
+    } catch {
+    }
+    const depPromises = phase.dependsOn.map((d) => this.phaseMergePromise.get(d)).filter((p) => Boolean(p));
+    const merged = (async () => {
+      await Promise.allSettled(depPromises);
+      this.mergeQueue = this.mergeQueue.then(() => this.mergeOne(phase, handle));
+      await this.mergeQueue;
+    })();
+    this.phaseMergePromise.set(phase.id, merged);
+  }
+  /** Squash-merge one phase. Conflicts mark the worktree needs-review (run continues). */
+  async mergeOne(phase, handle) {
+    if (!this.worktrees) return;
+    try {
+      const result = await this.worktrees.merge(handle, { squash: true });
+      await this.worktrees.release(handle, { keep: !result.ok });
+    } catch (err) {
+      this.emit("phase.failed", {
+        phaseId: phase.id,
+        name: phase.name,
+        error: `worktree merge failed: ${err instanceof Error ? err.message : String(err)}`
+      });
     }
   }
+  /** A failed phase keeps its worktree on disk for inspection (no merge). */
+  async keepWorktreeForReview(phase) {
+    const handle = this.phaseWorktrees.get(phase.id);
+    if (!this.worktrees || !handle) return;
+    try {
+      await this.worktrees.commitAll(handle, `autophase(${phase.name}) [failed]: ${phase.id}`);
+    } catch {
+    }
+    await this.worktrees.release(handle, { keep: true }).catch(() => {
+    });
+  }
   async executePhaseTasks(phase) {
-    phase.taskGraph;
     const pendingTasks = this.getExecutableTasks(phase);
     while (pendingTasks.length > 0 && !this.stopped) {
       const batch = pendingTasks.splice(0, this.opts.maxConcurrentTasks);
@@ -23556,7 +23717,8 @@ var PhaseOrchestrator = class {
   async executeSingleTask(task, phase) {
     const tracker = this.getTrackerForPhase(phase);
     tracker.updateNodeStatus(task.id, "in_progress");
-    return this.ctx.executeTask(task, phase.id);
+    const handle = this.phaseWorktrees.get(phase.id);
+    return this.ctx.executeTask(task, phase.id, { cwd: handle?.dir, branch: handle?.branch });
   }
   markTaskCompleted(phase, task) {
     const tracker = this.getTrackerForPhase(phase);
@@ -23569,13 +23731,27 @@ var PhaseOrchestrator = class {
   }
   markTaskFailed(phase, task, error) {
     const tracker = this.getTrackerForPhase(phase);
-    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)
-    });
+    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() {
@@ -23586,7 +23762,7 @@ var PhaseOrchestrator = class {
         const dep = this.graph.phases.get(depId);
         return dep?.status === "completed" || dep?.status === "skipped";
       });
-      if (depsDone) {
+      if (depsDone || phase.parallelizable) {
         ready.push(phase);
       }
     }
@@ -23605,18 +23781,20 @@ var PhaseOrchestrator = class {
     });
   }
   getTrackerForPhase(phase) {
+    if (this.trackerCache.has(phase.id)) {
+      return this.trackerCache.get(phase.id);
+    }
     const store = new DefaultTaskStore();
     const tracker = new TaskTracker({ store });
-    tracker.graph = phase.taskGraph;
+    tracker.setGraph(phase.taskGraph);
+    this.trackerCache.set(phase.id, tracker);
     return tracker;
   }
   getFailedTaskCount(phase) {
-    const tracker = this.getTrackerForPhase(phase);
-    return tracker.getAllNodes({ status: ["failed"] }).length;
+    return this.getTrackerForPhase(phase).getAllNodes({ status: ["failed"] }).length;
   }
   getCompletedTaskCount(phase) {
-    const tracker = this.getTrackerForPhase(phase);
-    return tracker.getAllNodes({ status: ["completed"] }).length;
+    return this.getTrackerForPhase(phase).getAllNodes({ status: ["completed"] }).length;
   }
   updatePhaseStatus(phase, status) {
     const from = phase.status;
@@ -23648,8 +23826,18 @@ var PhaseOrchestrator = class {
   // ─── Progress ─────────────────────────────────────────────────────────────
   getProgress() {
     const phases = Array.from(this.graph.phases.values());
-    let pending = 0, ready = 0, running = 0, paused = 0, completed = 0, failed = 0, skipped = 0;
-    let totalTasks = 0, completedTasks = 0, failedTasks = 0, estimatedHours = 0, actualHours = 0;
+    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":
@@ -23752,6 +23940,9 @@ var PhaseOrchestrator = class {
       }
     };
   }
+  delay(ms) {
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
+  }
 };
 
 // src/autophase/auto-phase-runner.ts
@@ -23760,6 +23951,26 @@ var AutoPhaseRunner = class {
   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;
   }
@@ -23801,31 +24012,11 @@ var AutoPhaseRunner = class {
         this.opts.onProgress(progress);
       }, 2e3);
     }
-    const events = this.opts.events;
-    if (events) {
-      events.on(
-        "graph.completed",
-        (payload) => {
-          const p = payload;
-          if (this.graph && p.graphId === this.graph.id) {
-            this.opts.onComplete?.(this.graph);
-            this.cleanup();
-          }
-        }
-      );
-      events.on(
-        "graph.failed",
-        (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();
-          }
-        }
-      );
+    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;
@@ -23863,6 +24054,10 @@ var AutoPhaseRunner = class {
       clearInterval(this.progressInterval);
       this.progressInterval = null;
     }
+    this.unsubscribeCompleted?.();
+    this.unsubscribeCompleted = null;
+    this.unsubscribeFailed?.();
+    this.unsubscribeFailed = null;
   }
 };
 async function createAutoPhaseFromTaskGraph(taskGraph, options) {
@@ -23883,6 +24078,181 @@ async function createAutoPhaseFromTaskGraph(taskGraph, options) {
     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) {
@@ -24046,22 +24416,26 @@ var PhaseStore = class {
       specId: serialized.specId,
       title: serialized.title,
       nodes,
-      edges: serialized.edges,
-      rootNodes: serialized.rootNodes,
+      edges: serialized.edges ?? [],
+      rootNodes: serialized.rootNodes ?? [],
       createdAt: serialized.createdAt,
       updatedAt: serialized.updatedAt
     };
   }
 };
-
-// src/autophase/checkpoint.ts
 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);
@@ -24082,11 +24456,16 @@ var CheckpointManager = class {
       label
     };
     this.checkpoints.set(checkpoint.id, checkpoint);
-    this.pruneCheckpoints();
+    await this.saveToDisk(checkpoint);
+    await this.pruneCheckpoints();
     return checkpoint;
   }
   async restoreCheckpoint(checkpointId) {
-    const checkpoint = this.checkpoints.get(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;
@@ -24110,20 +24489,357 @@ var CheckpointManager = class {
     const filtered = graphId ? all.filter((c) => c.graphId === graphId) : all;
     return filtered.sort((a, b) => b.timestamp - a.timestamp);
   }
-  deleteCheckpoint(checkpointId) {
-    return this.checkpoints.delete(checkpointId);
+  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");
   }
-  pruneCheckpoints() {
+  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);
+      if (oldest) {
+        this.checkpoints.delete(oldest.id);
+        await this.deleteFromDisk(oldest.id);
+      }
     }
   }
 };
+var MAX_SLUG = 40;
+var WorktreeManager = class {
+  projectRoot;
+  events;
+  gitBin;
+  runGit;
+  /** Keyed by ownerId. */
+  handles = /* @__PURE__ */ new Map();
+  usedSlugs = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.projectRoot = resolve(opts.projectRoot);
+    this.events = opts.events;
+    this.gitBin = opts.gitBin ?? "git";
+    this.runGit = opts.run ?? ((args, cwd) => this.defaultRun(args, cwd));
+  }
+  /** Create a fresh worktree + branch forked from the current base branch. */
+  async allocate(ownerId, opts = {}) {
+    const existing = this.handles.get(ownerId);
+    if (existing && (existing.status === "allocating" || existing.status === "active")) {
+      return existing;
+    }
+    const slug = this.makeSlug(opts.slugHint ?? ownerId);
+    const branch = `wstack/ap/${slug}`;
+    const dir = join(this.worktreesRoot(), slug);
+    assertSafePath(dir, this.projectRoot);
+    const baseBranch = opts.baseBranch ?? await this.detectBaseBranch();
+    const handle = {
+      id: slug,
+      ownerId,
+      ownerLabel: opts.ownerLabel ?? opts.slugHint ?? ownerId,
+      slug,
+      dir,
+      branch,
+      baseBranch,
+      status: "allocating",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      insertions: 0,
+      deletions: 0,
+      files: 0
+    };
+    this.handles.set(ownerId, handle);
+    try {
+      await mkdir(this.worktreesRoot(), { recursive: true });
+      const res = await this.runGit(
+        ["worktree", "add", "-b", branch, dir, baseBranch],
+        this.projectRoot
+      );
+      if (res.code !== 0) {
+        return this.fail(handle, res.stderr || "git worktree add failed");
+      }
+    } catch (err) {
+      return this.fail(handle, err instanceof Error ? err.message : String(err));
+    }
+    this.setStatus(handle, "active");
+    this.emit("worktree.allocated", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      ownerLabel: handle.ownerLabel,
+      slug: handle.slug,
+      dir: handle.dir,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch
+    });
+    return handle;
+  }
+  /** Stage everything and commit inside the worktree. */
+  async commitAll(handle, message) {
+    this.setStatus(handle, "committing");
+    await this.runGit(["add", "-A"], handle.dir);
+    const staged = await this.runGit(["diff", "--cached", "--quiet"], handle.dir);
+    if (staged.code === 0) {
+      this.emitCommitted(handle, false);
+      return { committed: false };
+    }
+    const committed = await this.runGit(["commit", "-m", message], handle.dir);
+    if (committed.code !== 0) {
+      this.fail(handle, committed.stderr || "git commit failed");
+      return { committed: false };
+    }
+    const stats = await this.collectStats(handle.dir);
+    handle.insertions = stats.insertions;
+    handle.deletions = stats.deletions;
+    handle.files = stats.files;
+    handle.sha = stats.sha;
+    handle.updatedAt = Date.now();
+    this.emitCommitted(handle, true);
+    return { committed: true };
+  }
+  /** Merge the worktree branch back into the base branch (squash by default). */
+  async merge(handle, opts = {}) {
+    const squash = opts.squash ?? true;
+    this.setStatus(handle, "merging");
+    const checkout = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
+    if (checkout.code !== 0) {
+      this.fail(handle, checkout.stderr || `checkout ${handle.baseBranch} failed`);
+      return { ok: false, stderr: checkout.stderr };
+    }
+    const mergeArgs = squash ? ["merge", "--squash", handle.branch] : ["merge", "--no-ff", handle.branch];
+    const merged = await this.runGit(mergeArgs, this.projectRoot);
+    if (merged.code !== 0) {
+      const conflictFiles = await this.unmergedFiles();
+      await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot);
+      handle.conflictFiles = conflictFiles;
+      this.setStatus(handle, "needs-review", { lastError: merged.stderr });
+      this.emit("worktree.conflict", {
+        handleId: handle.id,
+        ownerId: handle.ownerId,
+        branch: handle.branch,
+        conflictFiles
+      });
+      return { ok: false, conflict: true, conflictFiles, stderr: merged.stderr };
+    }
+    if (squash) {
+      const msg = opts.message ?? `merge ${handle.branch} (squash)`;
+      const commit = await this.runGit(["commit", "-m", msg], this.projectRoot);
+      if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+        this.fail(handle, commit.stderr || "squash commit failed");
+        return { ok: false, stderr: commit.stderr };
+      }
+    }
+    this.setStatus(handle, "merged");
+    this.emit("worktree.merged", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch,
+      squash
+    });
+    return { ok: true };
+  }
+  /**
+   * Remove the worktree + branch. Conflicted/failed handles (or `keep:true`)
+   * are left on disk for inspection.
+   */
+  async release(handle, opts = {}) {
+    const keep = opts.keep || handle.status === "needs-review" || handle.status === "failed";
+    if (!keep) {
+      await this.runGit(["worktree", "remove", "--force", handle.dir], this.projectRoot);
+      await this.runGit(["branch", "-D", handle.branch], this.projectRoot);
+      await this.runGit(["worktree", "prune"], this.projectRoot);
+      this.handles.delete(handle.ownerId);
+    }
+    this.emit("worktree.released", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      kept: keep
+    });
+  }
+  get(ownerId) {
+    return this.handles.get(ownerId);
+  }
+  list() {
+    return [...this.handles.values()];
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  worktreesRoot() {
+    return join(this.projectRoot, ".wrongstack", "worktrees");
+  }
+  async detectBaseBranch() {
+    const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
+    const name = head.stdout.trim();
+    if (name && name !== "HEAD") return name;
+    const sha = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
+    return sha.stdout.trim() || "HEAD";
+  }
+  makeSlug(hint) {
+    let base = hint.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+/, "").replace(/[-.]+$/, "").slice(0, MAX_SLUG).replace(/[-.]+$/, "");
+    if (!base) base = "wt";
+    let slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+    while (this.usedSlugs.has(slug)) slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+    this.usedSlugs.add(slug);
+    return slug;
+  }
+  async collectStats(dir) {
+    const sha = (await this.runGit(["rev-parse", "HEAD"], dir)).stdout.trim();
+    const numstat = await this.runGit(["show", "--numstat", "--format=", "HEAD"], dir);
+    let insertions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of numstat.stdout.split("\n")) {
+      const m = line.trim().match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+      if (!m) continue;
+      files++;
+      if (m[1] !== "-") insertions += Number(m[1]);
+      if (m[2] !== "-") deletions += Number(m[2]);
+    }
+    return { insertions, deletions, files, sha };
+  }
+  async unmergedFiles() {
+    const res = await this.runGit(
+      ["diff", "--name-only", "--diff-filter=U"],
+      this.projectRoot
+    );
+    return res.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  emitCommitted(handle, committed) {
+    this.emit("worktree.committed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      committed,
+      insertions: handle.insertions,
+      deletions: handle.deletions,
+      files: handle.files,
+      sha: handle.sha
+    });
+  }
+  fail(handle, error) {
+    this.setStatus(handle, "failed", { lastError: error });
+    this.emit("worktree.failed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      error
+    });
+    return handle;
+  }
+  setStatus(handle, status, patch) {
+    handle.status = status;
+    handle.updatedAt = Date.now();
+    if (patch) Object.assign(handle, patch);
+  }
+  emit(event, payload) {
+    this.events?.emit(event, payload);
+  }
+  defaultRun(args, cwd) {
+    return new Promise((res) => {
+      let stdout = "";
+      let stderr = "";
+      const child = spawn(this.gitBin, args, {
+        cwd,
+        env: buildChildEnv(),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout?.on("data", (c) => {
+        stdout += c.toString();
+      });
+      child.stderr?.on("data", (c) => {
+        stderr += c.toString();
+      });
+      child.on("error", (err) => res({ code: 1, stdout, stderr: err.message }));
+      child.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
+    });
+  }
+};
+function assertSafePath(dir, projectRoot) {
+  const root = resolve(projectRoot);
+  const abs = resolve(dir);
+  if (abs !== root && !abs.startsWith(root + sep)) {
+    throw new Error(`worktree path escapes project root: ${dir}`);
+  }
+}
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, 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 };
+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, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, 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