@diologue/local-agent 0.6.0 → 0.8.0

package/dist/cli.mjs

@@ -83,7 +83,7 @@ var init_engine_release = __esm({
 import { access as access2, constants } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import path3 from "node:path";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 var engineRelease, __filename, __dirname, LOCAL_AGENT_ROOT, REPO_ROOT, BUNDLE_DIR_INSTALLED, BUNDLE_DIR_LOCAL_BUILD, ENGINE_BUNDLE_ENV, exists2, resolveOpencodeAiBinary, bundleFilename, findEngineBundle;
 var init_engine_bundle = __esm({
@@ -92,15 +92,15 @@ var init_engine_bundle = __esm({
     init_engine_release();
     engineRelease = engine_release_default;
     __filename = fileURLToPath(import.meta.url);
-    __dirname = path3.dirname(__filename);
-    LOCAL_AGENT_ROOT = path3.resolve(__dirname, "../..");
-    REPO_ROOT = path3.resolve(LOCAL_AGENT_ROOT, "..");
-    BUNDLE_DIR_INSTALLED = path3.join(
+    __dirname = path4.dirname(__filename);
+    LOCAL_AGENT_ROOT = path4.resolve(__dirname, "../..");
+    REPO_ROOT = path4.resolve(LOCAL_AGENT_ROOT, "..");
+    BUNDLE_DIR_INSTALLED = path4.join(
       LOCAL_AGENT_ROOT,
       "dist/engine",
       engineRelease.releaseTag
     );
-    BUNDLE_DIR_LOCAL_BUILD = path3.join(
+    BUNDLE_DIR_LOCAL_BUILD = path4.join(
       REPO_ROOT,
       "build/diologue-engine-bundles"
     );
@@ -117,11 +117,11 @@ var init_engine_bundle = __esm({
       try {
         const require2 = createRequire(import.meta.url);
         const pkgJsonPath = require2.resolve("opencode-ai/package.json");
-        const pkgDir = path3.dirname(pkgJsonPath);
+        const pkgDir = path4.dirname(pkgJsonPath);
         const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
         const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.opencode;
         if (!binRel) return null;
-        return path3.join(pkgDir, binRel);
+        return path4.join(pkgDir, binRel);
       } catch {
         return null;
       }
@@ -145,11 +145,11 @@ var init_engine_bundle = __esm({
         return { path: opencodeAi, source: "opencode-ai" };
       }
       const filename = bundleFilename();
-      const installed = path3.join(BUNDLE_DIR_INSTALLED, filename);
+      const installed = path4.join(BUNDLE_DIR_INSTALLED, filename);
       if (await exists2(installed)) {
         return { path: installed, source: "installed" };
       }
-      const localBuild = path3.join(BUNDLE_DIR_LOCAL_BUILD, filename);
+      const localBuild = path4.join(BUNDLE_DIR_LOCAL_BUILD, filename);
       if (await exists2(localBuild)) {
         return { path: localBuild, source: "local-build" };
       }
@@ -165,7 +165,7 @@ __export(engine_locator_local_exports, {
 });
 import { access as access3, constants as constants2 } from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename2, __dirname2, REPO_ROOT2, DEFAULT_ENGINE_DIR, ENTRY_REL, DEFAULT_STARTUP_TIMEOUT_MS, LISTENING_REGEX, defaultRuntimeCheck, exists3, isRecord, parseExistingInlineConfig, mergeInlineConfig, buildEngineEnv, defaultClientFactory, LocalEngineLocator, truncate;
 var init_engine_locator_local = __esm({
@@ -173,9 +173,9 @@ var init_engine_locator_local = __esm({
     "use strict";
     init_engine_bundle();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = path4.dirname(__filename2);
-    REPO_ROOT2 = path4.resolve(__dirname2, "../../..");
-    DEFAULT_ENGINE_DIR = path4.join(REPO_ROOT2, "build/diologue-engine");
+    __dirname2 = path5.dirname(__filename2);
+    REPO_ROOT2 = path5.resolve(__dirname2, "../../..");
+    DEFAULT_ENGINE_DIR = path5.join(REPO_ROOT2, "build/diologue-engine");
     ENTRY_REL = "packages/opencode/src/index.ts";
     DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
     LISTENING_REGEX = /listening on (https?:\/\/[^\s]+)/i;
@@ -260,7 +260,7 @@ var init_engine_locator_local = __esm({
   - Reinstall the package so postinstall fetches a bundle, or
   - Run \`npm run rebrand-engine\` to populate the source tree.`;
         }
-        const entry = path4.join(this.enginePath, ENTRY_REL);
+        const entry = path5.join(this.enginePath, ENTRY_REL);
         if (!await exists3(entry)) {
           return `[engine-locator/local] Engine entry not found at ${entry}. The rebrand may have produced a partial tree \u2014 re-run \`npm run rebrand-engine\`.`;
         }
@@ -293,7 +293,7 @@ var init_engine_locator_local = __esm({
           command: this.runtime,
           args: [
             "run",
-            path4.join(this.enginePath, ENTRY_REL),
+            path5.join(this.enginePath, ENTRY_REL),
             "serve",
             "--port",
             "0",
@@ -356,7 +356,7 @@ var init_engine_locator_local = __esm({
         return new Promise((resolve, reject) => {
           let settled = false;
           let buffered = "";
-          const tag = `${this.runtime}/${path4.basename(this.enginePath)}`;
+          const tag = `${this.runtime}/${path5.basename(this.enginePath)}`;
           const settle = (fn) => {
             if (settled) return;
             settled = true;
@@ -560,24 +560,11 @@ var createState = () => {
   };
 };
 
-// src/routes/health.ts
-var createHealthHandler = (config) => {
-  return (_req, res) => {
-    const body = {
-      ok: true,
-      helperVersion: config.helperVersion,
-      boundHost: config.host,
-      port: config.port,
-      startedAt: config.startedAt
-    };
-    res.json(body);
-  };
-};
-
-// src/routes/repo.ts
-import { Router as createRouter } from "express";
-import path2 from "node:path";
-import { z } from "zod";
+// src/worktree.ts
+import { existsSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
 
 // src/lib/git.ts
 import { execFile } from "node:child_process";
@@ -726,9 +713,9 @@ var getDiff = async (cwd) => {
   return [trackedDiff, ...untrackedDiffs].filter((part) => part.trim().length > 0).join("\n");
 };
 var runGitWithStdin = async (cwd, args, input) => {
-  const { execFile: execFile3 } = await import("node:child_process");
+  const { execFile: execFile4 } = await import("node:child_process");
   return new Promise((resolve, reject) => {
-    const child = execFile3(
+    const child = execFile4(
       "git",
       args,
       {
@@ -787,10 +774,139 @@ var parseDiffPaths = (unified) => {
   }
   return paths;
 };
+var getRemoteUrl = async (cwd) => {
+  try {
+    return (await runGit(cwd, ["remote", "get-url", "origin"])).trim() || null;
+  } catch (err) {
+    if (err instanceof GitCommandError) return null;
+    throw err;
+  }
+};
+var getDefaultBranch = async (cwd) => {
+  try {
+    const ref = (await runGit(cwd, ["rev-parse", "--abbrev-ref", "origin/HEAD"])).trim();
+    const name = ref.replace(/^origin\//, "");
+    return name || "main";
+  } catch (err) {
+    if (err instanceof GitCommandError) return "main";
+    throw err;
+  }
+};
+var createBranch = async (cwd, name) => {
+  await runGit(cwd, ["checkout", "-b", name]);
+};
+var commitAll = async (cwd, message) => {
+  await runGit(cwd, ["add", "-A"]);
+  await runGit(cwd, ["commit", "-m", message]);
+  return (await runGit(cwd, ["rev-parse", "--short", "HEAD"])).trim();
+};
+var pushBranch = async (cwd, branch) => {
+  await runGit(cwd, ["push", "-u", "origin", branch]);
+};
+var branchNameForTitle = (title) => {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+  const rand = Math.random().toString(36).slice(2, 7);
+  return `diologue/${slug || "change"}-${rand}`;
+};
+var branchExists = async (repoPath, branch) => {
+  try {
+    await runGit(repoPath, [
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/heads/${branch}`
+    ]);
+    return true;
+  } catch (err) {
+    if (err instanceof GitCommandError) return false;
+    throw err;
+  }
+};
+var addWorktree = async (repoPath, worktreePath, branch) => {
+  await runGit(repoPath, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+};
+var addWorktreeForBranch = async (repoPath, worktreePath, branch) => {
+  await runGit(repoPath, ["worktree", "add", worktreePath, branch]);
+};
+var removeWorktree = async (repoPath, worktreePath) => {
+  await runGit(repoPath, ["worktree", "remove", "--force", worktreePath]);
+};
+var pruneWorktrees = async (repoPath) => {
+  await runGit(repoPath, ["worktree", "prune"]);
+};
+
+// src/worktree.ts
+var sanitize = (s) => s.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 50) || "session";
+var createWorktreeManager = (options = {}) => {
+  const baseDir = options.baseDir ?? path.join(homedir(), ".diologue", "worktrees");
+  const map = /* @__PURE__ */ new Map();
+  const ensure = async (sessionId, repoPath, baseBranch) => {
+    const existing = map.get(sessionId);
+    if (existing && existsSync(existing.path)) return existing;
+    const safe = sanitize(sessionId);
+    const branch = `diologue/${safe}`;
+    const worktreePath = path.join(baseDir, safe);
+    await mkdir(baseDir, { recursive: true });
+    await pruneWorktrees(repoPath).catch(() => void 0);
+    if (existsSync(worktreePath)) {
+      await removeWorktree(repoPath, worktreePath).catch(() => void 0);
+      await rm(worktreePath, { recursive: true, force: true }).catch(
+        () => void 0
+      );
+      await pruneWorktrees(repoPath).catch(() => void 0);
+    }
+    if (await branchExists(repoPath, branch)) {
+      await addWorktreeForBranch(repoPath, worktreePath, branch);
+    } else {
+      await addWorktree(repoPath, worktreePath, branch);
+    }
+    const info = {
+      path: worktreePath,
+      branch,
+      base: baseBranch,
+      repoPath
+    };
+    map.set(sessionId, info);
+    return info;
+  };
+  const get = (sessionId) => map.get(sessionId) ?? null;
+  const remove = async (sessionId) => {
+    const info = map.get(sessionId);
+    if (!info) return;
+    map.delete(sessionId);
+    await removeWorktree(info.repoPath, info.path).catch(() => void 0);
+    await rm(info.path, { recursive: true, force: true }).catch(
+      () => void 0
+    );
+  };
+  const cleanupAll = async () => {
+    for (const id of [...map.keys()]) await remove(id);
+  };
+  return { ensure, get, remove, cleanupAll };
+};
+
+// src/routes/health.ts
+var createHealthHandler = (config) => {
+  return (_req, res) => {
+    const body = {
+      ok: true,
+      helperVersion: config.helperVersion,
+      boundHost: config.host,
+      port: config.port,
+      startedAt: config.startedAt
+    };
+    res.json(body);
+  };
+};
+
+// src/routes/repo.ts
+import { Router as createRouter } from "express";
+import path3 from "node:path";
+import { z } from "zod";
 
 // src/lib/paths.ts
 import { access, lstat, realpath, stat } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 var InvalidRepoPathError = class extends Error {
   code;
   constructor(code, message) {
@@ -815,7 +931,7 @@ var validateRepoPath = async (raw) => {
   if (trimmed.length === 0) {
     throw new InvalidRepoPathError("empty", "path must not be empty");
   }
-  if (!path.isAbsolute(trimmed)) {
+  if (!path2.isAbsolute(trimmed)) {
     throw new InvalidRepoPathError(
       "not_absolute",
       `path must be absolute (got: ${trimmed})`
@@ -837,7 +953,7 @@ var validateRepoPath = async (raw) => {
       `path is not a directory: ${resolved}`
     );
   }
-  const gitMarker = path.join(resolved, ".git");
+  const gitMarker = path2.join(resolved, ".git");
   if (!await exists(gitMarker)) {
     throw new InvalidRepoPathError(
       "not_a_git_repo",
@@ -850,7 +966,7 @@ var validateRepoPath = async (raw) => {
 
 // src/lib/pick-directory.ts
 import { execFile as execFile2 } from "node:child_process";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 var PROMPT = "Select a git repository";
 var dialogSpec = (platform) => {
   switch (platform) {
@@ -910,21 +1026,94 @@ var pickDirectory = async () => {
   };
   const result = await attempt(spec.cmd, spec.args);
   if (!result.ok && result.reason === "no_gui" && process.platform === "linux") {
-    return attempt("kdialog", ["--getexistingdirectory", homedir()]);
+    return attempt("kdialog", ["--getexistingdirectory", homedir2()]);
   }
   return result;
 };
 
+// src/lib/github.ts
+import { execFile as execFile3 } from "node:child_process";
+var GhError = class extends Error {
+  constructor(message, code, stderr) {
+    super(message);
+    this.code = code;
+    this.stderr = stderr;
+    this.name = "GhError";
+  }
+};
+var run2 = (args, cwd) => new Promise((resolve, reject) => {
+  execFile3(
+    "gh",
+    args,
+    { cwd, timeout: 6e4, windowsHide: true },
+    (err, stdout, stderr) => {
+      if (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          reject(
+            new GhError(
+              "The GitHub CLI (gh) isn't installed on this machine.",
+              "gh_unavailable"
+            )
+          );
+          return;
+        }
+        reject(new GhError(stderr || err.message, "gh_failed", stderr));
+        return;
+      }
+      resolve({ stdout, stderr });
+    }
+  );
+});
+var ghReady = async () => {
+  try {
+    await run2(["auth", "status"]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var createPullRequest = async (opts) => {
+  const { stdout } = await run2(
+    [
+      "pr",
+      "create",
+      "--base",
+      opts.base,
+      "--head",
+      opts.head,
+      "--title",
+      opts.title,
+      "--body",
+      opts.body
+    ],
+    opts.cwd
+  );
+  const url = stdout.split("\n").map((l) => l.trim()).filter(Boolean).reverse().find((l) => l.startsWith("http"));
+  if (!url) {
+    throw new GhError("gh pr create didn't return a PR URL.", "gh_failed", stdout);
+  }
+  return url;
+};
+
 // src/routes/repo.ts
 var selectRepoSchema = z.object({
   path: z.string().min(1)
 });
 var applyPatchSchema = z.object({
   unified: z.string().min(1).max(8 * 1024 * 1024),
-  baselineHash: z.string().optional()
+  baselineHash: z.string().optional(),
+  sessionId: z.string().min(1).optional()
 });
 var revertPatchSchema = z.object({
-  unified: z.string().min(1).max(8 * 1024 * 1024)
+  unified: z.string().min(1).max(8 * 1024 * 1024),
+  sessionId: z.string().min(1).optional()
+});
+var createPrSchema = z.object({
+  title: z.string().min(1).max(200),
+  body: z.string().max(2e4).optional(),
+  /** When set, the PR is created from this session's worktree branch. */
+  sessionId: z.string().min(1).optional()
 });
 var buildRepoStatus = async (resolvedPath) => {
   const [branch, head, dirty] = await Promise.all([
@@ -934,7 +1123,7 @@ var buildRepoStatus = async (resolvedPath) => {
   ]);
   return {
     path: resolvedPath,
-    name: path2.basename(resolvedPath),
+    name: path3.basename(resolvedPath),
     branch,
     head,
     isDirty: dirty
@@ -958,7 +1147,8 @@ var requireSelectedRepo = (state, res) => {
   }
   return repo;
 };
-var createRepoRouter = (state) => {
+var readSessionId = (value) => typeof value === "string" && value ? value : void 0;
+var createRepoRouter = (state, worktrees) => {
   const router = createRouter();
   router.post("/select", async (req, res) => {
     const parsed = selectRepoSchema.safeParse(req.body);
@@ -1001,6 +1191,69 @@ var createRepoRouter = (state) => {
       message: "No desktop folder dialog is available on this machine. Type the repo path instead."
     });
   });
+  router.post("/create-pr", async (req, res) => {
+    const repo = requireSelectedRepo(state, res);
+    if (!repo) return;
+    const parsed = createPrSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "invalid_body", issues: parsed.error.issues });
+      return;
+    }
+    const { title } = parsed.data;
+    const body = parsed.data.body ?? "Opened from the Diologue coding agent.";
+    const worktree = parsed.data.sessionId ? worktrees.get(parsed.data.sessionId) : null;
+    const cwd = worktree ? worktree.path : repo.path;
+    try {
+      if (!await ghReady()) {
+        res.status(501).json({
+          error: "gh_unavailable",
+          message: "GitHub CLI (gh) isn't installed or authenticated on this machine. Run `gh auth login`, or push the branch and open the PR manually."
+        });
+        return;
+      }
+      if (!await getRemoteUrl(cwd)) {
+        res.status(400).json({
+          error: "no_remote",
+          message: "This repo has no `origin` remote. Add one (git remote add origin \u2026) before creating a PR."
+        });
+        return;
+      }
+      if (!await isDirty(cwd)) {
+        res.status(409).json({
+          error: "nothing_to_commit",
+          message: "There are no changes in the working tree to open a PR for."
+        });
+        return;
+      }
+      let branch;
+      let base;
+      if (worktree) {
+        branch = worktree.branch;
+        base = worktree.base;
+      } else {
+        const current = await getBranch(cwd) ?? "";
+        const onAgentBranch = current.startsWith("diologue/");
+        base = onAgentBranch ? await getDefaultBranch(cwd) : current || "main";
+        branch = onAgentBranch ? current : branchNameForTitle(title);
+        if (!onAgentBranch) await createBranch(cwd, branch);
+      }
+      await commitAll(cwd, title);
+      await pushBranch(cwd, branch);
+      const url = await createPullRequest({ cwd, base, head: branch, title, body });
+      const payload = { url, branch, base };
+      res.json(payload);
+    } catch (err) {
+      if (err instanceof GhError) {
+        res.status(502).json({ error: err.code, message: err.message });
+        return;
+      }
+      if (err instanceof GitCommandError) {
+        sendGitError(res, err);
+        return;
+      }
+      throw err;
+    }
+  });
   router.get("/status", async (_req, res) => {
     const repo = state.getSelectedRepo();
     if (!repo) {
@@ -1021,13 +1274,23 @@ var createRepoRouter = (state) => {
       throw err;
     }
   });
-  router.get("/diff", async (_req, res) => {
+  const resolveWorkdir = (repo, sessionId) => {
+    if (!sessionId) return repo.path;
+    const wt = worktrees.get(sessionId);
+    return wt ? wt.path : null;
+  };
+  router.get("/diff", async (req, res) => {
     const repo = requireSelectedRepo(state, res);
     if (!repo) {
       return;
     }
+    const workdir = resolveWorkdir(repo, readSessionId(req.query.sessionId));
+    if (!workdir) {
+      res.json({ unified: "", sizeBytes: 0 });
+      return;
+    }
     try {
-      const unified = await getDiff(repo.path);
+      const unified = await getDiff(workdir);
       const body = {
         unified,
         sizeBytes: Buffer.byteLength(unified, "utf8")
@@ -1041,13 +1304,18 @@ var createRepoRouter = (state) => {
       throw err;
     }
   });
-  router.get("/changed-files", async (_req, res) => {
+  router.get("/changed-files", async (req, res) => {
     const repo = requireSelectedRepo(state, res);
     if (!repo) {
       return;
     }
+    const workdir = resolveWorkdir(repo, readSessionId(req.query.sessionId));
+    if (!workdir) {
+      res.json({ files: [] });
+      return;
+    }
     try {
-      const files = await getStatusShort(repo.path);
+      const files = await getStatusShort(workdir);
       const body = { files };
       res.json(body);
     } catch (err) {
@@ -1066,8 +1334,9 @@ var createRepoRouter = (state) => {
       res.status(400).json({ error: "invalid_body", issues: parsed.error.issues });
       return;
     }
+    const applyWorkdir = parsed.data.sessionId && worktrees.get(parsed.data.sessionId)?.path || repo.path;
     try {
-      const check = await canApplyDiff(repo.path, parsed.data.unified);
+      const check = await canApplyDiff(applyWorkdir, parsed.data.unified);
       if (!check.ok) {
         res.status(409).json({
           error: "diff_does_not_apply",
@@ -1076,7 +1345,7 @@ var createRepoRouter = (state) => {
         });
         return;
       }
-      await applyDiff(repo.path, parsed.data.unified);
+      await applyDiff(applyWorkdir, parsed.data.unified);
       const paths = parseDiffPaths(parsed.data.unified);
       const body = {
         ok: true,
@@ -1100,8 +1369,9 @@ var createRepoRouter = (state) => {
       res.status(400).json({ error: "invalid_body", issues: parsed.error.issues });
       return;
     }
+    const revertWorkdir = parsed.data.sessionId && worktrees.get(parsed.data.sessionId)?.path || repo.path;
     try {
-      const check = await canRevertDiff(repo.path, parsed.data.unified);
+      const check = await canRevertDiff(revertWorkdir, parsed.data.unified);
       if (!check.ok) {
         res.status(409).json({
           error: "diff_does_not_revert",
@@ -1110,7 +1380,7 @@ var createRepoRouter = (state) => {
         });
         return;
       }
-      await revertDiff(repo.path, parsed.data.unified);
+      await revertDiff(revertWorkdir, parsed.data.unified);
       const paths = parseDiffPaths(parsed.data.unified);
       const body = {
         ok: true,
@@ -1379,8 +1649,21 @@ var createAgentRouter = (deps) => {
       res.status(409).json({ error: "no_repo_selected" });
       return;
     }
+    let workdir = repo.path;
+    try {
+      const worktree = await deps.worktrees.ensure(
+        parsed.data.sessionId,
+        repo.path,
+        repo.branch ?? "main"
+      );
+      workdir = worktree.path;
+    } catch (err) {
+      logAgentRoute(
+        `worktree create failed (falling back to in-place) session=${parsed.data.sessionId.slice(0, 8)} error=${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     logAgentRoute(
-      `message start session=${parsed.data.sessionId.slice(0, 8)} repo=${repo.path} promptChars=${parsed.data.prompt.length} provider=${parsed.data.preferredProvider ?? "(default)"} model=${parsed.data.preferredModel ?? "(default)"}`
+      `message start session=${parsed.data.sessionId.slice(0, 8)} repo=${repo.path} workdir=${workdir} promptChars=${parsed.data.prompt.length} provider=${parsed.data.preferredProvider ?? "(default)"} model=${parsed.data.preferredModel ?? "(default)"}`
     );
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache, no-transform");
@@ -1403,7 +1686,7 @@ var createAgentRouter = (deps) => {
       const history = parsed.data.history ? parsed.data.history.map((m) => ({ role: m.role, content: m.content })) : void 0;
       for await (const event of deps.adapter.streamMessage({
         sessionId: parsed.data.sessionId,
-        repoPath: repo.path,
+        repoPath: workdir,
         prompt: parsed.data.prompt,
         history,
         signal: controller.signal,
@@ -2588,8 +2871,8 @@ var mapEvent = (item, state) => {
           {
             type: "diff_proposed",
             unified: "",
-            files: files.map((path6) => ({
-              path: path6,
+            files: files.map((path7) => ({
+              path: path7,
               additions: 0,
               deletions: 0,
               status: "modified"
@@ -3091,13 +3374,17 @@ var createApp = (options) => {
   const state = options.state ?? createState();
   const adapter = options.adapter ?? buildDefaultAdapter();
   const brokerRegistry = createBrokerRegistry();
+  const worktrees = createWorktreeManager();
   const app = express();
   app.use(express.json({ limit: "1mb" }));
   app.use(createCorsMiddleware({ allowedOrigin: options.config.allowedOrigin }));
   app.use(createAuthMiddleware({ token: options.config.token }));
   app.get("/health", createHealthHandler(options.config));
-  app.use("/repo", createRepoRouter(state));
-  app.use("/agent", createAgentRouter({ state, adapter, brokerRegistry }));
+  app.use("/repo", createRepoRouter(state, worktrees));
+  app.use(
+    "/agent",
+    createAgentRouter({ state, adapter, brokerRegistry, worktrees })
+  );
   app.use("/agent/llm-response", createLlmResponseRouter({ brokerRegistry }));
   app.use("/agent/llm-chunk", createLlmChunkRouter({ brokerRegistry }));
   app.use("/agent/permission", createPermissionRouter({ adapter }));
@@ -3105,7 +3392,7 @@ var createApp = (options) => {
   app.use((req, res) => {
     res.status(404).json({ error: "not_found", method: req.method, path: req.path });
   });
-  return { app, state, adapter, brokerRegistry };
+  return { app, state, adapter, brokerRegistry, worktrees };
 };
 
 // src/modes/quickstart.ts
@@ -3200,7 +3487,7 @@ var runQuickstart = async (options) => {
 
 // src/lib/keychain.ts
 import { promises as fs } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 import os from "node:os";
 var KEYTAR_SERVICE = "diologue.local-agent";
 var KEYTAR_ACCOUNT = "device-credential";
@@ -3223,7 +3510,7 @@ var loadKeytar = async () => {
 };
 var fileFallbackPath = () => {
   const home = os.homedir();
-  return path5.join(home, ".diologue", "credentials");
+  return path6.join(home, ".diologue", "credentials");
 };
 var createCredentialStore = (options = {}) => {
   const filePath = options.filePathOverride ?? fileFallbackPath();
@@ -3270,7 +3557,7 @@ var createCredentialStore = (options = {}) => {
           return { backend: "keychain" };
         }
       }
-      await fs.mkdir(path5.dirname(filePath), { recursive: true });
+      await fs.mkdir(path6.dirname(filePath), { recursive: true });
       await fs.writeFile(filePath, JSON.stringify(credential, null, 2), {
         mode: 384
       });
@@ -3319,7 +3606,7 @@ var runStart = async (options) => {
     process.env.LOCAL_AGENT_ALLOWED_ORIGIN = options.allowedOrigin;
   if (options.adapter) process.env.LOCAL_AGENT_ADAPTER = options.adapter;
   const config = loadConfig();
-  const { app, adapter } = createApp({ config });
+  const { app, adapter, worktrees } = createApp({ config });
   const server = app.listen(config.port, config.host, async () => {
     const url = `http://${config.host}:${config.port}`;
     console.log(`[local-agent] Listening on ${url}`);
@@ -3335,7 +3622,9 @@ var runStart = async (options) => {
   const shutdown = (signal) => {
     console.log(`
 [local-agent] Received ${signal}, shutting down...`);
-    server.close(() => process.exit(0));
+    void worktrees.cleanupAll().finally(() => {
+      server.close(() => process.exit(0));
+    });
     setTimeout(() => process.exit(0), 3e3).unref();
   };
   process.on("SIGINT", shutdown);