@prestyj/cli 5.20.0 → 5.22.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,12 +28,14 @@ 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";
 import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, extractTurnToolCalls, isMechanicalOnlyTurn, } from "./core/autopilot-gate.js";
 import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-cycle.js";
+import { describeRunVerification, describeTurnVerification } from "./core/run-status.js";
 import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
 import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, getHistoryMessageVisibility, replayMessagesInOrder, restoreUserRow, restoreAssistantTexts, resolveRestoredCommand, autopilotMarkerCopySeed, } from "./core/session-history.js";
 import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export.js";
@@ -1829,6 +1831,11 @@ async function createSession(deps, opts) {
         recordApprovedPlanMarkers(d.text);
     });
     session.eventBus.on("thinking_delta", (d) => broadcast("thinking_delta", d));
+    session.eventBus.on("retry", (d) => {
+        if (!d.silent)
+            broadcast("retry", { reason: d.reason, attempt: d.attempt, delayMs: d.delayMs });
+    });
+    session.eventBus.on("max_turns", (d) => broadcast("max_turns", d));
     // The agent consumed queued steering at a turn boundary. Re-broadcast as the
     // usual `queued` depth update so the webview drops the pending affordance the
     // moment the message lands in the loop, not at run_end.
@@ -2138,8 +2145,10 @@ async function createSession(deps, opts) {
         // his own Ideal self-review adds latency and can corrupt the verdict shape.
         nolanAgent.setIdealReviewSuppressed(true);
         await nolanAgent.initialize();
-        // Deliberately no bus bridge: the review is silent. Errors surface via the
-        // runAutopilotReview try/catch as autopilot_error frames.
+        // Keep review text/tools silent; report usage only for whole-task accounting.
+        nolanAgent.eventBus.on("turn_end", (d) => {
+            broadcast("autopilot_usage", { outputTokens: d.usage.outputTokens });
+        });
         nolanAutoSession = nolanAgent;
         log("INFO", "app-sidecar", "nolan autopilot session ready", {
             provider: target.provider,
@@ -2181,7 +2190,7 @@ async function createSession(deps, opts) {
     }
     // Core provider-run bracket. Standalone runs own a lifecycle generation;
     // injected autopilot runs share the cycle's outer generation.
-    async function runAgent(label, run) {
+    async function runAgent(label, run, reviewPending = () => false) {
         const ownsGeneration = !runLifecycle.running;
         const generation = ownsGeneration
             ? runLifecycle.begin(abortOwnedWork).generation
@@ -2194,7 +2203,11 @@ async function createSession(deps, opts) {
         const cancelGenAtStart = cancelGeneration;
         const assistantsBeforeRun = countAssistantMessages(session.getMessages());
         let runSucceeded = false;
-        broadcast("run_start", { text: label, runState: runLifecycle.state });
+        broadcast("run_start", {
+            text: label,
+            runState: runLifecycle.state,
+            continued: !ownsGeneration,
+        });
         try {
             if (!runLifecycle.isCancellationRequested(generation))
                 await run();
@@ -2265,6 +2278,16 @@ async function createSession(deps, opts) {
                 broadcast("run_end", {
                     ...(cancelled ? { cancelled: true } : {}),
                     ...(verificationProblem ? { unverified: true } : {}),
+                    failed: !cancelled && !runSucceeded,
+                    // The cycle refuses an unresolved verification gate. Do not advertise
+                    // a review handoff that will exit before emitting any review events.
+                    reviewPending: !cancelled &&
+                        runSucceeded &&
+                        !verificationProblem &&
+                        (reviewPending() || !ownsGeneration),
+                    ...describeRunVerification(session.getVerificationEvidence(), verificationProblem),
+                    turnVerification: describeTurnVerification(session.getRunVerificationActivity(), verificationProblem),
+                    ...(verificationProblem ? { verificationReason: verificationProblem } : {}),
                     runState: runLifecycle.state,
                 });
             }
@@ -2553,7 +2576,7 @@ async function createSession(deps, opts) {
                     else {
                         await session.prompt(next.text);
                     }
-                });
+                }, () => autopilot);
                 const decision = shouldStartAutopilotCycle({
                     enabled: autopilot,
                     cancelled: autopilotCancelled,
@@ -2575,7 +2598,8 @@ async function createSession(deps, opts) {
                     });
                     await runAutopilotCycle(next.text);
                 }
-                else if (autopilot) {
+                else {
+                    broadcast("autopilot_ignored", { reason: decision.reason });
                     log("INFO", "app-sidecar", "autopilot skipped (queued turn)", {
                         reason: decision.reason,
                     });
@@ -2879,6 +2903,7 @@ async function createSession(deps, opts) {
                     mode,
                     chatAgent,
                     running,
+                    reviewPending: autopilotActive,
                     runState: runLifecycle.state,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -3016,6 +3041,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.
@@ -3626,7 +3770,7 @@ async function createSession(deps, opts) {
                         // while the webview keeps showing the short `/name`.
                         await session.prompt(text);
                     }
-                });
+                }, () => autopilot);
                 // After the user's run settles, kick off Nolan's auto-review loop — but
                 // only when the turn is actually reviewable (shouldStartAutopilotCycle):
                 // workflow commands (/compare, /expand, …) end with reports or
@@ -3655,7 +3799,8 @@ async function createSession(deps, opts) {
                     log("INFO", "app-sidecar", "autopilot cycle starting", { kind: decision.kind });
                     await runAutopilotCycle(text);
                 }
-                else if (autopilot) {
+                else {
+                    broadcast("autopilot_ignored", { reason: decision.reason });
                     log("INFO", "app-sidecar", "autopilot skipped", { reason: decision.reason });
                 }
                 // A prompt sent while Nolan was reviewing (build idle) queued but had no