@spencer-kit/coder-studio 0.4.3 → 0.4.4

package/dist/esm/server-runner.mjs

@@ -931,10 +931,10 @@ function resolveSpawnArgv(argv, deps = {}) {
   }
   const restArgs = argv.slice(1);
   const readFileSync10 = deps.readFileSync ?? ((file) => fs2.readFileSync(file, "utf8"));
-  const existsSync13 = deps.existsSync ?? fs2.existsSync;
+  const existsSync14 = deps.existsSync ?? fs2.existsSync;
   const pathEnv = deps.pathEnv ?? process.env.Path ?? process.env.PATH ?? "";
   const pathExt = deps.pathExt ?? process.env.PATHEXT ?? DEFAULT_PATHEXT;
-  const resolved = resolveExecutablePath(command, pathEnv, pathExt, existsSync13);
+  const resolved = resolveExecutablePath(command, pathEnv, pathExt, existsSync14);
   if (!resolved) {
     return [...argv];
   }
@@ -983,17 +983,17 @@ function expandShimVars(value, dp0Dir) {
 function parsePathExt(pathExt) {
   return pathExt.split(";").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
 }
-function resolveExecutablePath(command, pathEnv, pathExt, existsSync13) {
+function resolveExecutablePath(command, pathEnv, pathExt, existsSync14) {
   const hasExt = path3.win32.extname(command).length > 0;
   const extensions = parsePathExt(pathExt);
   if (path3.win32.isAbsolute(command)) {
-    if (existsSync13(command)) {
+    if (existsSync14(command)) {
       return command;
     }
     if (!hasExt) {
       for (const ext of extensions) {
         const candidate = command + ext;
-        if (existsSync13(candidate)) {
+        if (existsSync14(candidate)) {
           return candidate;
         }
       }
@@ -1004,14 +1004,14 @@ function resolveExecutablePath(command, pathEnv, pathExt, existsSync13) {
   for (const dir of dirs) {
     if (hasExt) {
       const candidate = path3.win32.join(dir, command);
-      if (existsSync13(candidate)) {
+      if (existsSync14(candidate)) {
         return candidate;
       }
       continue;
     }
     for (const ext of extensions) {
       const candidate = path3.win32.join(dir, command + ext);
-      if (existsSync13(candidate)) {
+      if (existsSync14(candidate)) {
         return candidate;
       }
     }
@@ -2532,12 +2532,12 @@ async function ensureSafeUploadDir(rootDir, targetDir2) {
     await mkdir3(resolvedRoot, { recursive: true });
     await assertDirectorySegmentSafe(resolvedRoot);
   }
-  const relative3 = path7.relative(resolvedRoot, resolvedTarget);
-  if (!relative3) {
+  const relative4 = path7.relative(resolvedRoot, resolvedTarget);
+  if (!relative4) {
     return;
   }
   let current = resolvedRoot;
-  for (const segment of relative3.split(path7.sep)) {
+  for (const segment of relative4.split(path7.sep)) {
     current = path7.join(current, segment);
     try {
       await assertDirectorySegmentSafe(current);
@@ -8055,7 +8055,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
   const arch = deps.arch ?? process.arch;
   const resolve4 = deps.resolve ?? ((id) => require4.resolve(id));
   const fileExists = deps.existsSync ?? existsSync6;
-  const stat9 = deps.statSync ?? statSync;
+  const stat10 = deps.statSync ?? statSync;
   const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
@@ -8073,7 +8073,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
     if (!fileExists(helperPath)) {
       return;
     }
-    const currentMode = stat9(helperPath).mode;
+    const currentMode = stat10(helperPath).mode;
     const executableMode = currentMode | 73;
     if (executableMode === currentMode) {
       return;
@@ -8279,13 +8279,19 @@ import { spawn as spawn3 } from "node:child_process";
 function buildPrompt(context, mode) {
   if (mode === "decompose") {
     return [
-      "You are an autonomous supervisor for a target-scoped software task.",
+      "You are an autonomous planner-supervisor for this target-scoped software task.",
+      "Your purpose is to drive the work from objective to high-quality delivery with minimal babysitting.",
+      'Do not optimize for merely reaching "done"; optimize for a result that is correct, verified, coherent, and not obviously low-quality or rushed.',
       "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:",
+      "- Create an execution plan, not just a task list.",
+      "- Break the objective into the smallest reasonable set of milestones that maximize clarity, reduce uncertainty, and preserve steady forward progress.",
+      "- Order milestones by dependency, risk reduction, and delivery leverage.",
+      "- Prefer a plan structure that makes execution easier, verification clearer, and replanning cheaper.",
       "- 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.",
@@ -8299,6 +8305,30 @@ function buildPrompt(context, mode) {
       "- Each item must be concrete, milestone-sized, and useful for subsequent evaluation.",
       "- Do not leave the structure empty.",
       "",
+      "Decomposition principles:",
+      "- Prefer milestones that produce a concrete artifact, observable behavior change, test result, or verification result.",
+      "- Make dependencies explicit.",
+      "- Separate implementation, verification, integration, and cleanup when that improves delivery reliability.",
+      "- If a step is too vague to verify independently, split it further.",
+      "- Prefer plans that keep the agent moving with minimal ambiguity between milestones.",
+      "- Use stage-based planning by default unless there are clearly independent deliverables that justify subtargets.",
+      "- Build the plan so it can recover from failed attempts: prefer decompositions that allow narrowing scope, isolating failures, checking assumptions, and restoring a working baseline when needed.",
+      "- Keep the decomposition practical for execution, not merely neat on paper.",
+      "",
+      "Planning quality bar:",
+      "- Prefer fewer, stronger milestones over many thin or vague ones.",
+      "- Every item should imply a concrete deliverable and observable acceptance criteria.",
+      '- Avoid vague items such as "improve", "clean up", or "refactor" unless tied to a specific delivery or verification target.',
+      "- Include quality and verification checkpoints where they materially improve the final result.",
+      "- Do not decompose in a way that encourages superficial completion.",
+      "",
+      "Planning boundary:",
+      "- You are responsible for execution structure, sequencing, quality control, and verification structure.",
+      "- Do not hard-code unnecessary implementation detail too early.",
+      "- If multiple implementation paths exist, prefer a plan that keeps execution adaptable until evidence makes one path clearly better.",
+      "- Do not hide assumptions inside the plan.",
+      "- Do not create a brittle plan that depends on perfect execution.",
+      "",
       "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".',
@@ -8331,8 +8361,13 @@ function buildPrompt(context, mode) {
     ].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.",
+    "You are an autonomous planner-supervisor for this target-scoped software task.",
+    "Your purpose is to drive the work from objective to high-quality delivery with minimal babysitting.",
+    'Do not optimize for merely reaching "done"; optimize for a result that is correct, verified, coherent, and not obviously low-quality or rushed.',
+    "Act as an autonomous execution supervisor.",
+    "Your job is to keep the agent moving toward the objective, maintain delivery quality, detect low-yield paths early, and redirect work when needed.",
+    "Do not passively observe progress; actively steer it toward successful, high-quality completion.",
+    "Drive execution through the supervised agent rather than by independently performing the work yourself.",
     "",
     "Return JSON only.",
     "No prose before or after the JSON.",
@@ -8363,7 +8398,12 @@ function buildPrompt(context, mode) {
     '- 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 current path is low-yield, brittle, repetitive, or producing low-quality output, redirect early.",
+    "- Diagnose stalls precisely: implementation failure, verification failure, environment failure, scope misframing, weak solution quality, or missing evidence.",
+    "- Choose the next action that most improves objective-level progress, not merely the most local continuation.",
+    "- Do not repeat the same tactic after failure unless new evidence justifies retrying it.",
+    "- Maintain commitment to the objective, not blind commitment to the current tactic.",
+    "- Replan locally when needed, but keep the overall execution coherent and objective-driven.",
     "- Do not rewrite the decomposition structure during normal evaluation cycles.",
     "",
     "Allowed statuses:",
@@ -8388,6 +8428,21 @@ function buildPrompt(context, mode) {
     "- 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.",
     "",
+    "Delivery quality bar:",
+    "- Do not accept shallow, brittle, or obviously rushed solutions.",
+    "- Do not optimize for the smallest change if it leads to poor maintainability, weak verification, or fragile behavior.",
+    "- Prefer solutions that are robust, coherent with the existing codebase, and likely to hold up beyond the happy path.",
+    "- Require appropriate verification for the kind of work being done.",
+    "- Consider edge cases, integration impact, regressions, and maintainability where relevant.",
+    "- If a solution technically works but is low-quality, incomplete, poorly verified, or obviously a shortcut, treat the milestone as not yet complete.",
+    "- Do not let superficial progress masquerade as real delivery.",
+    "",
+    "Completion standard:",
+    "- A milestone is complete only when its deliverable and acceptanceCriteria are supported by observable evidence and the result meets a reasonable quality bar.",
+    "- The objective is complete only when the final result is implemented, verified, and not obviously compromised in quality.",
+    "- Do not mark work complete merely because code was changed, a command passed once, or a minimal patch exists.",
+    "- Optimize for finished, verified, and defensible delivery.",
+    "",
     "Evaluation policy:",
     "- Update progress incrementally against the existing decomposition.",
     "- Use itemUpdates to reflect evidence-backed status changes only.",
@@ -14872,20 +14927,260 @@ var init_session2 = __esm({
   }
 });
 
+// packages/server/src/fs/content-search.ts
+import { spawn as spawn5 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { readdir as readdir4, readFile as readFile4, stat as stat8 } from "fs/promises";
+import { basename as basename2, join as join10, relative as relative2 } from "path";
+import { createInterface } from "readline";
+async function searchFileContents(rootPath, options) {
+  const query = options.query.trim();
+  if (!query) {
+    return {
+      files: [],
+      totalMatchCount: 0,
+      hasMoreFiles: false,
+      truncatedMatchFileCount: 0
+    };
+  }
+  const result = await searchWithRipgrep(rootPath, query, options.maxFiles).catch(
+    async (error) => {
+      if (error.code === "ENOENT") {
+        return searchWithNode(rootPath, query, options.maxFiles);
+      }
+      throw error;
+    }
+  );
+  return finalizeResults(result, options.maxFiles, options.maxMatchesPerFile);
+}
+async function searchWithRipgrep(rootPath, query, maxFiles) {
+  const hasGitignore = existsSync8(join10(rootPath, ".gitignore"));
+  const args = [
+    "--json",
+    "--line-number",
+    "--column",
+    "--fixed-strings",
+    "--sort",
+    "path",
+    "--with-filename",
+    "--glob",
+    "!**/.git/**",
+    "--glob",
+    "!**/node_modules/**"
+  ];
+  if (hasGitignore) {
+    args.push("--hidden");
+    args.push("--no-require-git");
+  }
+  args.push(query, ".");
+  return new Promise((resolve4, reject) => {
+    const child = spawn5("rg", args, { cwd: rootPath, stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = createInterface({ input: child.stdout });
+    const files = /* @__PURE__ */ new Map();
+    let totalMatchCount = 0;
+    let hasMoreFiles = false;
+    let stderr = "";
+    stdout.on("line", (line) => {
+      if (!line.trim()) {
+        return;
+      }
+      const event = JSON.parse(line);
+      if (event.type !== "match") {
+        return;
+      }
+      const rawPath = event.data?.path?.text;
+      if (!rawPath) {
+        return;
+      }
+      const relativePath = normalizeRelativePath(relative2(rootPath, join10(rootPath, rawPath)));
+      const preview = (event.data?.lines?.text ?? "").replace(/\r?\n$/, "");
+      const lineNumber = event.data?.line_number ?? 1;
+      const submatches = event.data?.submatches ?? [];
+      totalMatchCount += submatches.length;
+      if (!files.has(relativePath) && files.size >= maxFiles) {
+        hasMoreFiles = true;
+        return;
+      }
+      for (const submatch of submatches) {
+        pushMatch(files, relativePath, {
+          line: lineNumber,
+          column: byteOffsetToColumn(preview, submatch.start),
+          endColumn: byteOffsetToColumn(preview, submatch.end),
+          preview,
+          previewColumnStart: byteOffsetToColumn(preview, submatch.start),
+          previewColumnEnd: byteOffsetToColumn(preview, submatch.end)
+        });
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      void stdout.close();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      void stdout.close();
+      if (code === 0 || code === 1) {
+        resolve4({
+          files: sortAccumulators(files),
+          totalMatchCount,
+          hasMoreFiles
+        });
+        return;
+      }
+      reject(
+        Object.assign(new Error(stderr || `rg exited with code ${code ?? "unknown"}`), { code })
+      );
+    });
+  });
+}
+async function searchWithNode(rootPath, query, maxFiles) {
+  const files = /* @__PURE__ */ new Map();
+  let totalMatchCount = 0;
+  let hasMoreFiles = false;
+  async function walk(dirPath) {
+    const filter = createGitignoreFilter(rootPath, dirPath);
+    const entries = await readdir4(dirPath, { withFileTypes: true });
+    const filteredEntries = entries.filter((entry) => filter(entry.name));
+    filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of filteredEntries) {
+      const fullPath = join10(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const fileStat = await stat8(fullPath);
+      if (fileStat.size > FALLBACK_MAX_FILE_BYTES) {
+        continue;
+      }
+      const buffer = await readFile4(fullPath);
+      if (isBinaryFile(buffer)) {
+        continue;
+      }
+      const relativePath = normalizeRelativePath(relative2(rootPath, fullPath));
+      const file = collectMatchesFromText(relativePath, buffer.toString("utf-8"), query);
+      if (!file) {
+        continue;
+      }
+      totalMatchCount += file.matchCount;
+      if (files.size >= maxFiles) {
+        hasMoreFiles = true;
+        continue;
+      }
+      files.set(relativePath, file);
+    }
+  }
+  await walk(rootPath);
+  return {
+    files: sortAccumulators(files),
+    totalMatchCount,
+    hasMoreFiles
+  };
+}
+function collectMatchesFromText(relativePath, content, query) {
+  const file = {
+    path: relativePath,
+    name: basename2(relativePath),
+    matches: [],
+    matchCount: 0
+  };
+  const lines = content.split(/\r?\n/);
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const preview = lines[lineIndex] ?? "";
+    if (!preview) {
+      continue;
+    }
+    let fromIndex = 0;
+    while (fromIndex <= preview.length) {
+      const matchIndex = preview.indexOf(query, fromIndex);
+      if (matchIndex === -1) {
+        break;
+      }
+      const startColumn = matchIndex + 1;
+      const endColumn = startColumn + query.length;
+      file.matches.push({
+        line: lineIndex + 1,
+        column: startColumn,
+        endColumn,
+        preview,
+        previewColumnStart: startColumn,
+        previewColumnEnd: endColumn
+      });
+      file.matchCount += 1;
+      fromIndex = matchIndex + Math.max(query.length, 1);
+    }
+  }
+  return file.matchCount > 0 ? file : null;
+}
+function pushMatch(files, relativePath, match) {
+  let file = files.get(relativePath);
+  if (!file) {
+    file = {
+      path: relativePath,
+      name: basename2(relativePath),
+      matches: [],
+      matchCount: 0
+    };
+    files.set(relativePath, file);
+  }
+  file.matches.push(match);
+  file.matchCount += 1;
+}
+function sortAccumulators(files) {
+  return Array.from(files.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+function finalizeResults(result, maxFiles, maxMatchesPerFile) {
+  const visibleFiles = result.files.slice(0, maxFiles).map((file) => ({
+    path: file.path,
+    name: file.name,
+    matchCount: file.matchCount,
+    hasMoreMatches: file.matchCount > maxMatchesPerFile,
+    matches: file.matches.slice(0, maxMatchesPerFile)
+  }));
+  return {
+    files: visibleFiles,
+    totalMatchCount: result.totalMatchCount,
+    hasMoreFiles: result.hasMoreFiles || result.files.length > maxFiles,
+    truncatedMatchFileCount: visibleFiles.filter((file) => file.hasMoreMatches).length
+  };
+}
+function normalizeRelativePath(path14) {
+  return path14.replace(/\\/g, "/");
+}
+function byteOffsetToColumn(preview, byteOffset) {
+  return Buffer.from(preview, "utf8").subarray(0, byteOffset).toString("utf8").length + 1;
+}
+function isBinaryFile(buffer) {
+  const sample = buffer.subarray(0, 8e3);
+  return sample.includes(0);
+}
+var FALLBACK_MAX_FILE_BYTES;
+var init_content_search = __esm({
+  "packages/server/src/fs/content-search.ts"() {
+    "use strict";
+    init_gitignore();
+    FALLBACK_MAX_FILE_BYTES = 1e6;
+  }
+});
+
 // packages/server/src/fs/tree.ts
-import { readdir as readdir4, stat as stat8 } from "fs/promises";
-import { join as join10, relative as relative2 } from "path";
+import { readdir as readdir5, stat as stat9 } from "fs/promises";
+import { join as join11, relative as relative3 } from "path";
 async function readTree(rootPath, subdir) {
-  const targetPath = subdir ? join10(rootPath, subdir) : rootPath;
+  const targetPath = subdir ? join11(rootPath, subdir) : rootPath;
   const filter = createTreeVisibilityFilter();
-  const entries = await readdir4(targetPath, { withFileTypes: true });
+  const entries = await readdir5(targetPath, { withFileTypes: true });
   const nodes = [];
   for (const entry of entries) {
     if (!filter(entry.name)) {
       continue;
     }
-    const fullPath = join10(targetPath, entry.name);
-    const relPath = relative2(rootPath, fullPath);
+    const fullPath = join11(targetPath, entry.name);
+    const relPath = relative3(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
         name: entry.name,
@@ -14895,7 +15190,7 @@ async function readTree(rootPath, subdir) {
         // Not loaded yet - client will request on expand
       });
     } else if (entry.isFile()) {
-      const stats = await stat8(fullPath);
+      const stats = await stat9(fullPath);
       nodes.push({
         name: entry.name,
         path: relPath,
@@ -14924,18 +15219,18 @@ async function searchFiles(rootPath, query, limit = 10) {
   const matches = [];
   async function walk(dirPath) {
     const filter = createGitignoreFilter(rootPath, dirPath);
-    const entries = await readdir4(dirPath, { withFileTypes: true });
+    const entries = await readdir5(dirPath, { withFileTypes: true });
     const filteredEntries = entries.filter((entry) => filter(entry.name));
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
-      const fullPath = join10(dirPath, entry.name);
-      const relPath = relative2(rootPath, fullPath);
+      const fullPath = join11(dirPath, entry.name);
+      const relPath = relative3(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (entry.isFile()) {
-        const rank = scoreFilenameMatch(entry.name, normalizedQuery);
+        const rank = scoreFileMatch(relPath, entry.name, normalizedQuery);
         if (rank === null) {
           continue;
         }
@@ -14964,7 +15259,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     }
     return a.path.toLowerCase().localeCompare(b.path.toLowerCase());
   }).slice(0, limit)) {
-    const stats = await stat8(match.fullPath);
+    const stats = await stat9(match.fullPath);
     files.push({
       name: match.name,
       path: match.path,
@@ -14975,6 +15270,13 @@ async function searchFiles(rootPath, query, limit = 10) {
   }
   return { files };
 }
+function scoreFileMatch(path14, name, query) {
+  const filenameRank = scoreFilenameMatch(name, query);
+  if (filenameRank !== null) {
+    return filenameRank;
+  }
+  return scorePathMatch(path14, query);
+}
 function scoreFilenameMatch(name, query) {
   const normalizedName = name.toLowerCase();
   const baseName = normalizedName.replace(/\.[^.]+$/, "");
@@ -15001,6 +15303,22 @@ function scoreFilenameMatch(name, query) {
   }
   return null;
 }
+function scorePathMatch(path14, query) {
+  const normalizedPath = path14.toLowerCase();
+  if (normalizedPath === query) {
+    return 7;
+  }
+  if (normalizedPath.startsWith(query)) {
+    return 8;
+  }
+  if (normalizedPath.includes(query)) {
+    return 9;
+  }
+  if (isSubsequence(query, normalizedPath)) {
+    return 10;
+  }
+  return null;
+}
 function isSubsequence(query, candidate) {
   let index = 0;
   for (const char of candidate) {
@@ -15025,6 +15343,7 @@ import { z as z13 } from "zod";
 var init_file = __esm({
   "packages/server/src/commands/file.ts"() {
     "use strict";
+    init_content_search();
     init_file_io();
     init_tree();
     init_dispatch();
@@ -15057,6 +15376,26 @@ var init_file = __esm({
         return searchFiles(workspace.path, args.query, args.limit ?? 10);
       }
     );
+    registerCommand(
+      "file.searchContent",
+      z13.object({
+        workspaceId: z13.string(),
+        query: z13.string(),
+        maxFiles: z13.number().int().positive().max(100),
+        maxMatchesPerFile: z13.number().int().positive().max(100)
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return searchFileContents(workspace.path, {
+          query: args.query,
+          maxFiles: args.maxFiles,
+          maxMatchesPerFile: args.maxMatchesPerFile
+        });
+      }
+    );
     registerCommand(
       "file.read",
       z13.object({
@@ -15179,7 +15518,7 @@ var init_file = __esm({
 });
 
 // packages/server/src/git/diff.ts
-import { mkdtemp as mkdtemp3, readFile as readFile4, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile5, rm as rm6 } from "fs/promises";
 import os3 from "os";
 import path11 from "path";
 async function isTrackedPath(cwd, filePath) {
@@ -15219,7 +15558,7 @@ async function getUntrackedFileDiff(cwd, filePath) {
 }
 async function pathExists(cwd, filePath) {
   try {
-    await readFile4(resolveSafe(cwd, filePath));
+    await readFile5(resolveSafe(cwd, filePath));
     return true;
   } catch {
     return false;
@@ -15227,7 +15566,7 @@ async function pathExists(cwd, filePath) {
 }
 async function readTextAtRevision(cwd, revision, filePath) {
   if (revision === "WORKTREE") {
-    return readFile4(resolveSafe(cwd, filePath), "utf-8");
+    return readFile5(resolveSafe(cwd, filePath), "utf-8");
   }
   try {
     const gitSpec = revision === "INDEX" ? `:${filePath}` : `${revision}:${filePath}`;
@@ -15645,33 +15984,33 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename2, dirname as dirname7, join as join11 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join12 } from "node:path";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
     const testHome = process.env.CODER_STUDIO_CODEX_HOME;
     if (testHome && testHome.trim()) {
-      return join11(testHome, "config.toml");
+      return join12(testHome, "config.toml");
     }
     const codexHome = process.env.CODEX_HOME;
     if (codexHome && codexHome.trim()) {
-      return join11(codexHome, "config.toml");
+      return join12(codexHome, "config.toml");
     }
-    return join11(homedir3(), ".codex", "config.toml");
+    return join12(homedir3(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
-      return join11(testHome, "settings.json");
+      return join12(testHome, "settings.json");
     }
-    return join11(homedir3(), ".claude", "settings.json");
+    return join12(homedir3(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
 function readConfigFile(configType) {
   const configPath = resolveConfigPath(configType);
-  if (!existsSync8(configPath)) {
+  if (!existsSync9(configPath)) {
     return { configPath, content: "", exists: false };
   }
   try {
@@ -15685,11 +16024,11 @@ function writeConfigFile(configType, content) {
   try {
     const configPath = resolveConfigPath(configType);
     const parentDir = dirname7(configPath);
-    if (!existsSync8(parentDir)) {
+    if (!existsSync9(parentDir)) {
       mkdirSync7(parentDir, { recursive: true });
     }
     let backupPath = null;
-    if (existsSync8(configPath)) {
+    if (existsSync9(configPath)) {
       backupPath = createBackup(configPath);
     }
     const tempPath = `${configPath}.tmp`;
@@ -15707,10 +16046,10 @@ function writeConfigFile(configType, content) {
 function createBackup(filePath) {
   const original = readFileSync7(filePath, "utf-8");
   const ext = filePath.split(".").pop() ?? "";
-  const base = basename2(filePath, `.${ext}`);
+  const base = basename3(filePath, `.${ext}`);
   const dir = dirname7(filePath);
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join11(dir, `${base}.bak.${ts}.${ext}`);
+  const backupPath = join12(dir, `${base}.bak.${ts}.${ext}`);
   writeFileSync5(backupPath, original, "utf-8");
   return backupPath;
 }
@@ -17070,12 +17409,12 @@ var init_commands = __esm({
 // packages/server/src/server.ts
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function createServer(configOverrides) {
   const config = parseServerConfig(configOverrides);
   const configuredStateDir = resolveConfiguredStateDir(config);
   const shouldCleanupStateRoot = configuredStateDir === IN_MEMORY_STATE_DIR;
-  const stateRoot = shouldCleanupStateRoot ? mkdtempSync(join12(tmpdir(), "coder-studio-state-")) : configuredStateDir;
+  const stateRoot = shouldCleanupStateRoot ? mkdtempSync(join13(tmpdir(), "coder-studio-state-")) : configuredStateDir;
   ensureStateDir(config);
   const eventBus = new EventBus();
   const activationMgr = new ActivationManager();
@@ -17085,10 +17424,10 @@ async function createServer(configOverrides) {
   let commandContext;
   let lspMgr = null;
   const terminalRepo = new TerminalRepo({
-    filePath: join12(stateRoot, "state", "terminals.json")
+    filePath: join13(stateRoot, "state", "terminals.json")
   });
   const sessionRepo = new SessionRepo({
-    filePath: join12(stateRoot, "state", "sessions.json")
+    filePath: join13(stateRoot, "state", "sessions.json")
   });
   const terminalMgr = new TerminalManager({
     ptyHost: createPtyHost(),
@@ -17096,10 +17435,10 @@ async function createServer(configOverrides) {
     db: terminalRepo
   });
   const settingsRepo = new SettingsRepo({
-    filePath: join12(stateRoot, "state", "settings.json")
+    filePath: join13(stateRoot, "state", "settings.json")
   });
   const updateStateRepo = new UpdateStateRepo({
-    filePath: join12(stateRoot, "state", "update-state.json"),
+    filePath: join13(stateRoot, "state", "update-state.json"),
     currentVersion: config.appVersion ?? "0.0.0"
   });
   const autoFetch = new AutoFetchScheduler({
@@ -17132,10 +17471,10 @@ async function createServer(configOverrides) {
     }
   });
   const providerConfigRepo = new ProviderConfigRepo({
-    filePath: join12(stateRoot, "state", "provider-configs.json")
+    filePath: join13(stateRoot, "state", "provider-configs.json")
   });
   const workspaceRepo = new WorkspaceRepo({
-    filePath: join12(stateRoot, "state", "workspaces.json")
+    filePath: join13(stateRoot, "state", "workspaces.json")
   });
   const sessionMgr = new SessionManager({
     terminalMgr,
@@ -17170,10 +17509,10 @@ async function createServer(configOverrides) {
     )
   });
   const authSessionRepo = new AuthSessionRepo({
-    filePath: join12(stateRoot, "state", "auth-sessions.json")
+    filePath: join13(stateRoot, "state", "auth-sessions.json")
   });
   const authLoginBlockRepo = new AuthLoginBlockRepo({
-    filePath: join12(stateRoot, "state", "auth-login-blocks.json")
+    filePath: join13(stateRoot, "state", "auth-login-blocks.json")
   });
   const app = await buildFastifyApp({
     wsHub,
@@ -17248,7 +17587,7 @@ async function createServer(configOverrides) {
       ...config.update,
       currentVersion: config.appVersion ?? "0.0.0"
     },
-    updateWorkerLogFilePath: join12(stateRoot, "logs", "update-worker.log"),
+    updateWorkerLogFilePath: join13(stateRoot, "logs", "update-worker.log"),
     countRunningTerminals: () => terminalMgr.getAll().filter((terminal) => terminal.alive).length,
     countRunningSessions: () => sessionMgr.getAll().filter((session) => session.state === "starting" || session.state === "running").length,
     countActiveSupervisors: () => supervisorMgr?.countActive() ?? 0
@@ -17476,18 +17815,18 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 
 // packages/cli/src/config-store.ts
 init_state_paths();
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function getCliConfigPath() {
-  return join13(homedir4(), ".coder-studio", "config.json");
+  return join14(homedir4(), ".coder-studio", "config.json");
 }
 function normalizeLegacyDataDir(input) {
   return normalizeLegacyStateDir(input);
 }
 function readCliConfig() {
   const path14 = getCliConfigPath();
-  if (!existsSync9(path14)) {
+  if (!existsSync10(path14)) {
     return null;
   }
   try {
@@ -17507,7 +17846,7 @@ function readCliConfig() {
 }
 
 // packages/cli/src/embed.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { dirname as dirname8, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename = fileURLToPath2(import.meta.url);
@@ -17517,7 +17856,7 @@ function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }
 function hasWebAssets() {
-  return existsSync10(WEB_ASSETS_DIR);
+  return existsSync11(WEB_ASSETS_DIR);
 }
 
 // packages/cli/src/node-version.ts
@@ -17551,12 +17890,12 @@ function assertSupportedNodeVersion(version = process.versions.node) {
 }
 
 // packages/cli/src/package-manifest.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 function resolveCliPackageManifestUrl(importMetaUrl) {
   const manifestUrl = [
     new URL("../package.json", importMetaUrl),
     new URL("../../package.json", importMetaUrl)
-  ].find((candidate) => existsSync11(candidate));
+  ].find((candidate) => existsSync12(candidate));
   if (!manifestUrl) {
     throw new Error("Unable to locate CLI package.json");
   }
@@ -17575,16 +17914,16 @@ function getCliPackageName(importMetaUrl) {
 }
 
 // packages/cli/src/update-runtime.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { dirname as dirname9, join as join14 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { dirname as dirname9, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveWorkerEntryPath(importMetaUrl) {
   const currentDir = dirname9(fileURLToPath3(importMetaUrl));
   const candidates = [
-    join14(currentDir, "update-worker.mjs"),
-    join14(currentDir, "../src/update-worker.ts")
+    join15(currentDir, "update-worker.mjs"),
+    join15(currentDir, "../src/update-worker.ts")
   ];
-  return candidates.find((candidate) => existsSync12(candidate));
+  return candidates.find((candidate) => existsSync13(candidate));
 }
 function getUpdateRuntimeInfo(importMetaUrl) {
   const workerEntryPath = resolveWorkerEntryPath(importMetaUrl);