@prestyj/cli 5.20.0 → 5.21.0

package/README.md

@@ -177,7 +177,7 @@ Plus the [Grep MCP](https://grep.dev) for searching across 1M+ public GitHub rep
 
 Only GPT-5.6 Sol/Terra at **Ultra** delegates proactively. Lower Sol/Terra levels use async agents only when the user or project/skill instructions request delegation; other models receive no proactive policy.
 
-Children share the parent working directory, not isolated worktrees. Parallel writes must target disjoint files or subsystems. Async fan-out is one level deep, child output is bounded, idle workers reap after 10 minutes, and workers are not resumable after a CLI/app restart.
+Children share the parent working directory by default, so parallel writes must target disjoint files or subsystems. Pass `isolate: true` to `subagent` to give a child its own copy of the repo on a new branch instead — the right choice when several children edit at once, or when a child's changes should land on a branch of their own. The copy is reclaimed automatically when the child finishes without committing; a child that did commit keeps its branch, because that branch is the deliverable. `/integrate` then merges those branches one at a time, running the suite between each. Async fan-out is one level deep, child output is bounded, idle workers reap after 10 minutes, and workers are not resumable after a CLI/app restart.
 
 Parent cancellation interrupts active children. Session disposal shuts down every worker process alongside background commands, LSP servers, and MCP connections.
 

package/dist/app-sidecar.js

@@ -28,6 +28,7 @@ import { RunLifecycle } from "./core/run-lifecycle.js";
 import { RunClaim } from "./core/run-claim.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, switchChatAgent, } from "./chat-agents/index.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
+import { createWorktree, removeWorktree, sweepWorktrees, worktreeStatuses, } from "./core/worktree.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
 import { buildNolanSystemPrompt, buildNolanAutopilotSystemPrompt } from "./core/nolan-prompt.js";
 import { buildNolanDigest, buildNolanAutopilotContext, buildNolanAutopilotPlanContext, } from "./core/nolan-context.js";
@@ -3016,6 +3017,125 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Create an isolated git worktree for a project so a second window can work
+        // on the same repo without fighting the first over the working tree. The
+        // caller passes the project cwd; the module resolves the repo's MAIN root
+        // itself, so opening this from an already-linked worktree still branches
+        // off the real repo rather than nesting.
+        //
+        // The dirty gate in `createWorktree` is deliberate: branching a main
+        // checkout that has uncommitted work would strand those edits on a tree the
+        // user is about to stop looking at. It surfaces here as a 409 the picker
+        // renders verbatim.
+        if (method === "POST" && url === "/worktree") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const repoDir = body.cwd?.trim();
+                if (!repoDir) {
+                    json(res, 400, { error: "cwd is required" });
+                    return;
+                }
+                try {
+                    const created = await createWorktree({
+                        repoDir,
+                        branch: body.branch?.trim() || undefined,
+                        baseRef: body.baseRef?.trim() || undefined,
+                    });
+                    json(res, 200, created);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    // Dirty tree / not-a-repo are the user's to resolve, not bugs.
+                    const expected = message.includes("uncommitted changes") || message.includes("Not a git repository");
+                    json(res, expected ? 409 : 500, { error: message });
+                }
+            });
+            return;
+        }
+        // Every managed copy of a repo with the state the picker needs to decide
+        // what to offer: branch, unsaved files, unmerged commits, and why a copy
+        // cannot be reclaimed. `busy` paths come from the caller (the app knows its
+        // own windows; the daemon does not), repeated as `busy=` params.
+        if (method === "GET" && (url === "/worktrees" || url.startsWith("/worktrees?"))) {
+            const params = new URL(url, `http://${host}`).searchParams;
+            const target = params.get("cwd")?.trim() || cwd;
+            void worktreeStatuses(target, params.getAll("busy"))
+                .then((worktrees) => json(res, 200, { worktrees }))
+                .catch((err) => {
+                // Not-a-repo is the common case here, not a fault: answer "none".
+                log("INFO", "app-sidecar", "worktreeStatuses failed", {
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                json(res, 200, { worktrees: [] });
+            });
+            return;
+        }
+        // Remove one copy. `force` is the user having seen what would be lost and
+        // said yes anyway, so it is never defaulted on.
+        //
+        // `path` arrives from the client, and a request naming a path is not
+        // permission to delete it: `removeWorktree` re-derives the managed root
+        // from the repo itself and refuses anything outside it, or reached through
+        // a symlink. The check lives there so no caller can skip it.
+        if (method === "DELETE" && url === "/worktree") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const worktreePath = body.path?.trim();
+                if (!worktreePath) {
+                    json(res, 400, { error: "path is required" });
+                    return;
+                }
+                const release = await removeWorktree({
+                    repoDir: body.cwd?.trim() || cwd,
+                    worktreePath,
+                    force: body.force === true,
+                });
+                // removeWorktree never throws; a refusal is a 409 the UI shows as
+                // written, matching the dirty-checkout gate on POST above.
+                json(res, release.freed ? 200 : 409, release);
+            });
+            return;
+        }
+        // Reclaim every copy that provably holds no work. Never forces: anything
+        // with unsaved or unmerged changes comes back under `kept` with a reason
+        // and waits for a human. Called on window close and on daemon startup.
+        if (method === "POST" && url === "/worktrees/sweep") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const busy = Array.isArray(body.busyPaths)
+                    ? body.busyPaths.filter((p) => typeof p === "string")
+                    : [];
+                json(res, 200, await sweepWorktrees(body.cwd?.trim() || cwd, busy));
+            });
+            return;
+        }
         // Dismiss a project from the picker (or restore it with hidden:false). The
         // path is kept rather than the row: sessions in scratch dirs keep
         // re-surfacing, so the user's decision has to outlive any one scan.