@wrongstack/core 0.8.5 → 0.9.0

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((resolve7) => setTimeout(resolve7, delays[i]));
+      await new Promise((resolve9) => setTimeout(resolve9, 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((resolve7, reject) => {
+    return new Promise((resolve9, 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: resolve7,
+        resolve: resolve9,
         reject,
         timer
       });
@@ -3920,6 +3922,7 @@ 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"),
@@ -3987,7 +3990,9 @@ function looksSecret(name) {
 }
 function buildChildEnv(optsOrSessionId) {
   const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
-  const passthrough = process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  const hasOwn = Object.prototype.hasOwnProperty.call(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.prototype.hasOwnProperty.call(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
   if (passthrough && !process.env["CI"]) {
     console.warn(
       "[WrongStack] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
@@ -5366,9 +5371,14 @@ var RecoveryLock = class {
     };
   }
   /**
-   * Claim the lock for the given session. Overwrites any existing lock
-   * — the caller should have already handled abandonment (via
-   * `checkAbandoned`) before calling this.
+   * Claim the lock for the given session. Uses exclusive-create (`O_EXCL`)
+   * to detect whether another process acquired the lock between our
+   * `checkAbandoned()` call and now. If the file already exists, it means
+   * another process won the race and we throw instead of silently
+   * overwriting their recovery record.
+   *
+   * The caller MUST have already called `checkAbandoned()` and handled its
+   * null return before calling this.
    */
   async write(sessionId) {
     await ensureDir(path6.dirname(this.file));
@@ -5379,7 +5389,15 @@ var RecoveryLock = class {
       hostname: this.hostname,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await atomicWrite(this.file, JSON.stringify(lock), { mode: 384 });
+    try {
+      await fsp2.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
+    } catch (err) {
+      const code = err.code;
+      if (code === "EEXIST") {
+        throw new Error(`Recovery lock already held by another process`);
+      }
+      throw err;
+    }
   }
   /**
    * Release the lock. Idempotent — silently succeeds if the file is
@@ -6621,8 +6639,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
       try {
         await Promise.race([
           Promise.resolve(iter.return?.()),
-          new Promise((resolve7) => {
-            drainTimer = setTimeout(resolve7, 500);
+          new Promise((resolve9) => {
+            drainTimer = setTimeout(resolve9, 500);
           })
         ]);
       } finally {
@@ -6683,7 +6701,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve7, reject) => {
+      await new Promise((resolve9, reject) => {
         let settled = false;
         const onAbort = () => {
           if (settled) return;
@@ -6696,7 +6714,7 @@ async function runProviderWithRetry(opts) {
           settled = true;
           clearTimeout(t2);
           signal.removeEventListener("abort", onAbort);
-          resolve7();
+          resolve9();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -8340,7 +8358,7 @@ ${recentJournal}` : "No prior iterations.",
   }
 };
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/coordination/subagent-budget.ts
@@ -8490,12 +8508,12 @@ var SubagentBudget = class _SubagentBudget {
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
-          return new Promise((resolve7) => {
+          return new Promise((resolve9) => {
             let resolved = false;
             const respond = (d) => {
               if (resolved) return;
               resolved = true;
-              resolve7(d);
+              resolve9(d);
             };
             const fallback = setTimeout(
               () => respond("stop"),
@@ -11536,7 +11554,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((resolve7, reject) => {
+        return new Promise((resolve9, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -11545,7 +11563,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve7(result);
+              resolve9(result);
             }
           };
           this.on("task.completed", handler);
@@ -11975,7 +11993,7 @@ function providerErrorToSubagentError(err, message, cause) {
 
 // src/execution/parallel-eternal-engine.ts
 function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
@@ -13617,11 +13635,11 @@ var Director = class {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve7;
+        let resolve9;
         const promise = new Promise((res) => {
-          resolve7 = res;
+          resolve9 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve7 });
+        this.taskWaiters.set(id, { promise, resolve: resolve9 });
         return promise;
       })
     );
@@ -13937,7 +13955,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve7) => {
+        const result = await new Promise((resolve9) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -13946,7 +13964,7 @@ function createDelegateTool(opts) {
             if (timer) clearTimeout(timer);
             offTool();
             offIter();
-            resolve7(value);
+            resolve9(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -17089,9 +17107,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve7) => {
+    const timeout = new Promise((resolve9) => {
       timer = setTimeout(
-        () => resolve7({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve9({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -17330,14 +17348,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve9, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve7();
+      resolve9();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -17349,8 +17367,8 @@ async function startMetricsServer(opts) {
   return {
     port: boundPort,
     url: `${protocol}://${host}:${boundPort}${path28}`,
-    close: () => new Promise((resolve7, reject) => {
-      server.close((err) => err ? reject(err) : resolve7());
+    close: () => new Promise((resolve9, reject) => {
+      server.close((err) => err ? reject(err) : resolve9());
     })
   };
 }
@@ -18446,10 +18464,12 @@ async function collectFiles(dir, baseDir) {
 // src/storage/session-rewinder.ts
 init_atomic_write();
 var DefaultSessionRewinder = class {
-  constructor(sessionsDir) {
+  constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
+    this.projectRoot = projectRoot;
   }
   sessionsDir;
+  projectRoot;
   async listCheckpoints(sessionId) {
     const file = path6.join(this.sessionsDir, `${sessionId}.jsonl`);
     const raw = await fsp2.readFile(file, "utf8");
@@ -18506,7 +18526,7 @@ var DefaultSessionRewinder = class {
         }
       }
     }
-    const result = await revertSnapshots(snapshotsToRevert);
+    const result = await revertSnapshots(snapshotsToRevert, this.projectRoot);
     const removedEvents = events.length - targetIdx - 1;
     return { ...result, toPromptIndex: checkpointIndex, removedEvents };
   }
@@ -18536,7 +18556,7 @@ var DefaultSessionRewinder = class {
         snapshotsToRevert.push({ promptIndex: event.promptIndex, files: event.files });
       }
     }
-    const result = await revertSnapshots(snapshotsToRevert.reverse());
+    const result = await revertSnapshots(snapshotsToRevert.reverse(), this.projectRoot);
     return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
   }
   async rewindToStart(sessionId) {
@@ -18552,7 +18572,7 @@ var DefaultSessionRewinder = class {
     if (allSnapshots.length === 0) {
       return { revertedFiles: [], errors: [], toPromptIndex: 0, removedEvents: 0 };
     }
-    const result = await revertSnapshots(allSnapshots.reverse());
+    const result = await revertSnapshots(allSnapshots.reverse(), this.projectRoot);
     return { ...result, toPromptIndex: 0, removedEvents: allSnapshots.length };
   }
 };
@@ -18570,12 +18590,19 @@ function parseEvents(raw) {
   }
   return events;
 }
-async function revertSnapshots(snapshots) {
+async function revertSnapshots(snapshots, projectRoot) {
   const revertedFiles = [];
   const errors = [];
   for (const snapshot of snapshots) {
     for (const file of snapshot.files) {
       try {
+        const absPath = path6.resolve(file.path);
+        const root = path6.resolve(projectRoot);
+        const rel = path6.relative(root, absPath);
+        if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+          errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
+          continue;
+        }
         if (file.action === "deleted") {
           if (file.before !== null) {
             await atomicWrite(file.path, file.before, { mode: 420 });
@@ -19474,8 +19501,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir13 } = await import('fs/promises');
-      await mkdir13(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir14 } = await import('fs/promises');
+      await mkdir14(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -19751,7 +19778,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((resolve7) => setTimeout(resolve7, delay));
+      await new Promise((resolve9) => setTimeout(resolve9, delay));
       return this.completeWithRetry(provider, request, abortController, attempt + 1);
     }
   }
@@ -21248,12 +21275,12 @@ function makeContinueToNextIterationTool() {
 // src/core/iteration-limit.ts
 function requestLimitExtension(opts) {
   const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     let resolved = false;
     const timerFired = () => {
       if (!resolved) {
         resolved = true;
-        resolve7(0);
+        resolve9(0);
       }
     };
     const timer = setTimeout(timerFired, timeoutMs);
@@ -21262,14 +21289,14 @@ function requestLimitExtension(opts) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve7(0);
+        resolve9(0);
       }
     };
     const grant = (extra) => {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve7(Math.max(0, extra));
+        resolve9(Math.max(0, extra));
       }
     };
     events.emit("iteration.limit_reached", {
@@ -21283,7 +21310,7 @@ function requestLimitExtension(opts) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve7(100);
+          resolve9(100);
         }
       });
     }
@@ -21852,13 +21879,13 @@ var Agent = class {
     }
   }
   waitForConfirm(info) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       this.events.emit("tool.confirm_needed", {
         tool: info.tool,
         input: info.input,
         toolUseId: info.toolUseId,
         suggestedPattern: info.suggestedPattern,
-        resolve: resolve7
+        resolve: resolve9
       });
     });
   }
@@ -22575,12 +22602,12 @@ ${mem}`);
     }
   }
   async gitStatus(root) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let settled = false;
       const finish = (s) => {
         if (settled) return;
         settled = true;
-        resolve7(s);
+        resolve9(s);
       };
       let proc;
       const timer = setTimeout(() => {
@@ -23455,10 +23482,19 @@ var PhaseOrchestrator = class {
   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,
@@ -23490,10 +23526,17 @@ var PhaseOrchestrator = class {
         (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;
@@ -23518,6 +23561,12 @@ 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() {
@@ -23556,6 +23605,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);
@@ -23578,6 +23637,7 @@ var PhaseOrchestrator = class {
           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();
@@ -23591,6 +23651,7 @@ var PhaseOrchestrator = class {
           durationMs: phase.actualDurationMs
         });
         this.ctx.onPhaseComplete?.(phase);
+        await this.commitAndEnqueueMerge(phase);
       }
     } catch (error) {
       this.updatePhaseStatus(phase, "failed");
@@ -23605,8 +23666,56 @@ 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) {
     const pendingTasks = this.getExecutableTasks(phase);
     while (pendingTasks.length > 0 && !this.stopped) {
@@ -23632,7 +23741,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);
@@ -23855,7 +23965,7 @@ var PhaseOrchestrator = class {
     };
   }
   delay(ms) {
-    return new Promise((resolve7) => setTimeout(resolve7, ms));
+    return new Promise((resolve9) => setTimeout(resolve9, ms));
   }
 };
 
@@ -24499,7 +24609,294 @@ var CheckpointManager = class {
     }
   }
 };
+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);
+    const absDir = resolve(dir);
+    const absRoot = resolve(this.projectRoot);
+    if (!absDir.startsWith(absRoot + sep)) {
+      throw new Error(`Worktree dir "${absDir}" resolves outside project root`);
+    }
+    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 idArgs = await this.identityArgs(handle.dir);
+    const committed = await this.runGit([...idArgs, "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 fromOutput = parseConflictPaths(`${merged.stdout}
+${merged.stderr}`);
+      const fromIndex = await this.unmergedFiles();
+      const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+      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 idArgs = await this.identityArgs(this.projectRoot);
+      const commit = await this.runGit([...idArgs, "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 };
+  }
+  /**
+   * `git -c user.*` fallback so commits succeed on machines and CI runners
+   * that have no global git identity configured. Returns `[]` when both
+   * `user.name` and `user.email` are already set (the common case), so a real
+   * user's identity is never overridden. The worktree branch commits are
+   * squashed away on merge, so the fallback identity never reaches the base
+   * branch history.
+   */
+  async identityArgs(cwd) {
+    const name = (await this.runGit(["config", "user.name"], cwd)).stdout.trim();
+    const email = (await this.runGit(["config", "user.email"], cwd)).stdout.trim();
+    if (name && email) return [];
+    return [
+      "-c",
+      `user.name=${name || "WrongStack AutoPhase"}`,
+      "-c",
+      `user.email=${email || "autophase@wrongstack.local"}`
+    ];
+  }
+  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 parseConflictPaths(output) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const m = line.match(/^CONFLICT \([^)]*\): Merge conflict in (.+?)\s*$/);
+    if (m?.[1]) paths.add(m[1]);
+  }
+  return [...paths];
+}
+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, 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 };
+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