@spencer-kit/coder-studio 0.3.10 → 0.3.11

package/dist/esm/bin.mjs

@@ -1018,7 +1018,14 @@ var init_image = __esm({
 
 // packages/server/src/fs/file-io.ts
 import { createHash } from "crypto";
-import { readFile as fsReadFile, writeFile as fsWriteFile, mkdir, rm, stat } from "fs/promises";
+import {
+  readFile as fsReadFile,
+  rename as fsRename,
+  writeFile as fsWriteFile,
+  mkdir,
+  rm,
+  stat
+} from "fs/promises";
 import { dirname as dirname2, isAbsolute, relative, resolve as resolve2 } from "path";
 async function statSafe(path10) {
   try {
@@ -1052,6 +1059,27 @@ async function deleteEntry(rootPath, relPath) {
   }
   await rm(abs, { recursive: true });
 }
+async function renameEntry(rootPath, fromPath, toPath) {
+  const fromAbs = resolveSafe(rootPath, fromPath);
+  const toAbs = resolveSafe(rootPath, toPath);
+  const source = await statSafe(fromAbs);
+  const target = await statSafe(toAbs);
+  const fromParent = dirname2(fromAbs);
+  const toParent = dirname2(toAbs);
+  if (!source) {
+    throw { code: "not_found", message: "Source not found" };
+  }
+  if (fromParent !== toParent) {
+    throw {
+      code: "rename_across_directories_not_supported",
+      message: "Rename must stay within the current directory"
+    };
+  }
+  if (target) {
+    throw { code: "already_exists", message: "Target already exists" };
+  }
+  await fsRename(fromAbs, toAbs);
+}
 function resolveSafe(root, relPath) {
   const absRoot = resolve2(root);
   const abs = resolve2(absRoot, relPath);
@@ -2032,12 +2060,12 @@ var init_auto_fetch = __esm({
       }
       acquireWorkspaceOperation(workspaceId) {
         const state = this.getOrCreateState(workspaceId);
-        return new Promise((resolve4) => {
+        return new Promise((resolve5) => {
           const grant = () => {
             state.inFlight = true;
             state.nextFetchAt = void 0;
             let released = false;
-            resolve4(() => {
+            resolve5(() => {
               if (released) {
                 return;
               }
@@ -2065,7 +2093,7 @@ var init_auto_fetch = __esm({
 // packages/server/src/provider-runtime/command-runner.ts
 import { spawn } from "node:child_process";
 async function runCommandAsString(file, args, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = spawn(file, args, {
       shell: shouldUseShellForCommand(file, process.platform),
       windowsHide: options?.windowsHide ?? true
@@ -2090,7 +2118,7 @@ async function runCommandAsString(file, args, options) {
       const stdout = Buffer.concat(stdoutChunks).toString("utf8");
       const stderr = Buffer.concat(stderrChunks).toString("utf8");
       if (code === 0) {
-        resolve4({ stdout, stderr });
+        resolve5({ stdout, stderr });
         return;
       }
       reject(
@@ -2699,6 +2727,13 @@ ${details.stdout}`.toLowerCase();
   }
 });
 
+// packages/core/src/domain/diagnostics.ts
+var init_diagnostics = __esm({
+  "packages/core/src/domain/diagnostics.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/domain/events.ts
 var init_events = __esm({
   "packages/core/src/domain/events.ts"() {
@@ -2949,6 +2984,7 @@ var init_idle_heuristics2 = __esm({
 var init_src3 = __esm({
   "packages/core/src/index.ts"() {
     "use strict";
+    init_diagnostics();
     init_events();
     init_mcp();
     init_provider_install();
@@ -5032,13 +5068,13 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
     return;
   }
   const arch = deps.arch ?? process.arch;
-  const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
+  const resolve5 = deps.resolve ?? ((id) => require2.resolve(id));
   const fileExists = deps.existsSync ?? existsSync4;
-  const stat7 = deps.statSync ?? statSync;
+  const stat8 = deps.statSync ?? statSync;
   const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
-    packageJsonPath = resolve4(NODE_PTY_PKG);
+    packageJsonPath = resolve5(NODE_PTY_PKG);
   } catch {
     return;
   }
@@ -5052,7 +5088,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
     if (!fileExists(helperPath)) {
       return;
     }
-    const currentMode = stat7(helperPath).mode;
+    const currentMode = stat8(helperPath).mode;
     const executableMode = currentMode | 73;
     if (executableMode === currentMode) {
       return;
@@ -5103,7 +5139,7 @@ async function escalateKillWithPolling(pid, signal, options) {
   const startTime = Date.now();
   const deadline = startTime + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
     if (!isProcessAlive(pid)) {
       return true;
     }
@@ -5255,38 +5291,107 @@ var init_settings = __esm({
 
 // packages/server/src/supervisor/evaluator.ts
 import { spawn as spawn2 } from "node:child_process";
-function buildPrompt(context) {
+function buildPrompt(context, mode) {
+  if (mode === "decompose") {
+    return [
+      "You are an autonomous supervisor for a target-scoped software task.",
+      "Your first job is to decompose the target into a supervision structure before evaluation begins.",
+      "",
+      "Return JSON only.",
+      "No prose before or after the JSON.",
+      "",
+      "Decomposition policy:",
+      "- Do not ask the user any questions.",
+      "- Do not ask for clarification, confirmation, or approval.",
+      "- Do not propose options for the user to choose from.",
+      "- If information is incomplete, make the most conservative reasonable assumptions and decide the decomposition yourself.",
+      "- Your job is to return the best useful decomposition now, not to begin a discussion or planning workflow.",
+      "- Keep the user-visible target as the top-level supervision owner.",
+      '- Choose "stage" by default.',
+      '- Choose "subtarget" only when the work clearly breaks into independently deliverable and independently verifiable workstreams.',
+      "- If the distinction is unclear, choose stage.",
+      "- Produce 1 to 7 decomposition items.",
+      "- Each item must be concrete, milestone-sized, and useful for subsequent evaluation.",
+      "- Do not leave the structure empty.",
+      "",
+      "Item requirements:",
+      '- Each item must include "id", "kind", "title", "objective", "deliverable", "acceptanceCriteria", and "status".',
+      '- "kind" must match the selected decompositionMode: all "stage" or all "subtarget".',
+      '- "acceptanceCriteria" must be a non-empty string array.',
+      '- Use statuses "pending", "in_progress", or "done".',
+      "- Usually mark the first active item as in_progress and the rest as pending.",
+      "",
+      "Output schema:",
+      "{",
+      '  "mode": "decompose",',
+      '  "decompositionMode": "stage" | "subtarget",',
+      '  "items": [',
+      '    { "id": string, "kind": "stage" | "subtarget", "title": string, "objective": string, "deliverable": string, "acceptanceCriteria": string[], "status": "pending" | "in_progress" | "done" }',
+      "  ],",
+      '  "activeItemId": optional string,',
+      '  "progressSummary": optional brief summary',
+      "}",
+      "",
+      "Current objective:",
+      context.objective,
+      "",
+      "Current target memory:",
+      JSON.stringify(context.targetMemory, null, 2),
+      "",
+      "Latest user input:",
+      context.latestUserInput?.trim() || "(none)",
+      "",
+      "Current terminal snapshot:",
+      context.terminalExcerpt || "(no output yet)"
+    ].join("\n");
+  }
   const lines = [
     "You are an autonomous supervisor for a target-scoped software task.",
     "Your job is to keep the agent moving toward the objective until the objective is complete.",
     "",
     "Return JSON only.",
+    "No prose before or after the JSON.",
     "",
     "Decision policy:",
-    '- Prefer "continue" whenever there is a reasonable next action.',
+    '- Prefer "continue" over "stop" whenever the objective is not yet verified complete and there is a concrete next action.',
+    '- "continue" may mean continuing the current item, verifying the current item, unblocking the current item, or advancing to the next item only after the current item is verified done.',
     "- Do not ask the user to decide, clarify, or choose among implementation options.",
+    "- Do not tell the agent to ask the user to decide, clarify, or choose among implementation options unless continuing would likely be unsafe or clearly unsupported.",
+    "- If the agent asks a question or presents multiple options, choose the most conservative reasonable option yourself and direct the next action.",
+    "- If multiple reasonable paths exist, pick one and move forward unless doing so would be unsafe or clearly unsupported.",
     "- When information is incomplete, choose a conservative next action based on the objective, target memory, latest user input, and terminal snapshot.",
+    "- Do not treat the agent's claims, summaries, or self-reports as sufficient evidence of completion.",
     "- Stop only when the objective is complete, or when continuing would likely push the agent in an unsafe or clearly unsupported direction.",
     "",
     "Stage decision policy:",
     "- Use the target memory as the current supervision state.",
-    "- Base your decision on the objective, current plan, activeStepId, progressSummary, lastGuidance, stalledCount, latest user input, and terminal snapshot.",
-    "- Identify which plan step is currently active.",
-    "- Decide whether the active step is done, still in progress, blocked, or obsolete.",
-    "- If the active step is done, advance to the next useful step.",
-    "- If the active step is still in progress, give guidance that moves it forward.",
+    "- Base your decision on the objective, current decompositionMode, items, activeItemId, progressSummary, lastGuidance, stalledCount, latest user input, and terminal snapshot.",
+    "- Identify which decomposition item is currently active.",
+    "- Keep the current active item unless there is evidence that it is done, blocked, or obsolete.",
+    "- Decide whether the active item is done, still in progress, blocked, or obsolete based on observable evidence.",
+    '- Treat statements like "done", "fixed", "implemented", or "should pass" as unverified unless supported by observable evidence.',
+    '- Mark an item as "done" only when there is observable evidence that its deliverable or acceptanceCriteria were satisfied.',
+    "- Prefer evidence from terminal output, test results, build results, explicit verification output, or other observable artifacts in the terminal snapshot.",
+    "- If evidence is missing or ambiguous, keep the item in_progress and direct the agent to gather or produce the missing verification evidence.",
+    "- If the current item appears nearly complete but is not yet verified, keep the same active item and direct targeted verification.",
+    "- Advance to the next item only after the current item's deliverable or acceptanceCriteria are supported by observable evidence.",
+    '- When advancing to the next item, mark the previous item as "done" and set activeItemId to the next item explicitly.',
+    "- If the active item is blocked, give guidance that is most likely to unblock it.",
+    "- If the active item is obsolete, explain the reason briefly and move to the next useful item.",
     "- If the agent appears stuck or repeated the same action, give a different concrete next action.",
-    "- If the plan is obsolete, update only the affected steps unless a full replacement is necessary.",
+    "- Do not rewrite the decomposition structure during normal evaluation cycles.",
     "",
     "Allowed statuses:",
-    '- "continue": more work is needed; include "reason" and "guidance".',
+    '- "continue": supervision should continue; include "reason" and "guidance".',
     '- "stop": supervision should stop; include "stopReason" and "reason".',
     "",
     "Allowed stop reasons:",
     '- "objective_complete"',
     '- "supervisor_uncertain"',
     "",
-    'Use "objective_complete" only when the objective has been satisfied.',
+    'Use "objective_complete" only when there is evidence that the objective and relevant acceptanceCriteria have been satisfied.',
+    "- Do not stop only because the agent says the work is complete or because code changes exist without verification evidence.",
+    "- If completion looks plausible but remains unverified, continue and require targeted verification.",
     'Use "supervisor_uncertain" only as a last resort when no useful next action can be inferred and additional guidance would likely be misleading.',
     "",
     'Guidance requirements for "continue":',
@@ -5294,30 +5399,32 @@ function buildPrompt(context) {
     "- Focus on the highest-value step toward completing the objective.",
     "- Be specific enough for the supervised agent to act without asking the user.",
     "- Avoid generic reminders, encouragement, or restating the objective.",
-    "- If verification is needed, tell the agent exactly what to verify next.",
+    "- If verification is needed, tell the agent exactly what command, file, behavior, or artifact to verify next.",
     "- If implementation is needed, point to the likely area, behavior, or file/module based on available evidence.",
+    "- If the agent asked a question, answer it directly in the guidance and continue with a concrete next action.",
     "",
-    "Planning policy:",
-    "- If planGenerated is false, include a plan with 3 to 7 milestone-sized steps.",
-    "- If planGenerated is true, update progress incrementally.",
-    "- Do not rewrite the full plan unless the existing plan is clearly wrong or obsolete.",
-    "- Use stepUpdates to mark completed or active steps when the terminal snapshot shows progress.",
-    "- Keep activeStepId aligned with the next useful step.",
+    "Evaluation policy:",
+    "- Update progress incrementally against the existing decomposition.",
+    "- Use itemUpdates to reflect evidence-backed status changes only.",
+    "- Keep activeItemId on the current item by default.",
+    "- Change activeItemId only when there is a clear reason to switch items.",
+    "- If evidence is missing or ambiguous, prefer verification over further implementation.",
     "",
     "Output schema:",
     "For continue:",
     "{",
+    '  "mode": "evaluate",',
     '  "status": "continue",',
     '  "reason": "brief explanation of why more work is needed",',
     '  "guidance": "specific next action for the supervised agent",',
-    '  "plan": optional array of plan steps,',
-    '  "activeStepId": optional step id,',
+    '  "activeItemId": optional item id,',
     '  "progressSummary": optional brief progress summary,',
-    '  "stepUpdates": optional array of { "id": string, "status": "pending" | "in_progress" | "done" }',
+    '  "itemUpdates": optional array of { "id": string, "status": "pending" | "in_progress" | "done" }',
     "}",
     "",
     "For stop:",
     "{",
+    '  "mode": "evaluate",',
     '  "status": "stop",',
     '  "stopReason": "objective_complete" | "supervisor_uncertain",',
     '  "reason": "brief explanation"',
@@ -5341,7 +5448,7 @@ async function runCommand(command, timeoutMs, options = {}) {
   if (options.signal?.aborted) {
     throw createSupervisorEvalAbortedError();
   }
-  return await new Promise((resolve4, reject) => {
+  return await new Promise((resolve5, reject) => {
     const child = spawn2(command.argv[0], command.argv.slice(1), {
       cwd: command.cwd,
       detached: process.platform !== "win32",
@@ -5371,7 +5478,7 @@ async function runCommand(command, timeoutMs, options = {}) {
       }
       settled = true;
       cleanup();
-      resolve4(value);
+      resolve5(value);
     };
     const terminate = (error) => {
       if (terminationError) {
@@ -5402,7 +5509,10 @@ async function runCommand(command, timeoutMs, options = {}) {
         settleReject(terminationError);
         return;
       }
-      settleReject(error);
+      settleReject({
+        code: "supervisor_eval_failed",
+        message: error instanceof Error ? error.message : "Evaluator process failed to start"
+      });
     });
     child.on("exit", (code) => {
       if (terminationError) {
@@ -5580,7 +5690,7 @@ function extractSupervisorPayload(output2, providerId) {
   }
   throw new Error("Supervisor did not return a recognizable message");
 }
-function parseSupervisorEvaluationResult(payloadText, guidanceMaxChars) {
+function parseSupervisorEvaluationResult(payloadText, guidanceMaxChars, requestedMode) {
   let parsed;
   try {
     parsed = JSON.parse(stripCodeFence(payloadText));
@@ -5593,9 +5703,49 @@ function parseSupervisorEvaluationResult(payloadText, guidanceMaxChars) {
     throw new Error("Supervisor returned invalid evaluation payload");
   }
   const record = parsed;
+  const payloadMode = record.mode;
+  if (requestedMode === "decompose") {
+    if (payloadMode !== "decompose") {
+      throw new Error("Supervisor returned invalid decompose payload");
+    }
+    const decompositionMode = record.decompositionMode;
+    if (decompositionMode !== "stage" && decompositionMode !== "subtarget") {
+      throw new Error("Supervisor decompose result is missing a valid decompositionMode");
+    }
+    const items = Array.isArray(record.items) ? record.items.flatMap((value) => {
+      if (!value || typeof value !== "object") {
+        return [];
+      }
+      const item = value;
+      if (typeof item.id !== "string" || item.kind !== "stage" && item.kind !== "subtarget" || item.kind !== decompositionMode || typeof item.title !== "string" || typeof item.objective !== "string" || typeof item.deliverable !== "string" || !Array.isArray(item.acceptanceCriteria) || item.acceptanceCriteria.length === 0 || item.acceptanceCriteria.some((entry) => typeof entry !== "string") || item.status !== "pending" && item.status !== "in_progress" && item.status !== "done") {
+        return [];
+      }
+      return [
+        {
+          id: item.id,
+          kind: item.kind,
+          title: item.title,
+          objective: item.objective,
+          deliverable: item.deliverable,
+          acceptanceCriteria: item.acceptanceCriteria,
+          status: item.status
+        }
+      ];
+    }) : [];
+    if (items.length === 0) {
+      throw new Error("Supervisor decompose result must include at least one valid item");
+    }
+    return {
+      mode: "decompose",
+      decompositionMode,
+      items,
+      activeItemId: typeof record.activeItemId === "string" && record.activeItemId.trim() ? record.activeItemId : void 0,
+      progressSummary: typeof record.progressSummary === "string" && record.progressSummary.trim() ? record.progressSummary.trim() : void 0
+    };
+  }
   const status = record.status;
   const reason = record.reason;
-  if (status !== "continue" && status !== "stop" || typeof reason !== "string" || !reason.trim()) {
+  if (payloadMode !== void 0 && payloadMode !== "evaluate" || status !== "continue" && status !== "stop" || typeof reason !== "string" || !reason.trim()) {
     throw new Error("Supervisor returned invalid evaluation payload");
   }
   if (status === "stop") {
@@ -5604,23 +5754,14 @@ function parseSupervisorEvaluationResult(payloadText, guidanceMaxChars) {
       throw new Error("Supervisor stop result is missing a valid stopReason");
     }
     return {
+      mode: "evaluate",
       status,
       stopReason,
       reason: reason.trim()
     };
   }
   const guidance = typeof record.guidance === "string" && record.guidance.trim() ? record.guidance.trim().slice(0, guidanceMaxChars) : void 0;
-  const plan = Array.isArray(record.plan) ? record.plan.flatMap((value) => {
-    if (!value || typeof value !== "object") {
-      return [];
-    }
-    const step = value;
-    if (typeof step.id !== "string" || typeof step.title !== "string" || step.status !== "pending" && step.status !== "in_progress" && step.status !== "done") {
-      return [];
-    }
-    return [{ id: step.id, title: step.title, status: step.status }];
-  }) : void 0;
-  const stepUpdates = Array.isArray(record.stepUpdates) ? record.stepUpdates.flatMap((value) => {
+  const itemUpdates = Array.isArray(record.itemUpdates) ? record.itemUpdates.flatMap((value) => {
     if (!value || typeof value !== "object") {
       return [];
     }
@@ -5631,13 +5772,13 @@ function parseSupervisorEvaluationResult(payloadText, guidanceMaxChars) {
     return [{ id: update.id, status: update.status }];
   }) : void 0;
   return {
+    mode: "evaluate",
     status,
     reason: reason.trim(),
     guidance,
-    plan,
-    activeStepId: typeof record.activeStepId === "string" && record.activeStepId.trim() ? record.activeStepId : void 0,
+    activeItemId: typeof record.activeItemId === "string" && record.activeItemId.trim() ? record.activeItemId : void 0,
     progressSummary: typeof record.progressSummary === "string" && record.progressSummary.trim() ? record.progressSummary.trim() : void 0,
-    stepUpdates
+    itemUpdates
   };
 }
 var NOOP_LOGGER2, SupervisorEvaluator;
@@ -5689,7 +5830,8 @@ var init_evaluator = __esm({
           provider,
           this.deps.providerConfigRepo.get(provider.id)
         );
-        const prompt = buildPrompt(context);
+        const mode = options.mode ?? "evaluate";
+        const prompt = buildPrompt(context, mode);
         const command = provider.buildSupervisorEvalCommand(config, {
           prompt,
           sessionId: supervisor.sessionId,
@@ -5723,7 +5865,7 @@ var init_evaluator = __esm({
           );
           throw error;
         }
-        return parseSupervisorEvaluationResult(payloadText, this.config.guidanceMaxChars);
+        return parseSupervisorEvaluationResult(payloadText, this.config.guidanceMaxChars, mode);
       }
     };
   }
@@ -5894,12 +6036,12 @@ var init_scheduler = __esm({
 
 // packages/server/src/supervisor/manager.ts
 function createDeferredCompletion() {
-  let resolve4 = () => {
+  let resolve5 = () => {
   };
   const promise = new Promise((innerResolve) => {
-    resolve4 = innerResolve;
+    resolve5 = innerResolve;
   });
-  return { promise, resolve: resolve4 };
+  return { promise, resolve: resolve5 };
 }
 function generateSupervisorId() {
   return `sup_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
@@ -5925,6 +6067,12 @@ function messageOf(error, fallback) {
 function logFailure(logger, error, context, message) {
   logger.error({ ...context, err: error }, message);
 }
+function isDecomposeResult(result) {
+  return result.mode === "decompose";
+}
+function isEvaluateStopResult(result) {
+  return "status" in result && result.status === "stop";
+}
 function isSupervisorEvalAborted(error) {
   return !!error && typeof error === "object" && error.code === "supervisor_eval_aborted";
 }
@@ -6428,7 +6576,12 @@ var init_manager2 = __esm({
             turnId: context.lastTurnId,
             createdAt: Date.now()
           });
-          this.broadcastCycle(evaluatingSupervisor, activeCycle, "created");
+          this.broadcastCycle(evaluatingSupervisor, activeCycle, "created", {
+            phase: "waiting_evaluator",
+            currentAttemptIndex: 0,
+            attemptCount: 1,
+            maxAttempts: 1 + retrySettings.retryMaxCount
+          });
           return {
             cycle: activeCycle,
             supervisor: hydratedSupervisor,
@@ -6626,6 +6779,8 @@ var init_manager2 = __esm({
       }
       async executeCycleWithRetry(started, signal) {
         const supervisor = started.supervisor;
+        let context = started.context;
+        let currentMemory = context.targetMemory;
         for (let attemptIndex = 0; ; attemptIndex += 1) {
           const attempt = this.deps.cycleAttemptRepo.create({
             id: generateAttemptId(),
@@ -6634,23 +6789,79 @@ var init_manager2 = __esm({
             status: "evaluating",
             startedAt: Date.now()
           });
+          this.broadcastCycle(started.supervisor, started.cycle, "updated", {
+            phase: "waiting_evaluator",
+            currentAttemptIndex: attemptIndex,
+            attemptCount: attemptIndex + 1,
+            maxAttempts: 1 + started.retry.retryMaxCount
+          });
           try {
-            const evaluation = await this.evaluator.evaluate(supervisor, started.context, { signal });
+            if (!currentMemory.decompositionGenerated || currentMemory.items.length === 0) {
+              const decomposition = await this.evaluator.evaluate(supervisor, context, {
+                signal,
+                mode: "decompose"
+              });
+              if (!isDecomposeResult(decomposition)) {
+                throw new Error("Supervisor decompose pass did not return a decomposition result");
+              }
+              currentMemory = {
+                ...currentMemory,
+                decompositionGenerated: true,
+                decompositionMode: decomposition.decompositionMode,
+                items: decomposition.items,
+                activeItemId: decomposition.activeItemId,
+                progressSummary: decomposition.progressSummary ?? currentMemory.progressSummary,
+                updatedAt: Date.now()
+              };
+              const workspace = this.requireWorkspace(context.workspaceId);
+              await this.deps.targetStore.saveTargetMemory(
+                workspace.path,
+                started.targetId,
+                currentMemory
+              );
+              const currentSupervisor2 = this.supervisors.get(supervisor.id) ?? this.requireSupervisor(supervisor.id);
+              if (currentSupervisor2.targetId === started.targetId) {
+                const refreshed = this.attachCycles({
+                  ...currentSupervisor2,
+                  currentTargetMemory: currentMemory
+                });
+                this.storeSnapshot(refreshed);
+              }
+              context = {
+                ...context,
+                targetMemory: currentMemory
+              };
+            }
+            const evaluation = await this.evaluator.evaluate(supervisor, context, {
+              signal,
+              mode: "evaluate"
+            });
             this.deps.cycleAttemptRepo.update(attempt.id, {
               status: "completed",
               completedAt: Date.now(),
               providerModel: supervisor.evaluatorModel ?? null
             });
-            if (evaluation.status === "stop") {
+            if (isDecomposeResult(evaluation)) {
+              throw new Error("Supervisor evaluate pass returned a decompose result");
+            }
+            const nextTargetMemory = this.applyEvaluationToTargetMemory(
+              currentMemory,
+              evaluation,
+              void 0,
+              Date.now()
+            );
+            if (isEvaluateStopResult(evaluation)) {
               return {
                 evaluation,
-                injected: false
+                injected: false,
+                targetMemory: nextTargetMemory
               };
             }
             if (!evaluation.guidance?.trim()) {
               return {
                 evaluation,
-                injected: false
+                injected: false,
+                targetMemory: nextTargetMemory
               };
             }
             if (signal?.aborted || this.pendingPauses.has(supervisor.id)) {
@@ -6660,7 +6871,8 @@ var init_manager2 = __esm({
             if (currentSupervisor.targetId !== started.targetId) {
               return {
                 evaluation,
-                injected: false
+                injected: false,
+                targetMemory: nextTargetMemory
               };
             }
             const injectingSupervisor = this.attachCycles(
@@ -6673,6 +6885,12 @@ var init_manager2 = __esm({
             );
             this.storeSnapshot(injectingSupervisor);
             this.broadcastState(injectingSupervisor, "state_changed");
+            this.broadcastCycle(injectingSupervisor, started.cycle, "updated", {
+              phase: "injecting",
+              currentAttemptIndex: attemptIndex,
+              attemptCount: attemptIndex + 1,
+              maxAttempts: 1 + started.retry.retryMaxCount
+            });
             const recentCycles = this.deps.cycleRepo.listRecentForSupervisor(supervisor.id, this.config.guidanceDedupeWindow + 1).filter((cycle) => cycle.id !== started.cycle.id);
             const injection = await this.injector.inject(
               injectingSupervisor,
@@ -6685,7 +6903,13 @@ var init_manager2 = __esm({
             return {
               evaluation,
               injected: injection.injected,
-              injectedText: injection.injected ? injection.text : void 0
+              injectedText: injection.injected ? injection.text : void 0,
+              targetMemory: this.applyEvaluationToTargetMemory(
+                currentMemory,
+                evaluation,
+                injection.injected ? injection.text : void 0,
+                Date.now()
+              )
             };
           } catch (error) {
             if (isSupervisorEvalAborted(error)) {
@@ -6706,6 +6930,15 @@ var init_manager2 = __esm({
             if (!this.shouldRetryAttempt(error, attemptIndex, started.retry)) {
               throw error;
             }
+            const nextRetryAt = Date.now() + started.retry.retryDelayMs;
+            this.broadcastCycle(supervisor, started.cycle, "updated", {
+              phase: "retry_wait",
+              currentAttemptIndex: attemptIndex,
+              attemptCount: attemptIndex + 1,
+              maxAttempts: 1 + started.retry.retryMaxCount,
+              lastAttemptError: reason,
+              nextRetryAt
+            });
             await this.sleep(started.retry.retryDelayMs, signal);
             const evaluatingSupervisor = this.attachCycles(
               this.withCurrentTargetState(
@@ -6723,9 +6956,9 @@ var init_manager2 = __esm({
       async finalizeSuccessfulCycle(activeCycle, context, result, targetId) {
         const workspace = this.requireWorkspace(context.workspaceId);
         const currentSupervisor = this.supervisors.get(activeCycle.supervisorId) ?? this.requireSupervisor(activeCycle.supervisorId);
-        const targetMemory = targetId === currentSupervisor.targetId && currentSupervisor.currentTargetMemory ? currentSupervisor.currentTargetMemory : await this.deps.targetStore.loadTargetMemory(workspace.path, targetId);
+        const evaluation = result.evaluation;
         const finalStatus = result.injected ? "injected" : "completed";
-        const cycleReason = result.evaluation.status === "stop" ? result.evaluation.reason : result.injected ? result.injectedText : result.evaluation.guidance ? `Skipped duplicate: ${result.evaluation.guidance}` : void 0;
+        const cycleReason = isEvaluateStopResult(evaluation) ? evaluation.reason : result.injected ? result.injectedText : evaluation.guidance ? `Skipped duplicate: ${evaluation.guidance}` : void 0;
         const finishedCycle = this.deps.cycleRepo.update(activeCycle.id, {
           status: finalStatus,
           result: cycleReason ?? null,
@@ -6733,24 +6966,22 @@ var init_manager2 = __esm({
           errorReason: null,
           completedAt: Date.now()
         });
-        const nextTargetMemory = this.applyEvaluationToTargetMemory(
-          targetMemory,
-          result.evaluation,
-          result.injectedText,
-          finishedCycle.completedAt ?? Date.now()
-        );
+        const nextTargetMemory = {
+          ...result.targetMemory,
+          updatedAt: finishedCycle.completedAt ?? Date.now()
+        };
         await this.deps.targetStore.saveTargetMemory(workspace.path, targetId, nextTargetMemory);
-        const cycleRecord = result.evaluation.status === "stop" ? {
+        const cycleRecord = isEvaluateStopResult(evaluation) ? {
           cycleId: activeCycle.id,
           targetId,
           startedAt: activeCycle.createdAt,
           completedAt: finishedCycle.completedAt ?? Date.now(),
           result: "stop",
-          stopReason: result.evaluation.stopReason,
-          reason: result.evaluation.reason,
-          progressSummary: result.evaluation.progressSummary ?? nextTargetMemory.progressSummary,
-          activeStepId: result.evaluation.activeStepId ?? nextTargetMemory.activeStepId,
-          stepUpdates: result.evaluation.stepUpdates,
+          stopReason: evaluation.stopReason,
+          reason: evaluation.reason,
+          progressSummary: nextTargetMemory.progressSummary,
+          decompositionMode: nextTargetMemory.decompositionMode,
+          activeItemId: nextTargetMemory.activeItemId,
           injected: false,
           attemptCount: this.deps.cycleAttemptRepo.listForCycle(activeCycle.id).length
         } : {
@@ -6759,18 +6990,19 @@ var init_manager2 = __esm({
           startedAt: activeCycle.createdAt,
           completedAt: finishedCycle.completedAt ?? Date.now(),
           result: "continue",
-          reason: result.evaluation.reason,
-          guidance: result.injected ? result.injectedText : result.evaluation.guidance,
+          reason: evaluation.reason,
+          guidance: result.injected ? result.injectedText : evaluation.guidance,
           progressSummary: nextTargetMemory.progressSummary,
-          activeStepId: nextTargetMemory.activeStepId,
-          stepUpdates: result.evaluation.stepUpdates,
+          decompositionMode: nextTargetMemory.decompositionMode,
+          activeItemId: nextTargetMemory.activeItemId,
+          itemUpdates: evaluation.itemUpdates,
           injected: result.injected,
           attemptCount: this.deps.cycleAttemptRepo.listForCycle(activeCycle.id).length
         };
         await this.deps.targetStore.appendTargetCycleRecord(workspace.path, targetId, cycleRecord);
-        if (result.evaluation.status === "stop") {
+        if (isEvaluateStopResult(evaluation)) {
           await this.updateTargetMetaStatus(workspace.path, targetId, {
-            status: result.evaluation.stopReason === "objective_complete" ? "completed" : "cancelled",
+            status: evaluation.stopReason === "objective_complete" ? "completed" : "cancelled",
             completedAt: finishedCycle.completedAt ?? Date.now()
           });
         }
@@ -6787,9 +7019,9 @@ var init_manager2 = __esm({
         const finishedSupervisor = this.attachCycles(
           this.withCurrentTargetState(
             this.deps.supervisorRepo.update(activeCycle.supervisorId, {
-              state: result.evaluation.status === "stop" ? "stopped" : "idle",
+              state: isEvaluateStopResult(result.evaluation) ? "stopped" : "idle",
               completedSupervisionCount: (this.supervisors.get(activeCycle.supervisorId)?.completedSupervisionCount ?? 0) + 1,
-              stopReason: result.evaluation.status === "stop" ? result.evaluation.stopReason : null,
+              stopReason: isEvaluateStopResult(evaluation) ? evaluation.stopReason : null,
               lastCycleAt: finishedCycle.completedAt,
               lastEvaluatedTurnId: context.lastTurnId ?? void 0,
               errorReason: null,
@@ -6943,23 +7175,46 @@ var init_manager2 = __esm({
         };
       }
       applyEvaluationToTargetMemory(memory, evaluation, injectedText, updatedAt) {
-        let plan = memory.plan;
-        if (evaluation.plan && evaluation.plan.length > 0) {
-          plan = evaluation.plan;
-        } else if (evaluation.stepUpdates?.length) {
-          const updates = new Map(evaluation.stepUpdates.map((step) => [step.id, step.status]));
-          plan = memory.plan.map(
-            (step) => updates.has(step.id) ? { ...step, status: updates.get(step.id) } : step
+        if (isDecomposeResult(evaluation)) {
+          return {
+            ...memory,
+            decompositionGenerated: true,
+            decompositionMode: evaluation.decompositionMode,
+            items: evaluation.items,
+            activeItemId: evaluation.activeItemId,
+            progressSummary: evaluation.progressSummary ?? memory.progressSummary,
+            updatedAt
+          };
+        }
+        if (isEvaluateStopResult(evaluation)) {
+          return {
+            ...memory,
+            decompositionGenerated: memory.decompositionGenerated,
+            decompositionMode: memory.decompositionMode,
+            items: memory.items,
+            activeItemId: memory.activeItemId,
+            progressSummary: memory.progressSummary,
+            lastGuidance: memory.lastGuidance,
+            stalledCount: 0,
+            updatedAt
+          };
+        }
+        let items = memory.items;
+        if (evaluation.itemUpdates?.length) {
+          const updates = new Map(evaluation.itemUpdates.map((item) => [item.id, item.status]));
+          items = memory.items.map(
+            (item) => updates.has(item.id) ? { ...item, status: updates.get(item.id) } : item
           );
         }
         const progressSummary = evaluation.progressSummary ?? memory.progressSummary;
-        const lastGuidance = evaluation.status === "continue" ? injectedText ?? evaluation.guidance ?? memory.lastGuidance : memory.lastGuidance;
-        const stalledCount = evaluation.status === "continue" && !evaluation.progressSummary && !evaluation.stepUpdates?.length ? memory.stalledCount + 1 : 0;
+        const lastGuidance = injectedText ?? evaluation.guidance ?? memory.lastGuidance;
+        const stalledCount = !evaluation.progressSummary && !evaluation.itemUpdates?.length ? memory.stalledCount + 1 : 0;
         return {
           ...memory,
-          planGenerated: memory.planGenerated || Boolean(evaluation.plan?.length),
-          plan,
-          activeStepId: evaluation.activeStepId ?? memory.activeStepId,
+          decompositionGenerated: memory.decompositionGenerated,
+          decompositionMode: memory.decompositionMode,
+          items,
+          activeItemId: evaluation.activeItemId ?? memory.activeItemId,
           progressSummary,
           lastGuidance,
           stalledCount,
@@ -7082,10 +7337,10 @@ var init_manager2 = __esm({
           { supervisor, event }
         );
       }
-      broadcastCycle(supervisor, cycle, event) {
+      broadcastCycle(supervisor, cycle, event, runtime) {
         this.deps.broadcaster.broadcast(
           Topics.supervisorCycle(supervisor.workspaceId, supervisor.sessionId),
-          { cycle, event }
+          { cycle: runtime ? { ...cycle, runtime } : cycle, event }
         );
       }
       shouldRetryAttempt(error, attemptIndex, retry) {
@@ -7111,10 +7366,10 @@ var init_manager2 = __esm({
         if (signal?.aborted) {
           throw { code: "supervisor_eval_aborted", message: "Supervisor evaluator aborted" };
         }
-        await new Promise((resolve4, reject) => {
+        await new Promise((resolve5, reject) => {
           const timer = setTimeout(() => {
             signal?.removeEventListener("abort", onAbort);
-            resolve4();
+            resolve5();
           }, delayMs);
           timer.unref?.();
           const onAbort = () => {
@@ -7182,6 +7437,119 @@ function errorMessage(error, fallback) {
   }
   return fallback;
 }
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const next = value.trim();
+  return next ? next : void 0;
+}
+function readStatus(value) {
+  return value === "in_progress" || value === "done" || value === "pending" ? value : "pending";
+}
+function readDecompositionMode(value) {
+  return value === "stage" || value === "subtarget" ? value : void 0;
+}
+function readNonNegativeInteger(value, fallback) {
+  if (!Number.isSafeInteger(value) || typeof value !== "number" || value < 0) {
+    return fallback;
+  }
+  return value;
+}
+function readTimestamp(value, fallback) {
+  if (!Number.isSafeInteger(value) || typeof value !== "number") {
+    return fallback;
+  }
+  return value;
+}
+function fallbackAcceptanceCriteria(title) {
+  return [`${title} is complete`];
+}
+function normalizeItem(value, fallbackKind) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readNonEmptyString(value.id);
+  const title = readNonEmptyString(value.title);
+  if (!id || !title) {
+    return null;
+  }
+  const kind = readDecompositionMode(value.kind) ?? fallbackKind ?? "stage";
+  const objective = readNonEmptyString(value.objective) ?? title;
+  const deliverable = readNonEmptyString(value.deliverable) ?? `${title} completed`;
+  const acceptanceCriteria = Array.isArray(value.acceptanceCriteria) ? value.acceptanceCriteria.flatMap((entry) => {
+    const next = readNonEmptyString(entry);
+    return next ? [next] : [];
+  }) : [];
+  return {
+    id,
+    kind,
+    title,
+    objective,
+    deliverable,
+    acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : fallbackAcceptanceCriteria(title),
+    status: readStatus(value.status)
+  };
+}
+function normalizeLegacyPlanItems(plan) {
+  if (!Array.isArray(plan)) {
+    return [];
+  }
+  return plan.flatMap((value) => {
+    const item = normalizeItem(
+      isRecord(value) ? {
+        id: value.id,
+        kind: "stage",
+        title: value.title,
+        objective: value.title,
+        deliverable: `${readNonEmptyString(value.title) ?? "Legacy step"} completed`,
+        acceptanceCriteria: fallbackAcceptanceCriteria(
+          readNonEmptyString(value.title) ?? "Legacy step"
+        ),
+        status: value.status
+      } : value,
+      "stage"
+    );
+    return item ? [item] : [];
+  });
+}
+function resolveActiveItemId(items, candidate) {
+  const next = readNonEmptyString(candidate);
+  if (next && items.some((item) => item.id === next)) {
+    return next;
+  }
+  return items.find((item) => item.status === "in_progress")?.id ?? items.find((item) => item.status === "pending")?.id ?? items[0]?.id;
+}
+function normalizeTargetMemory(raw, targetId) {
+  if (!isRecord(raw)) {
+    return buildTargetMemory(targetId, 0);
+  }
+  const updatedAt = readTimestamp(raw.updatedAt, 0);
+  const declaredMode = readDecompositionMode(raw.decompositionMode);
+  let items = Array.isArray(raw.items) ? raw.items.flatMap((value) => {
+    const item = normalizeItem(value, declaredMode);
+    return item ? [item] : [];
+  }) : [];
+  let decompositionMode = declaredMode ?? items[0]?.kind;
+  if (items.length === 0) {
+    items = normalizeLegacyPlanItems(raw.plan);
+    decompositionMode = items.length > 0 ? "stage" : void 0;
+  }
+  return {
+    targetId: readNonEmptyString(raw.targetId) ?? targetId,
+    decompositionGenerated: items.length > 0,
+    decompositionMode,
+    items,
+    activeItemId: resolveActiveItemId(items, raw.activeItemId ?? raw.activeStepId),
+    progressSummary: readNonEmptyString(raw.progressSummary),
+    lastGuidance: readNonEmptyString(raw.lastGuidance),
+    stalledCount: readNonNegativeInteger(raw.stalledCount, 0),
+    updatedAt
+  };
+}
 async function writeJsonIfMissing(path10, value) {
   try {
     await writeFile3(path10, JSON.stringify(value, null, 2) + "\n", {
@@ -7210,8 +7578,12 @@ function buildTargetMeta(input2) {
 function buildTargetMemory(targetId, createdAt) {
   return {
     targetId,
-    planGenerated: false,
-    plan: [],
+    decompositionGenerated: false,
+    decompositionMode: void 0,
+    items: [],
+    activeItemId: void 0,
+    progressSummary: void 0,
+    lastGuidance: void 0,
     stalledCount: 0,
     updatedAt: createdAt
   };
@@ -7300,8 +7672,9 @@ async function readTargetMeta(workspacePath, targetId) {
   );
 }
 async function loadTargetMemory(workspacePath, targetId) {
-  return JSON.parse(
-    await readFile2(memoryPath(workspacePath, targetId), "utf-8")
+  return normalizeTargetMemory(
+    JSON.parse(await readFile2(memoryPath(workspacePath, targetId), "utf-8")),
+    targetId
   );
 }
 async function saveTargetMemory(workspacePath, targetId, memory) {
@@ -7638,8 +8011,8 @@ var init_terminal_snapshot_buffer = __esm({
         if (this.pendingWriteCount === 0) {
           return Promise.resolve();
         }
-        return new Promise((resolve4) => {
-          this.drainResolvers.push(resolve4);
+        return new Promise((resolve5) => {
+          this.drainResolvers.push(resolve5);
         });
       }
       resolveDrainIfIdle() {
@@ -7648,8 +8021,8 @@ var init_terminal_snapshot_buffer = __esm({
         }
         const resolvers = this.drainResolvers;
         this.drainResolvers = [];
-        for (const resolve4 of resolvers) {
-          resolve4();
+        for (const resolve5 of resolvers) {
+          resolve5();
         }
       }
       requireTerminal() {
@@ -7968,10 +8341,10 @@ var init_manager3 = __esm({
           }
           return existing.promise;
         }
-        let resolve4 = () => {
+        let resolve5 = () => {
         };
         const promise = new Promise((innerResolve) => {
-          resolve4 = innerResolve;
+          resolve5 = innerResolve;
         });
         let markKillCompleted = () => {
         };
@@ -7984,7 +8357,7 @@ var init_manager3 = __esm({
           markKillCompleted,
           finalized: false,
           promise,
-          resolve: resolve4
+          resolve: resolve5
         });
         void terminal.pty.kill(signal).finally(() => {
           const waiter = this.explicitCloseWaiters.get(terminalId);
@@ -8257,11 +8630,11 @@ var init_watcher = __esm({
           this.pendingReason = "fs_change";
         }
         const elapsed = now - this.firstDirtyTime;
-        const delay = Math.min(this.DEBOUNCE_MS, Math.max(0, this.MAX_WAIT_MS - elapsed));
+        const delay2 = Math.min(this.DEBOUNCE_MS, Math.max(0, this.MAX_WAIT_MS - elapsed));
         if (this.dirtyTimer) {
           clearTimeout(this.dirtyTimer);
         }
-        this.dirtyTimer = setTimeout(() => this.flushDirty(), delay);
+        this.dirtyTimer = setTimeout(() => this.flushDirty(), delay2);
       }
       flushDirty() {
         this.broadcaster?.broadcast(Topics.workspaceFsDirty(this.workspaceId), {
@@ -8859,7 +9232,8 @@ var init_fencing = __esm({
 });
 
 // packages/server/src/commands/terminal.ts
-import { basename } from "node:path";
+import { stat as stat6 } from "node:fs/promises";
+import { basename, isAbsolute as isAbsolute3 } from "node:path";
 import { z as z5 } from "zod";
 function decodeTerminalInput(args) {
   if ("bytes" in args) {
@@ -8930,6 +9304,7 @@ var init_terminal = __esm({
   "packages/server/src/commands/terminal.ts"() {
     "use strict";
     init_src3();
+    init_file_io();
     init_dispatch();
     TerminalInputActivitySchema = z5.enum(TERMINAL_INPUT_ACTIVITIES).optional();
     TerminalInputSchema = z5.union([
@@ -8964,20 +9339,44 @@ var init_terminal = __esm({
       z5.object({
         workspaceId: z5.string(),
         cols: z5.number().int().positive().optional(),
-        rows: z5.number().int().positive().optional()
+        rows: z5.number().int().positive().optional(),
+        cwdPath: z5.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
+        let cwd = workspace.path;
+        if (args.cwdPath && args.cwdPath !== ".") {
+          if (isAbsolute3(args.cwdPath)) {
+            throw { code: "invalid_cwd_path", message: "cwdPath must be workspace-relative" };
+          }
+          let resolvedCwd;
+          try {
+            resolvedCwd = resolveSafe(workspace.path, args.cwdPath);
+          } catch (error) {
+            if (typeof error === "object" && error !== null && "code" in error && error.code === "path_escape") {
+              throw { code: "invalid_cwd_path", message: "cwdPath must be workspace-relative" };
+            }
+            throw error;
+          }
+          const cwdStats = await stat6(resolvedCwd).catch(() => null);
+          if (!cwdStats) {
+            throw { code: "cwd_not_found", message: `Directory not found: ${args.cwdPath}` };
+          }
+          if (!cwdStats.isDirectory()) {
+            throw { code: "cwd_not_directory", message: `Not a directory: ${args.cwdPath}` };
+          }
+          cwd = resolvedCwd;
+        }
         const shell = resolveShellCommand();
         const terminal = ctx.terminalMgr.create({
           workspaceId: args.workspaceId,
           kind: "shell",
           argv: shell.argv,
           title: shell.title,
-          cwd: workspace.path,
+          cwd,
           cols: args.cols ?? 120,
           rows: args.rows ?? 30
         });
@@ -9663,7 +10062,7 @@ var init_hub = __esm({
         }
       }
       awaitBinaryPayload(clientId) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           const timer = setTimeout(() => {
             const waiters = this.pendingBinaryWaiters.get(clientId);
             if (!waiters) return;
@@ -9675,7 +10074,7 @@ var init_hub = __esm({
             }
             reject(new Error("Timeout waiting for terminal input binary payload"));
           }, BINARY_PAYLOAD_TIMEOUT_MS);
-          const waiter = { resolve: resolve4, reject, timer };
+          const waiter = { resolve: resolve5, reject, timer };
           const queue = this.pendingBinaryWaiters.get(clientId);
           if (queue) {
             queue.push(waiter);
@@ -9953,10 +10352,34 @@ var init_hub = __esm({
 });
 
 // packages/server/src/commands/workspace.ts
-import { readdir as readdir2 } from "node:fs/promises";
+import { readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join6, resolve as resolve3 } from "node:path";
 import { z as z6 } from "zod";
+function resolveBrowsePath(path10) {
+  const home = homedir2();
+  if (!path10 || path10 === "~") {
+    return home;
+  }
+  if (path10.startsWith("~/")) {
+    return join6(home, path10.slice(2));
+  }
+  return isAbsolute4(path10) ? path10 : resolve3(home, path10);
+}
+async function buildRootPaths(currentPath) {
+  const roots = /* @__PURE__ */ new Set(["/"]);
+  const home = homedir2();
+  roots.add(home);
+  try {
+    roots.add(await realpath2(home));
+  } catch {
+  }
+  const currentSegments = currentPath.split("/").filter(Boolean);
+  if (currentSegments.length > 0) {
+    roots.add(`/${currentSegments[0]}`);
+  }
+  return Array.from(roots);
+}
 var init_workspace = __esm({
   "packages/server/src/commands/workspace.ts"() {
     "use strict";
@@ -9970,7 +10393,7 @@ var init_workspace = __esm({
         path: z6.string().optional()
       }),
       async (args) => {
-        const basePath = args.path || homedir2();
+        const basePath = resolveBrowsePath(args.path);
         const entries = await readdir2(basePath, { withFileTypes: true });
         const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
           name: entry.name,
@@ -9979,7 +10402,8 @@ var init_workspace = __esm({
         return {
           currentPath: basePath,
           parentPath: basePath !== "/" ? join6(basePath, "..") : null,
-          directories
+          directories,
+          rootPaths: await buildRootPaths(basePath)
         };
       }
     );
@@ -10276,16 +10700,105 @@ var init_runtime_status = __esm({
   }
 });
 
+// packages/server/src/workspace/pane-layout.ts
+function applyPaneDisposition(layout, sessionId, disposition) {
+  if (!layout) {
+    return layout;
+  }
+  return disposition === "remove" ? removePaneBySessionId(layout, sessionId) : closePaneBySessionId(layout, sessionId);
+}
+function closePaneBySessionId(node, sessionId) {
+  return replaceSessionWithDraft(node, sessionId);
+}
+function replaceSessionWithDraft(node, sessionId) {
+  if (node.type === "leaf") {
+    if (node.sessionId === sessionId) {
+      return {
+        id: node.id,
+        type: "leaf"
+      };
+    }
+    return node;
+  }
+  const children = node.children ?? [];
+  let changed = false;
+  const nextChildren = children.map((child) => {
+    const nextChild = replaceSessionWithDraft(child, sessionId);
+    if (nextChild !== child) {
+      changed = true;
+    }
+    return nextChild;
+  });
+  if (!changed) {
+    return node;
+  }
+  return {
+    ...node,
+    children: nextChildren
+  };
+}
+function removePaneBySessionId(node, sessionId) {
+  return removeSessionPane(node, sessionId) ?? { id: node.id, type: "leaf" };
+}
+function removeSessionPane(node, sessionId) {
+  if (node.type === "leaf") {
+    if (node.sessionId === sessionId) {
+      return null;
+    }
+    return node;
+  }
+  const children = node.children ?? [];
+  let changed = false;
+  const nextChildren = [];
+  for (const child of children) {
+    const nextChild = removeSessionPane(child, sessionId);
+    if (nextChild !== child) {
+      changed = true;
+    }
+    if (nextChild !== null) {
+      nextChildren.push(nextChild);
+    }
+  }
+  if (!changed) {
+    return node;
+  }
+  if (nextChildren.length === 1) {
+    return nextChildren[0];
+  }
+  if (nextChildren.length === 0) {
+    return null;
+  }
+  return {
+    ...node,
+    children: nextChildren
+  };
+}
+var init_pane_layout = __esm({
+  "packages/server/src/workspace/pane-layout.ts"() {
+    "use strict";
+  }
+});
+
 // packages/server/src/commands/session.ts
 import { z as z10 } from "zod";
+function delay(ms) {
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, ms);
+  });
+}
 function getProviderFromRegistry(providerId, registry) {
   return registry.find((provider) => provider.id === providerId);
 }
+var SESSION_CLOSE_POLL_INTERVAL_MS, SESSION_CLOSE_TIMEOUT_MS;
 var init_session = __esm({
   "packages/server/src/commands/session.ts"() {
     "use strict";
     init_runtime_status();
+    init_database();
+    init_pane_layout();
     init_dispatch();
+    SESSION_CLOSE_POLL_INTERVAL_MS = 100;
+    SESSION_CLOSE_TIMEOUT_MS = 5e3;
     registerCommand(
       "session.list",
       z10.object({
@@ -10357,11 +10870,75 @@ var init_session = __esm({
         ctx.sessionMgr.delete(args.sessionId);
       }
     );
+    registerCommand(
+      "session.close",
+      z10.object({
+        sessionId: z10.string(),
+        paneDisposition: z10.enum(["draft", "remove"]).default("draft")
+      }),
+      async (args, ctx) => {
+        let session = ctx.sessionMgr.get(args.sessionId);
+        if (!session) {
+          throw { code: "session_not_found", message: `Session not found: ${args.sessionId}` };
+        }
+        if (session.state !== "ended") {
+          try {
+            await ctx.sessionMgr.stop(args.sessionId);
+          } catch (error) {
+            const candidate = error;
+            throw {
+              code: "session_close_failed",
+              message: candidate.message ?? `Failed to stop session: ${args.sessionId}`
+            };
+          }
+          const deadline = Date.now() + SESSION_CLOSE_TIMEOUT_MS;
+          while (Date.now() < deadline) {
+            session = ctx.sessionMgr.get(args.sessionId);
+            if (!session) {
+              return;
+            }
+            if (session.state === "ended") {
+              break;
+            }
+            await delay(SESSION_CLOSE_POLL_INTERVAL_MS);
+          }
+          session = ctx.sessionMgr.get(args.sessionId);
+          if (!session) {
+            return;
+          }
+          if (session.state !== "ended") {
+            throw {
+              code: "session_close_timeout",
+              message: `Timed out waiting for session to end before closing: ${args.sessionId}`
+            };
+          }
+        }
+        const workspace = ctx.workspaceMgr.get(session.workspaceId);
+        if (!workspace) {
+          throw {
+            code: "workspace_not_found",
+            message: `Workspace not found: ${session.workspaceId}`
+          };
+        }
+        const nextUiState = {
+          ...workspace.uiState,
+          paneLayout: applyPaneDisposition(
+            workspace.uiState.paneLayout,
+            args.sessionId,
+            args.paneDisposition
+          )
+        };
+        withTransaction(ctx.db, () => {
+          ctx.workspaceMgr.updateUiState(session.workspaceId, nextUiState);
+          ctx.sessionMgr.delete(args.sessionId);
+        });
+      }
+    );
   }
 });
 
 // packages/server/src/fs/tree.ts
-import { readdir as readdir3, stat as stat6 } from "fs/promises";
+import { readdir as readdir3, stat as stat7 } from "fs/promises";
 import { join as join7, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
   const targetPath = subdir ? join7(rootPath, subdir) : rootPath;
@@ -10383,7 +10960,7 @@ async function readTree(rootPath, subdir) {
         // Not loaded yet - client will request on expand
       });
     } else if (entry.isFile()) {
-      const stats = await stat6(fullPath);
+      const stats = await stat7(fullPath);
       nodes.push({
         name: entry.name,
         path: relPath,
@@ -10452,7 +11029,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     }
     return a.path.toLowerCase().localeCompare(b.path.toLowerCase());
   }).slice(0, limit)) {
-    const stats = await stat6(match.fullPath);
+    const stats = await stat7(match.fullPath);
     files.push({
       name: match.name,
       path: match.path,
@@ -10619,6 +11196,27 @@ var init_file = __esm({
         return { ok: true };
       }
     );
+    registerCommand(
+      "file.rename",
+      z11.object({
+        workspaceId: z11.string(),
+        fromPath: z11.string(),
+        toPath: z11.string()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        await renameEntry(workspace.path, args.fromPath, args.toPath);
+        ctx.eventBus.emit({
+          type: "fs.dirty",
+          workspaceId: args.workspaceId,
+          reason: "fs_change"
+        });
+        return { ok: true };
+      }
+    );
     registerCommand(
       "file.write",
       z11.object({
@@ -10800,7 +11398,7 @@ import { mkdir as mkdir4, mkdtemp as mkdtemp2, rm as rm5, writeFile as writeFile
 import os2 from "os";
 import path6 from "path";
 async function runGit(cwd, args, options = {}) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const gitArgs = [
       ...options.config?.flatMap(([key, value]) => ["-c", `${key}=${value}`]) ?? [],
       ...args
@@ -10827,7 +11425,7 @@ async function runGit(cwd, args, options = {}) {
         if (err) {
           reject(new GitError(err.message, stderr));
         } else {
-          resolve4({ stdout, stderr });
+          resolve5({ stdout, stderr });
         }
       }
     );
@@ -12171,20 +12769,373 @@ var init_settings2 = __esm({
   }
 });
 
-// packages/server/src/commands/provider.ts
+// packages/server/src/commands/diagnostics.ts
 import { z as z14 } from "zod";
+function isLoopbackHost(host) {
+  return host === void 0 || host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0";
+}
+async function resolveWorkspacePathCheck(workspacePath) {
+  if (!workspacePath) {
+    return {
+      canContinue: false,
+      checks: [
+        {
+          id: "workspace-selection",
+          code: "workspace_selection_missing",
+          status: "needs_attention"
+        }
+      ]
+    };
+  }
+  const validation = await validatePath(workspacePath);
+  if (validation.valid) {
+    return {
+      canContinue: true,
+      checks: [
+        {
+          id: "workspace-path",
+          code: "workspace_path_ready",
+          status: "ready",
+          workspacePath
+        }
+      ]
+    };
+  }
+  return {
+    canContinue: false,
+    checks: [
+      {
+        id: "workspace-path",
+        code: validation.error === "Path does not exist" ? "workspace_path_not_found" : "workspace_path_unreadable",
+        status: "needs_attention",
+        workspacePath
+      }
+    ]
+  };
+}
+function buildProviderCheck(providerStatus, providerId) {
+  if (providerStatus.available) {
+    return {
+      canContinue: true,
+      checks: [
+        {
+          id: `provider:${providerId}`,
+          code: "provider_runtime_ready",
+          status: "ready",
+          providerId,
+          autoInstallSupported: providerStatus.autoInstallSupported,
+          installReadiness: providerStatus.installReadiness
+        }
+      ]
+    };
+  }
+  if (providerStatus.missingPrerequisites.length > 0) {
+    return {
+      canContinue: false,
+      checks: [
+        {
+          id: `provider:${providerId}`,
+          code: "provider_prerequisite_missing",
+          status: "needs_attention",
+          providerId,
+          autoInstallSupported: providerStatus.autoInstallSupported,
+          installReadiness: providerStatus.installReadiness,
+          missingCommands: providerStatus.missingCommands,
+          missingPrerequisites: providerStatus.missingPrerequisites,
+          manualGuideKeys: providerStatus.manualGuideKeys,
+          docUrl: providerStatus.docUrls.provider
+        }
+      ]
+    };
+  }
+  return {
+    canContinue: false,
+    checks: [
+      {
+        id: `provider:${providerId}`,
+        code: "provider_cli_missing",
+        status: "needs_attention",
+        providerId,
+        autoInstallSupported: providerStatus.autoInstallSupported,
+        installReadiness: providerStatus.installReadiness,
+        missingCommands: providerStatus.missingCommands,
+        missingPrerequisites: providerStatus.missingPrerequisites,
+        manualGuideKeys: providerStatus.manualGuideKeys,
+        docUrl: providerStatus.docUrls.provider
+      }
+    ]
+  };
+}
+async function buildWorkspaceSelectionChecks(args, ctx) {
+  if (args.workspacePath) {
+    const workspaceResult = await resolveWorkspacePathCheck(args.workspacePath);
+    return {
+      canContinue: workspaceResult.canContinue,
+      checks: workspaceResult.checks,
+      workspacePath: args.workspacePath
+    };
+  }
+  const workspace = args.workspaceId ? ctx.workspaceMgr.get(args.workspaceId) : void 0;
+  if (!args.workspaceId) {
+    return {
+      canContinue: true,
+      checks: []
+    };
+  }
+  if (!workspace) {
+    return {
+      canContinue: false,
+      checks: [
+        {
+          id: "session-workspace",
+          code: "session_workspace_missing",
+          status: "needs_attention",
+          workspaceId: args.workspaceId
+        }
+      ]
+    };
+  }
+  const pathCheck = await resolveWorkspacePathCheck(workspace.path);
+  return {
+    canContinue: pathCheck.canContinue,
+    checks: [
+      {
+        id: "session-workspace",
+        code: "session_workspace_ready",
+        status: "ready",
+        workspaceId: workspace.id,
+        workspacePath: workspace.path
+      },
+      ...pathCheck.checks.map(
+        (check) => check.id === "workspace-path" ? {
+          ...check,
+          id: `workspace-path:${workspace.id}`
+        } : check
+      )
+    ],
+    workspacePath: workspace.path
+  };
+}
+async function buildAllProviderChecks(ctx, preferredProviderId) {
+  const checks = [];
+  let canContinueForPreferredProvider = preferredProviderId ? false : true;
+  const runtimeStatus = await buildProviderRuntimeStatus(
+    ctx.providerRegistry,
+    ctx.providerRuntimeDeps
+  );
+  for (const provider of ctx.providerRegistry) {
+    const providerStatus = runtimeStatus.providers[provider.id];
+    if (!providerStatus) {
+      checks.push({
+        id: `provider:${provider.id}`,
+        code: "provider_unknown",
+        status: "needs_attention",
+        providerId: provider.id
+      });
+      if (provider.id === preferredProviderId) {
+        canContinueForPreferredProvider = false;
+      }
+      continue;
+    }
+    const providerCheck = buildProviderCheck(providerStatus, provider.id);
+    checks.push(...providerCheck.checks);
+    if (provider.id === preferredProviderId) {
+      canContinueForPreferredProvider = providerCheck.canContinue;
+    }
+  }
+  if (preferredProviderId && !ctx.providerRegistry.find((provider) => provider.id === preferredProviderId)) {
+    checks.unshift({
+      id: "session-provider",
+      code: "provider_unknown",
+      status: "needs_attention",
+      providerId: preferredProviderId
+    });
+    canContinueForPreferredProvider = false;
+  }
+  return { checks, canContinueForPreferredProvider };
+}
+function buildServerAuthCheck(ctx) {
+  return {
+    id: "server-auth",
+    code: ctx.config?.auth.enabled ? "server_auth_ready" : "server_auth_not_required",
+    status: "ready"
+  };
+}
+function buildMobileHostCheck(ctx) {
+  if (isLoopbackHost(ctx.config?.host)) {
+    return {
+      canContinue: false,
+      check: {
+        id: "mobile-host",
+        code: "mobile_host_local_only",
+        status: "needs_attention"
+      }
+    };
+  }
+  return {
+    canContinue: true,
+    check: {
+      id: "mobile-host",
+      code: "mobile_host_ready",
+      status: "ready"
+    }
+  };
+}
+async function buildSessionStartDiagnostics(args, ctx) {
+  const workspaceSelection = await buildWorkspaceSelectionChecks(args, ctx);
+  const providerChecks = await buildAllProviderChecks(ctx, args.providerId);
+  const mobileHost = buildMobileHostCheck(ctx);
+  const checks = [
+    ...workspaceSelection.checks,
+    ...providerChecks.checks,
+    buildServerAuthCheck(ctx),
+    mobileHost.check
+  ];
+  const canContinue = workspaceSelection.canContinue && providerChecks.canContinueForPreferredProvider;
+  return {
+    context: "session_start",
+    canContinue,
+    checks,
+    metadata: {
+      providerId: args.providerId,
+      workspaceId: args.workspaceId,
+      workspacePath: workspaceSelection.workspacePath,
+      authEnabled: ctx.config?.auth.enabled ?? false,
+      host: ctx.config?.host
+    }
+  };
+}
+async function buildManualDiagnostics(args, ctx) {
+  const workspaceSelection = await buildWorkspaceSelectionChecks(args, ctx);
+  const providerChecks = await buildAllProviderChecks(ctx, args.providerId);
+  const mobileHost = buildMobileHostCheck(ctx);
+  const checks = [
+    ...workspaceSelection.checks,
+    ...providerChecks.checks,
+    buildServerAuthCheck(ctx),
+    mobileHost.check
+  ];
+  return {
+    context: "manual_check",
+    canContinue: checks.every((check) => check.status !== "needs_attention"),
+    checks,
+    metadata: {
+      authEnabled: ctx.config?.auth.enabled ?? false,
+      host: ctx.config?.host,
+      providerId: args.providerId,
+      workspaceId: args.workspaceId,
+      workspacePath: workspaceSelection.workspacePath ?? args.workspacePath
+    }
+  };
+}
+async function buildMobileDiagnostics(args, ctx) {
+  const host = ctx.config?.host;
+  const authEnabled = ctx.config?.auth.enabled ?? false;
+  const workspaceSelection = await buildWorkspaceSelectionChecks(args, ctx);
+  const providerChecks = await buildAllProviderChecks(ctx, args.providerId);
+  const mobileHost = buildMobileHostCheck(ctx);
+  const checks = [
+    ...workspaceSelection.checks,
+    ...providerChecks.checks,
+    buildServerAuthCheck(ctx),
+    mobileHost.check
+  ];
+  let canContinue = mobileHost.canContinue;
+  if (!authEnabled) {
+    canContinue = false;
+    checks.push({
+      id: "mobile-auth",
+      code: "mobile_auth_disabled",
+      status: "needs_attention"
+    });
+  } else {
+    checks.push({
+      id: "mobile-auth",
+      code: "server_auth_ready",
+      status: "ready"
+    });
+  }
+  return {
+    context: "mobile_continue",
+    canContinue,
+    checks,
+    metadata: {
+      authEnabled,
+      host,
+      workspaceId: args.workspaceId,
+      workspacePath: workspaceSelection.workspacePath,
+      providerId: args.providerId
+    }
+  };
+}
+async function buildDiagnostics(args, ctx) {
+  switch (args.context) {
+    case "workspace_open": {
+      const workspaceSelection = await buildWorkspaceSelectionChecks(args, ctx);
+      const providerChecks = await buildAllProviderChecks(ctx, args.providerId);
+      const mobileHost = buildMobileHostCheck(ctx);
+      return {
+        context: "workspace_open",
+        canContinue: workspaceSelection.canContinue,
+        checks: [
+          ...workspaceSelection.checks,
+          ...providerChecks.checks,
+          buildServerAuthCheck(ctx),
+          mobileHost.check
+        ],
+        metadata: {
+          workspacePath: workspaceSelection.workspacePath ?? args.workspacePath,
+          authEnabled: ctx.config?.auth.enabled ?? false,
+          host: ctx.config?.host,
+          providerId: args.providerId,
+          workspaceId: args.workspaceId
+        }
+      };
+    }
+    case "session_start":
+      return buildSessionStartDiagnostics(args, ctx);
+    case "mobile_continue":
+      return buildMobileDiagnostics(args, ctx);
+    case "manual_check":
+      return buildManualDiagnostics(args, ctx);
+  }
+}
+var DiagnosticsRequestSchema;
+var init_diagnostics2 = __esm({
+  "packages/server/src/commands/diagnostics.ts"() {
+    "use strict";
+    init_runtime_status();
+    init_validator();
+    init_dispatch();
+    DiagnosticsRequestSchema = z14.object({
+      context: z14.enum(["workspace_open", "session_start", "mobile_continue", "manual_check"]),
+      workspaceId: z14.string().optional(),
+      workspacePath: z14.string().optional(),
+      providerId: z14.string().optional()
+    });
+    registerCommand("diagnostics.get", DiagnosticsRequestSchema, async (args, ctx) => {
+      return buildDiagnostics(args, ctx);
+    });
+    registerCommand("diagnostics.recheck", DiagnosticsRequestSchema, async (args, ctx) => {
+      return buildDiagnostics(args, ctx);
+    });
+  }
+});
+
+// packages/server/src/commands/provider.ts
+import { z as z15 } from "zod";
 var init_provider = __esm({
   "packages/server/src/commands/provider.ts"() {
     "use strict";
     init_runtime_status();
     init_dispatch();
-    registerCommand("provider.runtimeStatus", z14.object({}), async (_args, ctx) => {
+    registerCommand("provider.runtimeStatus", z15.object({}), async (_args, ctx) => {
       return buildProviderRuntimeStatus(ctx.providerRegistry, ctx.providerRuntimeDeps);
     });
     registerCommand(
       "provider.install.start",
-      z14.object({
-        providerId: z14.string()
+      z15.object({
+        providerId: z15.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -12198,8 +13149,8 @@ var init_provider = __esm({
     );
     registerCommand(
       "provider.install.get",
-      z14.object({
-        jobId: z14.string()
+      z15.object({
+        jobId: z15.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -12222,35 +13173,35 @@ var init_provider = __esm({
 });
 
 // packages/server/src/commands/supervisor.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var supervisorObjectiveSchema, createSupervisorSchema, updateSupervisorSchema, sessionIdSchema, supervisorIdSchema;
 var init_supervisor2 = __esm({
   "packages/server/src/commands/supervisor.ts"() {
     "use strict";
     init_dispatch();
-    supervisorObjectiveSchema = z15.string().trim().min(1).max(4e3);
-    createSupervisorSchema = z15.object({
-      sessionId: z15.string(),
-      workspaceId: z15.string(),
+    supervisorObjectiveSchema = z16.string().trim().min(1).max(4e3);
+    createSupervisorSchema = z16.object({
+      sessionId: z16.string(),
+      workspaceId: z16.string(),
       objective: supervisorObjectiveSchema,
-      evaluatorProviderId: z15.string(),
-      evaluatorModel: z15.string().trim().min(1).max(200).optional(),
-      maxSupervisionCount: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      scheduledAt: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+      evaluatorProviderId: z16.string(),
+      evaluatorModel: z16.string().trim().min(1).max(200).optional(),
+      maxSupervisionCount: z16.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z16.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
     }).strict();
-    updateSupervisorSchema = z15.object({
-      id: z15.string(),
+    updateSupervisorSchema = z16.object({
+      id: z16.string(),
       objective: supervisorObjectiveSchema.optional(),
-      evaluatorProviderId: z15.string().optional(),
-      evaluatorModel: z15.string().trim().min(1).max(200).nullable().optional(),
-      maxSupervisionCount: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      scheduledAt: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable().optional()
+      evaluatorProviderId: z16.string().optional(),
+      evaluatorModel: z16.string().trim().min(1).max(200).nullable().optional(),
+      maxSupervisionCount: z16.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z16.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable().optional()
     }).strict().refine(
       (input2) => input2.objective !== void 0 || input2.evaluatorProviderId !== void 0 || input2.evaluatorModel !== void 0 || input2.maxSupervisionCount !== void 0 || input2.scheduledAt !== void 0,
       "at least one supervisor field is required"
     );
-    sessionIdSchema = z15.object({ sessionId: z15.string() });
-    supervisorIdSchema = z15.object({ id: z15.string() });
+    sessionIdSchema = z16.object({ sessionId: z16.string() });
+    supervisorIdSchema = z16.object({ id: z16.string() });
     registerCommand("supervisor.create", createSupervisorSchema, async (args, ctx) => {
       return {
         supervisor: await ctx.supervisorMgr.create({
@@ -12434,7 +13385,7 @@ var init_worktree = __esm({
 
 // packages/server/src/commands/worktree.ts
 import path9 from "node:path";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 async function findRelatedWorkspaceIds(ctx, workspacePath) {
   const targetCommonDir = await getGitCommonDirPath(workspacePath);
   const relatedWorkspaceIds = await Promise.all(
@@ -12467,7 +13418,7 @@ var init_worktree2 = __esm({
     init_worktree();
     init_dispatch();
     init_git_events();
-    registerCommand("worktree.list", z16.object({ workspaceId: z16.string() }), async (args, ctx) => {
+    registerCommand("worktree.list", z17.object({ workspaceId: z17.string() }), async (args, ctx) => {
       const workspace = ctx.workspaceMgr.get(args.workspaceId);
       if (!workspace) {
         throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
@@ -12476,7 +13427,7 @@ var init_worktree2 = __esm({
     });
     registerCommand(
       "worktree.status",
-      z16.object({ workspaceId: z16.string(), worktreePath: z16.string() }),
+      z17.object({ workspaceId: z17.string(), worktreePath: z17.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -12488,10 +13439,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.diff",
-      z16.object({
-        workspaceId: z16.string(),
-        worktreePath: z16.string(),
-        staged: z16.boolean().optional().default(false)
+      z17.object({
+        workspaceId: z17.string(),
+        worktreePath: z17.string(),
+        staged: z17.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -12504,7 +13455,7 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.tree",
-      z16.object({ workspaceId: z16.string(), worktreePath: z16.string() }),
+      z17.object({ workspaceId: z17.string(), worktreePath: z17.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -12516,10 +13467,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.create",
-      z16.object({
-        workspaceId: z16.string(),
-        branch: z16.string(),
-        path: z16.string()
+      z17.object({
+        workspaceId: z17.string(),
+        branch: z17.string(),
+        path: z17.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -12534,10 +13485,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.remove",
-      z16.object({
-        workspaceId: z16.string(),
-        worktreePath: z16.string(),
-        force: z16.boolean().optional().default(false)
+      z17.object({
+        workspaceId: z17.string(),
+        worktreePath: z17.string(),
+        force: z17.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -12561,7 +13512,7 @@ var init_worktree2 = __esm({
 });
 
 // packages/server/src/commands/fencing.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function createMockFencingRequest() {
   return {
     ip: "127.0.0.1",
@@ -12574,9 +13525,9 @@ var init_fencing2 = __esm({
     init_dispatch();
     registerCommand(
       "fencing.request",
-      z17.object({
-        workspaceId: z17.string(),
-        tabId: z17.string()
+      z18.object({
+        workspaceId: z18.string(),
+        tabId: z18.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.requestControl(
@@ -12589,7 +13540,7 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.heartbeat",
-      z17.object({ workspaceId: z17.string() }),
+      z18.object({ workspaceId: z18.string() }),
       async (args, ctx, clientId) => {
         const success = ctx.fencingMgr.heartbeat(args.workspaceId, clientId);
         return { success };
@@ -12597,13 +13548,13 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.release",
-      z17.object({ workspaceId: z17.string() }),
+      z18.object({ workspaceId: z18.string() }),
       async (args, ctx, clientId) => {
         ctx.fencingMgr.release(args.workspaceId, clientId);
         return {};
       }
     );
-    registerCommand("fencing.status", z17.object({ workspaceId: z17.string() }), async (args, ctx) => {
+    registerCommand("fencing.status", z18.object({ workspaceId: z18.string() }), async (args, ctx) => {
       const controller = ctx.fencingMgr.getController(args.workspaceId);
       const isUnresponsive = ctx.fencingMgr.isControllerUnresponsive(args.workspaceId);
       return {
@@ -12614,9 +13565,9 @@ var init_fencing2 = __esm({
     });
     registerCommand(
       "fencing.takeover",
-      z17.object({
-        workspaceId: z17.string(),
-        tabId: z17.string()
+      z18.object({
+        workspaceId: z18.string(),
+        tabId: z18.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.forceTakeover(
@@ -12643,6 +13594,7 @@ var init_commands = __esm({
     init_file();
     init_git2();
     init_settings2();
+    init_diagnostics2();
     init_provider();
     init_supervisor2();
     init_worktree2();
@@ -12786,7 +13738,8 @@ async function createServer(configOverrides) {
     autoFetch,
     providerRuntimeDeps,
     providerInstallMgr,
-    activationMgr
+    activationMgr,
+    config
   };
   wsHub.setCommandContext(commandContext);
   await app.listen({
@@ -13361,7 +14314,7 @@ function getOpenCommand(url) {
 }
 async function openBrowser(url) {
   const { command, args } = getOpenCommand(url);
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const child = spawn3(command, args, {
       detached: true,
       stdio: "ignore",
@@ -13370,7 +14323,7 @@ async function openBrowser(url) {
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve4();
+      resolve5();
     });
   });
 }
@@ -13739,29 +14692,29 @@ async function loadPm2() {
 }
 var connectPm2 = async () => {
   const pm2 = await loadPm2();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     pm2.connect((error) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve4();
+      resolve5();
     });
   });
 };
-var sleep = async (ms) => new Promise((resolve4) => {
-  setTimeout(resolve4, ms);
+var sleep = async (ms) => new Promise((resolve5) => {
+  setTimeout(resolve5, ms);
 });
 var disconnectPm2 = async () => {
   const pm2 = await loadPm2();
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     let settled = false;
     const finish = () => {
       if (settled) {
         return;
       }
       settled = true;
-      resolve4();
+      resolve5();
     };
     const timer = setTimeout(finish, PM2_DISCONNECT_WAIT_MS);
     try {
@@ -13775,29 +14728,29 @@ var disconnectPm2 = async () => {
     }
   });
 };
-var describeManagedServer = async (pm2) => new Promise((resolve4, reject) => {
+var describeManagedServer = async (pm2) => new Promise((resolve5, reject) => {
   pm2.describe(MANAGED_SERVER_NAME, (error, result) => {
     if (error) {
       reject(error);
       return;
     }
-    resolve4(result ?? []);
+    resolve5(result ?? []);
   });
 });
-var removeManagedServer = async (pm2) => new Promise((resolve4, reject) => {
+var removeManagedServer = async (pm2) => new Promise((resolve5, reject) => {
   pm2.delete(MANAGED_SERVER_NAME, (error) => {
     if (error) {
       reject(error);
       return;
     }
-    resolve4();
+    resolve5();
   });
 });
 var killPm2Daemon = async () => {
   const pm2 = await loadPm2();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     pm2.kill(() => {
-      resolve4();
+      resolve5();
     });
   });
 };
@@ -13943,7 +14896,7 @@ var startManagedServer = async ({
   ensureLogDirectory();
   const { outFile, errFile } = getLogPaths();
   const logOffsets = captureStartupLogOffsets();
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     pm2.start(
       {
         name: MANAGED_SERVER_NAME,
@@ -13966,7 +14919,7 @@ var startManagedServer = async ({
           reject(error);
           return;
         }
-        resolve4();
+        resolve5();
       }
     );
   });
@@ -14084,11 +15037,11 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/cli/src/embed.ts
 import { existsSync as existsSync10 } from "fs";
-import { dirname as dirname6, resolve as resolve3 } from "path";
+import { dirname as dirname6, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname6(__filename);
-var WEB_ASSETS_DIR = resolve3(__dirname, "../web");
+var WEB_ASSETS_DIR = resolve4(__dirname, "../web");
 function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }