appostle-installer 0.0.21 → 0.0.23

package/dist/worker.js

@@ -259,7 +259,7 @@ import { createReadStream, unlinkSync, existsSync as existsSync20 } from "fs";
 import { stat as stat9 } from "fs/promises";
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { hostname as getHostname2 } from "node:os";
-import path35 from "node:path";
+import path36 from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
@@ -712,18 +712,18 @@ function resolveNodePtyPackageRoot() {
     return null;
   }
 }
-function ensureExecutableBit(path39) {
-  if (!existsSync2(path39)) {
+function ensureExecutableBit(path40) {
+  if (!existsSync2(path40)) {
     return;
   }
-  const stat10 = statSync(path39);
+  const stat10 = statSync(path40);
   if (!stat10.isFile()) {
     return;
   }
   if ((stat10.mode & 73) === 73) {
     return;
   }
-  chmodSync(path39, stat10.mode | 73);
+  chmodSync(path40, stat10.mode | 73);
 }
 function ensureNodePtySpawnHelperExecutableForCurrentPlatform(options = {}) {
   const platform = options.platform ?? process.platform;
@@ -1341,11 +1341,11 @@ function parseGitRevParsePath(stdout) {
   if (lines.length !== 1) {
     return null;
   }
-  const path39 = lines[0]?.trim() ?? "";
-  if (!path39 || path39.startsWith("--")) {
+  const path40 = lines[0]?.trim() ?? "";
+  if (!path40 || path40.startsWith("--")) {
     return null;
   }
-  return path39;
+  return path40;
 }
 function resolveGitRevParsePath(cwd, stdout) {
   const parsed = parseGitRevParsePath(stdout);
@@ -2118,9 +2118,9 @@ async function deleteAppostleWorktree({
     }
   }
 }
-async function pathExists(path39) {
+async function pathExists(path40) {
   try {
-    await stat(path39);
+    await stat(path40);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -2129,8 +2129,8 @@ async function pathExists(path39) {
     throw error;
   }
 }
-async function removeDirectoryWithRetries(path39) {
-  if (!await pathExists(path39)) {
+async function removeDirectoryWithRetries(path40) {
+  if (!await pathExists(path40)) {
     return;
   }
   const delaysMs = [0, 100, 300, 700, 1500];
@@ -2140,17 +2140,17 @@ async function removeDirectoryWithRetries(path39) {
       await new Promise((resolve15) => setTimeout(resolve15, delay));
     }
     try {
-      await rm(path39, { recursive: true, force: true });
-      if (!await pathExists(path39)) {
+      await rm(path40, { recursive: true, force: true });
+      if (!await pathExists(path40)) {
         return;
       }
-      lastError = new Error(`Directory still present after rm: ${path39}`);
+      lastError = new Error(`Directory still present after rm: ${path40}`);
     } catch (error) {
       lastError = error;
     }
   }
-  if (await pathExists(path39)) {
-    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path39}`);
+  if (await pathExists(path40)) {
+    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path40}`);
   }
 }
 var createWorktree = async ({
@@ -3975,7 +3975,9 @@ var BrandEntrySchema = z10.object({
   variables: z10.array(BrandVariableSchema).optional().default([]),
   path: z10.string(),
   modifiedAt: z10.string(),
-  size: z10.number()
+  size: z10.number(),
+  /** Raw markdown body (frontmatter stripped). Optional, fed by the scanner. */
+  body: z10.string().optional()
 });
 var BrandFrontmatterSchema = z10.object({
   description: z10.string().optional(),
@@ -4152,6 +4154,22 @@ var BrandGenerateWireframeResponseSchema = z10.object({
     error: z10.string().nullable()
   })
 });
+var BrandAnalyzePhotographyRequestSchema = z10.object({
+  type: z10.literal("brands/analyze-photography"),
+  requestId: z10.string(),
+  workspaceRoot: z10.string(),
+  brandPath: z10.string(),
+  brief: z10.string(),
+  referenceDescriptions: z10.array(z10.string()).optional()
+});
+var BrandAnalyzePhotographyResponseSchema = z10.object({
+  type: z10.literal("brands/analyze-photography/response"),
+  payload: z10.object({
+    requestId: z10.string(),
+    updatedCount: z10.number(),
+    error: z10.string().nullable()
+  })
+});
 var RightFontEntrySchema = z10.object({
   id: z10.string(),
   name: z10.string(),
@@ -4251,10 +4269,14 @@ var MutableDaemonConfigSchema = z11.object({
     icon: z11.string().optional()
   }).passthrough().optional(),
   chrome: z11.object({
-    // When false, agents on this host won't get the --chrome flag,
-    // preventing the client's Chrome browser from being controlled.
-    // Useful on headless servers where browser tools should target
-    // a local headless Chrome instead of the remote client's browser.
+    // When false, agents on this host won't have the claude-in-chrome
+    // tools injected. Set to false on hosts where the client's browser
+    // should not be controlled (e.g. headless/server-only hosts).
+    enabled: z11.boolean()
+  }).passthrough().optional(),
+  playwright: z11.object({
+    // When false, agents on this host won't have the Playwright MCP
+    // server injected.
     enabled: z11.boolean()
   }).passthrough().optional()
 }).passthrough();
@@ -4263,7 +4285,8 @@ var MutableDaemonConfigPatchSchema = z11.object({
   identity: z11.object({
     icon: z11.string().optional()
   }).partial().passthrough().optional(),
-  chrome: MutableDaemonConfigSchema.shape.chrome
+  chrome: MutableDaemonConfigSchema.shape.chrome,
+  playwright: MutableDaemonConfigSchema.shape.playwright
 }).partial().passthrough();
 var AgentStatusSchema = z11.enum(AGENT_LIFECYCLE_STATUSES);
 var AgentModeSchema = z11.object({
@@ -6273,6 +6296,7 @@ var SessionInboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutRequestSchema,
   BrandLayoutQaNextRequestSchema,
   BrandGenerateWireframeRequestSchema,
+  BrandAnalyzePhotographyRequestSchema,
   RightFontLibraryRequestSchema,
   GoogleFontsCatalogRequestSchema,
   GoogleFontsDownloadRequestSchema,
@@ -7909,6 +7933,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutResponseSchema,
   BrandLayoutQaNextResponseSchema,
   BrandGenerateWireframeResponseSchema,
+  BrandAnalyzePhotographyResponseSchema,
   RightFontLibraryResponseSchema,
   GoogleFontsCatalogResponseSchema,
   GoogleFontsDownloadResponseSchema,
@@ -8157,7 +8182,7 @@ import { exec } from "node:child_process";
 import { promisify as promisify3 } from "util";
 import { join as join16, resolve as resolve10, sep as sep2 } from "path";
 import { homedir as homedir6, hostname as osHostname } from "node:os";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../server/src/server/persisted-config.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
@@ -8454,6 +8479,9 @@ var PersistedConfigSchema = z14.object({
     }).strict().optional(),
     chrome: z14.object({
       enabled: z14.boolean().optional()
+    }).strict().optional(),
+    playwright: z14.object({
+      enabled: z14.boolean().optional()
     }).strict().optional()
   }).strict().transform(({ allowedHosts, ...daemon }) => {
     const hostnames = daemon.hostnames ?? allowedHosts;
@@ -10480,14 +10508,14 @@ var DictationStreamManager = class {
       PCM_CHANNELS,
       PCM_BITS_PER_SAMPLE
     );
-    const path39 = await maybePersistDictationDebugAudio(
+    const path40 = await maybePersistDictationDebugAudio(
       wavBuffer,
       { sessionId: state.sessionId, dictationId: state.dictationId, format: "audio/wav" },
       this.logger,
       state.debugChunkWriter?.folder
     );
-    state.debugRecordingPath = path39;
-    return path39;
+    state.debugRecordingPath = path40;
+    return path40;
   }
   failDictationStream(dictationId, error, retryable) {
     this.emit({
@@ -12505,14 +12533,14 @@ function parseDiff(diffText) {
     const firstLine = lines[0];
     const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
     const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
-    let path39 = "unknown";
+    let path40 = "unknown";
     const pathMatch = firstLine.match(/a\/(.*?) b\//);
     if (pathMatch) {
-      path39 = pathMatch[1];
+      path40 = pathMatch[1];
     } else {
       const newFileMatch = firstLine.match(/b\/(.+)$/);
       if (newFileMatch) {
-        path39 = newFileMatch[1];
+        path40 = newFileMatch[1];
       }
     }
     const hunks = [];
@@ -12556,7 +12584,7 @@ function parseDiff(diffText) {
     if (currentHunk) {
       hunks.push(currentHunk);
     }
-    files.push({ path: path39, isNew, isDeleted, additions, deletions, hunks });
+    files.push({ path: path40, isNew, isDeleted, additions, deletions, hunks });
   }
   return files;
 }
@@ -12612,9 +12640,9 @@ function buildTokenLookup(lineMap, highlighted) {
   }
   return lookup;
 }
-function buildFullFileTokenLookup(fileContent, path39) {
+function buildFullFileTokenLookup(fileContent, path40) {
   const lookup = /* @__PURE__ */ new Map();
-  const highlighted = highlightCode(fileContent, path39);
+  const highlighted = highlightCode(fileContent, path40);
   for (let i = 0; i < highlighted.length; i++) {
     lookup.set(i + 1, highlighted[i]);
   }
@@ -14319,11 +14347,11 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
       }
       continue;
     }
-    const path39 = tabParts[1];
-    if (!path39) continue;
+    const path40 = tabParts[1];
+    if (!path40) continue;
     const code = rawStatus[0];
     changes.push({
-      path: path39,
+      path: path40,
       status: rawStatus,
       isNew: code === "A",
       isDeleted: code === "D"
@@ -14358,9 +14386,9 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
   }
   return Array.from(byPath.values());
 }
-async function readGitFileContentAtRef(cwd, ref, path39) {
+async function readGitFileContentAtRef(cwd, ref, path40) {
   try {
-    const { stdout } = await runGitCommand(["show", `${ref}:${path39}`], {
+    const { stdout } = await runGitCommand(["show", `${ref}:${path40}`], {
       cwd,
       env: READ_ONLY_GIT_ENV2
     });
@@ -14421,21 +14449,21 @@ async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
     const additionsField = parts[0] ?? "";
     const deletionsField = parts[1] ?? "";
     const rawPath = parts.slice(2).join("	");
-    const path39 = normalizeNumstatPath(rawPath);
-    if (!path39) {
+    const path40 = normalizeNumstatPath(rawPath);
+    if (!path40) {
       continue;
     }
     if (additionsField === "-" || deletionsField === "-") {
-      stats.set(path39, { additions: 0, deletions: 0, isBinary: true });
+      stats.set(path40, { additions: 0, deletions: 0, isBinary: true });
       continue;
     }
     const additions = Number.parseInt(additionsField, 10);
     const deletions = Number.parseInt(deletionsField, 10);
     if (Number.isNaN(additions) || Number.isNaN(deletions)) {
-      stats.set(path39, null);
+      stats.set(path40, null);
       continue;
     }
-    stats.set(path39, { additions, deletions, isBinary: false });
+    stats.set(path40, { additions, deletions, isBinary: false });
   }
   return stats;
 }
@@ -15127,10 +15155,10 @@ async function listUncommittedFiles(cwd) {
         if (dest) results.push({ path: dest, changeType: code });
         continue;
       }
-      const path39 = parts[1];
-      if (!path39) continue;
+      const path40 = parts[1];
+      if (!path40) continue;
       if (code === "A" || code === "M" || code === "D") {
-        results.push({ path: path39, changeType: code });
+        results.push({ path: path40, changeType: code });
       }
     }
   } catch {
@@ -19959,6 +19987,7 @@ var ClaudeAgentClient = class {
       runtimeSettings: this.runtimeSettings,
       launchEnv: launchContext?.env,
       chromeEnabled: launchContext?.chromeEnabled,
+      playwrightEnabled: launchContext?.playwrightEnabled,
       logger: this.logger,
       queryFactory: this.queryFactory
     });
@@ -19977,6 +20006,7 @@ var ClaudeAgentClient = class {
       handle,
       launchEnv: launchContext?.env,
       chromeEnabled: launchContext?.chromeEnabled,
+      playwrightEnabled: launchContext?.playwrightEnabled,
       logger: this.logger,
       queryFactory: this.queryFactory
     });
@@ -20291,6 +20321,7 @@ var ClaudeAgentSession = class {
     this.config = config;
     this.launchEnv = options.launchEnv;
     this.chromeEnabled = options.chromeEnabled ?? true;
+    this.playwrightEnabled = options.playwrightEnabled ?? true;
     this.defaults = options.defaults;
     this.runtimeSettings = options.runtimeSettings;
     this.logger = options.logger;
@@ -21054,7 +21085,8 @@ var ClaudeAgentSession = class {
     } else {
       const homeMcps = loadHomeMcpServers(this.logger);
       if (homeMcps) {
-        base.mcpServers = this.normalizeMcpServers(homeMcps);
+        const filtered = this.playwrightEnabled ? homeMcps : Object.fromEntries(Object.entries(homeMcps).filter(([k]) => k !== "playwright"));
+        base.mcpServers = this.normalizeMcpServers(filtered);
       }
     }
     if (this.config.model) {
@@ -22192,6 +22224,12 @@ ${error.stack ?? ""}` : JSON.stringify(error);
   buildStructuredToolResult(server, tool4, output, input) {
     const normalizedServer = server.toLowerCase();
     const normalizedTool = tool4.toLowerCase();
+    if (normalizedTool === "mcp__playwright__browser_take_screenshot" || normalizedTool === "browser_take_screenshot") {
+      const imageOutput = this.tryInlinePlaywrightScreenshot(output, input);
+      if (imageOutput) {
+        return { output: imageOutput };
+      }
+    }
     if (normalizedServer.includes("bash") || normalizedServer.includes("shell") || normalizedServer.includes("command") || normalizedTool.includes("bash") || normalizedTool.includes("shell") || normalizedTool.includes("command") || input && (typeof input.command === "string" || Array.isArray(input.command))) {
       const command = this.extractCommandText(input ?? {}) ?? "command";
       return {
@@ -22233,8 +22271,46 @@ ${error.stack ?? ""}` : JSON.stringify(error);
         };
       }
     }
+    if (normalizedServer === "playwright" && normalizedTool === "browser_take_screenshot") {
+      const imageDetail = this.tryReadPlaywrightScreenshot(output, input);
+      if (imageDetail) return imageDetail;
+    }
     return void 0;
   }
+  /**
+   * Playwright MCP's `browser_take_screenshot` saves the image to a local file
+   * and returns a markdown link (`[Screenshot of viewport](./file.png)`).
+   * Extract the path, resolve it against the agent CWD, read the bytes, and
+   * return an image ToolCallDetail so the client renders it inline.
+   */
+  tryReadPlaywrightScreenshot(output, input) {
+    let filePath;
+    if (input && typeof input.filename === "string") {
+      filePath = input.filename;
+    }
+    if (!filePath) {
+      const match = output.match(/\[Screenshot[^\]]*\]\(([^)]+)\)/i);
+      if (match?.[1]) {
+        filePath = match[1];
+      }
+    }
+    if (!filePath) return void 0;
+    const cwd = this.config.cwd;
+    if (!cwd) return void 0;
+    const abs = path9.isAbsolute(filePath) ? filePath : path9.resolve(cwd, filePath);
+    try {
+      const buf = fs4.readFileSync(abs);
+      const ext = path9.extname(abs).toLowerCase();
+      const mime = ext === ".jpeg" || ext === ".jpg" ? "image/jpeg" : "image/png";
+      return {
+        type: "image",
+        toolName: "mcp__playwright__browser_take_screenshot",
+        images: [{ mimeType: mime, data: buf.toString("base64") }]
+      };
+    } catch {
+      return void 0;
+    }
+  }
   mapPartialEvent(event, options) {
     if (event.type === "content_block_start") {
       const block = isClaudeContentChunk2(event.content_block) ? event.content_block : null;
@@ -22407,6 +22483,44 @@ ${error.stack ?? ""}` : JSON.stringify(error);
     }
     return input;
   }
+  /**
+   * Playwright MCP returns `### Result\n- [Screenshot of viewport](./foo.png)`
+   * and writes the file to disk instead of inlining the image. Resolve that
+   * path against the agent cwd and turn the file into an Anthropic-style
+   * image content block array, so downstream `extractImageToolDetail`
+   * promotes the tool call to a renderable `image` detail.
+   *
+   * Returns `null` when the path cannot be resolved/read safely; the caller
+   * then falls back to the default text output behavior.
+   */
+  tryInlinePlaywrightScreenshot(output, input) {
+    const cwd = this.config.cwd;
+    if (!cwd) return null;
+    let relPath;
+    if (input && typeof input.filename === "string" && input.filename.length > 0) {
+      relPath = input.filename;
+    } else {
+      const match = output.match(/\[Screenshot[^\]]*\]\(([^)]+)\)/);
+      if (match?.[1]) {
+        relPath = match[1];
+      }
+    }
+    if (!relPath) return null;
+    const resolved = path9.resolve(cwd, relPath);
+    const cwdReal = path9.resolve(cwd);
+    if (!resolved.startsWith(cwdReal + path9.sep) && resolved !== cwdReal) {
+      return null;
+    }
+    let buf;
+    try {
+      buf = fs4.readFileSync(resolved);
+    } catch {
+      return null;
+    }
+    const ext = path9.extname(resolved).toLowerCase();
+    const mimeType = ext === ".jpg" || ext === ".jpeg" ? "image/jpeg" : ext === ".webp" ? "image/webp" : ext === ".gif" ? "image/gif" : "image/png";
+    return [{ type: "image", mimeType, data: buf.toString("base64") }];
+  }
   areToolInputsEqual(left, right) {
     if (!left) {
       return false;
@@ -23349,14 +23463,14 @@ function codexApplyPatchToUnifiedDiff(text) {
   for (const line of lines) {
     const directive = parseCodexApplyPatchDirective(line);
     if (directive) {
-      const path39 = normalizeDiffHeaderPath(directive.path);
-      if (path39.length > 0) {
+      const path40 = normalizeDiffHeaderPath(directive.path);
+      if (path40.length > 0) {
         if (output.length > 0 && output[output.length - 1] !== "") {
           output.push("");
         }
-        const left = directive.kind === "add" ? "/dev/null" : `a/${path39}`;
-        const right = directive.kind === "delete" ? "/dev/null" : `b/${path39}`;
-        output.push(`diff --git a/${path39} b/${path39}`);
+        const left = directive.kind === "add" ? "/dev/null" : `a/${path40}`;
+        const right = directive.kind === "delete" ? "/dev/null" : `b/${path40}`;
+        output.push(`diff --git a/${path40} b/${path40}`);
         output.push(`--- ${left}`);
         output.push(`+++ ${right}`);
         sawDiffContent = true;
@@ -23426,9 +23540,9 @@ function asEditTextFields(text) {
 function normalizeRolloutEditInput(input) {
   if (typeof input === "string") {
     const textFields2 = asEditTextFields(input);
-    const path39 = extractPatchPrimaryFilePath(input);
+    const path40 = extractPatchPrimaryFilePath(input);
     return {
-      ...path39 ? { path: path39 } : {},
+      ...path40 ? { path: path40 } : {},
       ...textFields2.unifiedDiff ? { patch: textFields2.unifiedDiff } : {},
       ...textFields2.newString ? { content: textFields2.newString } : {}
     };
@@ -23576,12 +23690,12 @@ function parseFileChangeDiff(entry) {
   ]);
 }
 function toFileChangeEntry(entry, options, fallbackPath) {
-  const path39 = parseFileChangePath(entry, options, fallbackPath);
-  if (!path39) {
+  const path40 = parseFileChangePath(entry, options, fallbackPath);
+  if (!path40) {
     return null;
   }
   return {
-    path: path39,
+    path: path40,
     kind: parseFileChangeKind(entry),
     diff: parseFileChangeDiff(entry)
   };
@@ -23603,12 +23717,12 @@ function parseFileChangeEntries(changes, options) {
   if (singleEntry) {
     return [singleEntry];
   }
-  return Object.entries(changes).map(([path39, value]) => {
+  return Object.entries(changes).map(([path40, value]) => {
     if (isRecord2(value)) {
-      return toFileChangeEntry(value, options, path39);
+      return toFileChangeEntry(value, options, path40);
     }
     if (typeof value === "string") {
-      const normalizedPath = normalizeCodexFilePath(path39.trim(), options?.cwd);
+      const normalizedPath = normalizeCodexFilePath(path40.trim(), options?.cwd);
       if (!normalizedPath) {
         return null;
       }
@@ -24353,16 +24467,16 @@ function isObjectSchemaNode(schema) {
   const type = schema.type;
   return isSchemaRecord(schema.properties) || type === "object" || Array.isArray(type) && type.includes("object");
 }
-function normalizeCodexOutputSchemaNode(schema, path39) {
+function normalizeCodexOutputSchemaNode(schema, path40) {
   if (Array.isArray(schema)) {
-    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path39}[${index}]`));
+    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path40}[${index}]`));
   }
   if (!isSchemaRecord(schema)) {
     return schema;
   }
   const normalized = {};
   for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path39}.${key}`);
+    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path40}.${key}`);
   }
   if (!isObjectSchemaNode(normalized)) {
     return normalized;
@@ -24371,7 +24485,7 @@ function normalizeCodexOutputSchemaNode(schema, path39) {
     normalized.additionalProperties = false;
   } else if (normalized.additionalProperties !== false) {
     throw new Error(
-      `Codex structured outputs require ${path39} to set additionalProperties to false for object schemas.`
+      `Codex structured outputs require ${path40} to set additionalProperties to false for object schemas.`
     );
   }
   const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
@@ -25135,8 +25249,8 @@ function parseCodexPatchChanges(changes) {
       }
     ];
   }
-  return Object.entries(recordChanges).map(([path39, value]) => {
-    const normalizedPath = path39.trim();
+  return Object.entries(recordChanges).map(([path40, value]) => {
+    const normalizedPath = path40.trim();
     if (!normalizedPath) {
       return null;
     }
@@ -33012,6 +33126,428 @@ function forkSession(input) {
   };
 }
 
+// ../server/src/server/agent/providers/claude-draft-commands.ts
+import fs9 from "node:fs/promises";
+import os7 from "node:os";
+import path15 from "node:path";
+
+// ../server/src/server/skills/scanner.ts
+import fs8 from "node:fs/promises";
+import os6 from "node:os";
+import path14 from "node:path";
+var NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/i;
+function homeDir() {
+  return process.env.HOME || os6.homedir();
+}
+function codexHomeDir() {
+  return process.env.CODEX_HOME || path14.join(homeDir(), ".codex");
+}
+function resolveScopeDir(provider, scope, workspaceRoot) {
+  if (scope === "codex-prompts") {
+    if (provider !== "codex") {
+      throw new Error(`Scope "codex-prompts" is only valid for provider "codex"`);
+    }
+    return path14.join(codexHomeDir(), "prompts");
+  }
+  if (scope === "project") {
+    if (!workspaceRoot) {
+      throw new Error(`workspaceRoot is required for scope "project"`);
+    }
+    const dotDir = provider === "claude" ? ".claude" : ".codex";
+    return path14.join(workspaceRoot, dotDir, "skills");
+  }
+  if (provider === "claude") {
+    return path14.join(homeDir(), ".claude", "skills");
+  }
+  return path14.join(codexHomeDir(), "skills");
+}
+function allowedRoots(workspaceRoot) {
+  const roots = [
+    path14.join(homeDir(), ".claude", "skills"),
+    path14.join(codexHomeDir(), "skills"),
+    path14.join(codexHomeDir(), "prompts")
+  ];
+  if (workspaceRoot) {
+    roots.push(path14.join(workspaceRoot, ".claude", "skills"));
+    roots.push(path14.join(workspaceRoot, ".codex", "skills"));
+  }
+  return roots.map((r) => path14.resolve(r));
+}
+function isInsideAllowedRoot(absPath, workspaceRoot) {
+  const resolved = path14.resolve(absPath);
+  for (const root of allowedRoots(workspaceRoot)) {
+    const rel = path14.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel)) {
+      return true;
+    }
+  }
+  return false;
+}
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseSkillFile(text) {
+  const match = FRONTMATTER_RE.exec(text);
+  if (!match) {
+    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
+  }
+  const yamlBlock = match[1] ?? "";
+  const body = match[2] ?? "";
+  return {
+    rawFrontmatterLines: yamlBlock.split(/\r?\n/),
+    body,
+    hadFrontmatter: true
+  };
+}
+function readDescription(text) {
+  const parsed = parseSkillFile(text);
+  if (!parsed.hadFrontmatter) return "";
+  for (const line of parsed.rawFrontmatterLines) {
+    const m = /^description\s*:\s*(.*)$/.exec(line);
+    if (m) {
+      const value = (m[1] ?? "").trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+      }
+      return value;
+    }
+  }
+  return "";
+}
+function findOwnedSpans(lines) {
+  const spans = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    const value = keyMatch[2];
+    if (key !== "description" && key !== "argument-hint" && key !== "allowed-tools") {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    if (value === "") {
+      while (end < lines.length) {
+        const next = lines[end] ?? "";
+        if (/^\s+-\s+/.test(next) || /^\s*$/.test(next)) {
+          end++;
+        } else {
+          break;
+        }
+      }
+    }
+    spans.push({ key, startLine: i, endLine: end });
+    i = end;
+  }
+  return spans;
+}
+function emitFrontmatterValue(key, value) {
+  if (key === "allowed-tools") {
+    if (!Array.isArray(value) || value.length === 0) return [];
+    return [`allowed-tools:`, ...value.map((v) => `  - ${v}`)];
+  }
+  const text = typeof value === "string" ? value : "";
+  if (text.length === 0) return [];
+  const needsQuote = /[:#\n]/.test(text) || text.startsWith(" ") || text.endsWith(" ");
+  const formatted = needsQuote ? `"${text.replace(/"/g, '\\"')}"` : text;
+  return [`${key}: ${formatted}`];
+}
+function rewriteFrontmatter(originalLines, next) {
+  const spans = findOwnedSpans(originalLines);
+  const ownedKeys = new Set(spans.map((s) => s.key));
+  const replacements = /* @__PURE__ */ new Map();
+  if (next.description !== void 0) {
+    replacements.set("description", emitFrontmatterValue("description", next.description));
+  }
+  if (next.argumentHint !== void 0) {
+    replacements.set("argument-hint", emitFrontmatterValue("argument-hint", next.argumentHint));
+  }
+  if (next.allowedTools !== void 0) {
+    replacements.set("allowed-tools", emitFrontmatterValue("allowed-tools", next.allowedTools));
+  }
+  const out = [];
+  let i = 0;
+  while (i < originalLines.length) {
+    const span = spans.find((s) => s.startLine === i);
+    if (span) {
+      if (replacements.has(span.key)) {
+        out.push(...replacements.get(span.key) ?? []);
+      } else {
+        for (let j = span.startLine; j < span.endLine; j++) {
+          out.push(originalLines[j] ?? "");
+        }
+      }
+      i = span.endLine;
+      continue;
+    }
+    out.push(originalLines[i] ?? "");
+    i++;
+  }
+  for (const key of ["description", "argument-hint", "allowed-tools"]) {
+    if (replacements.has(key) && !ownedKeys.has(key)) {
+      out.push(...replacements.get(key) ?? []);
+    }
+  }
+  return out;
+}
+async function listSkills(args) {
+  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
+  let entries;
+  try {
+    entries = await fs8.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  if (args.scope === "codex-prompts") {
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".md")) continue;
+      const name = entry.name.slice(0, -".md".length);
+      if (!name) continue;
+      const fullPath = path14.join(dir, entry.name);
+      const stat10 = await safeStat(fullPath);
+      if (!stat10) continue;
+      const description = await readDescriptionSafely(fullPath);
+      results.push({
+        id: `${args.provider}:${args.scope}:${name}`,
+        provider: args.provider,
+        scope: args.scope,
+        name,
+        path: fullPath,
+        description,
+        modifiedAt: stat10.mtime.toISOString(),
+        size: stat10.size
+      });
+    }
+  } else {
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      const skillDir = path14.join(dir, entry.name);
+      const skillPath = path14.join(skillDir, "SKILL.md");
+      const stat10 = await safeStat(skillPath);
+      if (!stat10) continue;
+      const description = await readDescriptionSafely(skillPath);
+      results.push({
+        id: `${args.provider}:${args.scope}:${entry.name}`,
+        provider: args.provider,
+        scope: args.scope,
+        name: entry.name,
+        path: skillPath,
+        description,
+        modifiedAt: stat10.mtime.toISOString(),
+        size: stat10.size
+      });
+    }
+  }
+  results.sort((a, b) => a.name.localeCompare(b.name));
+  return results;
+}
+async function safeStat(filePath) {
+  try {
+    const s = await fs8.stat(filePath);
+    return { mtime: s.mtime, size: s.size };
+  } catch {
+    return null;
+  }
+}
+async function readDescriptionSafely(filePath) {
+  try {
+    const text = await fs8.readFile(filePath, "utf8");
+    return readDescription(text);
+  } catch {
+    return "";
+  }
+}
+async function createSkill(args) {
+  if (!NAME_REGEX.test(args.name)) {
+    throw new Error(
+      `Invalid skill name "${args.name}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
+    throw new Error(`Skill name must not contain path separators or "..".`);
+  }
+  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
+  await fs8.mkdir(dir, { recursive: true });
+  if (args.scope === "codex-prompts") {
+    const filePath2 = path14.join(dir, `${args.name}.md`);
+    try {
+      await fs8.access(filePath2);
+      throw new Error(`A prompt named "${args.name}" already exists at ${filePath2}`);
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+        throw err;
+      }
+      if (err instanceof Error && err.message.includes("already exists")) {
+        throw err;
+      }
+    }
+    const initial2 = buildStarterPrompt(args.name);
+    await fs8.writeFile(filePath2, initial2, "utf8");
+    return { path: filePath2 };
+  }
+  const skillDir = path14.join(dir, args.name);
+  let dirExists = false;
+  try {
+    const stat10 = await fs8.stat(skillDir);
+    dirExists = stat10.isDirectory();
+  } catch {
+    dirExists = false;
+  }
+  if (dirExists) {
+    throw new Error(`A skill named "${args.name}" already exists at ${skillDir}`);
+  }
+  await fs8.mkdir(skillDir, { recursive: true });
+  const filePath = path14.join(skillDir, "SKILL.md");
+  const initial = buildStarterSkill(args.name);
+  await fs8.writeFile(filePath, initial, "utf8");
+  return { path: filePath };
+}
+function buildStarterSkill(name) {
+  return `---
+name: ${name}
+description: ""
+---
+
+# ${name}
+
+Describe when this skill should be used and what it does. The body of this
+file is loaded into the agent's context when the skill is invoked.
+`;
+}
+function buildStarterPrompt(name) {
+  return `---
+description: ""
+argument-hint: ""
+---
+
+# ${name}
+
+Body of the prompt. Use \`$1\`, \`$2\`, ... or \`$ARGUMENTS\` for parameter expansion.
+`;
+}
+async function writeSkillFrontmatter(args, workspaceRoot) {
+  if (!path14.isAbsolute(args.path)) {
+    throw new Error(`writeSkillFrontmatter expects an absolute path; got "${args.path}"`);
+  }
+  if (!isInsideAllowedRoot(args.path, workspaceRoot)) {
+    throw new Error(`Path "${args.path}" is not inside an allowlisted skill root`);
+  }
+  let original;
+  try {
+    original = await fs8.readFile(args.path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Failed to read skill file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const parsed = parseSkillFile(original);
+  const newLines = rewriteFrontmatter(parsed.rawFrontmatterLines, args.frontmatter);
+  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
+  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
+${parsed.body}` : `${nextFrontmatter}
+
+${original}`;
+  await fs8.writeFile(args.path, nextContent, "utf8");
+}
+
+// ../server/src/server/agent/providers/claude-draft-commands.ts
+async function enumerateClaudeDraftCommands(cwd) {
+  const byName = /* @__PURE__ */ new Map();
+  const [global, project, plugin] = await Promise.all([
+    listSkills({ provider: "claude", scope: "global" }).catch(() => []),
+    listSkills({ provider: "claude", scope: "project", workspaceRoot: cwd }).catch(() => []),
+    listClaudePluginSkills().catch(() => [])
+  ]);
+  for (const entry of [...project, ...global, ...plugin]) {
+    if (!byName.has(entry.name)) {
+      byName.set(entry.name, {
+        name: entry.name,
+        description: entry.description,
+        argumentHint: ""
+      });
+    }
+  }
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+async function listClaudePluginSkills() {
+  const pluginsRoot = path15.join(os7.homedir(), ".claude", "plugins");
+  const installedPath = path15.join(pluginsRoot, "installed_plugins.json");
+  let raw;
+  try {
+    raw = await fs9.readFile(installedPath, "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const plugins = parsed.plugins ?? {};
+  for (const [key, installs] of Object.entries(plugins)) {
+    if (!Array.isArray(installs) || installs.length === 0) continue;
+    const prefix = key.split("@")[0];
+    if (!prefix) continue;
+    const install = installs[installs.length - 1];
+    const installPath = install?.installPath;
+    if (!installPath) continue;
+    const skills = await readSkillFolder(path15.join(installPath, "skills"));
+    for (const skill of skills) {
+      out.push({
+        name: `${prefix}:${skill.name}`,
+        description: skill.description
+      });
+    }
+  }
+  return out;
+}
+async function readSkillFolder(dir) {
+  let entries;
+  try {
+    entries = await fs9.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const skillPath = path15.join(dir, entry.name, "SKILL.md");
+    const description = await readDescriptionField(skillPath);
+    if (description === null) continue;
+    out.push({ name: entry.name, description });
+  }
+  return out;
+}
+var FRONTMATTER_RE2 = /^---\r?\n([\s\S]*?)\r?\n---/;
+async function readDescriptionField(filePath) {
+  let text;
+  try {
+    text = await fs9.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const match = FRONTMATTER_RE2.exec(text);
+  if (!match) return "";
+  const yaml = match[1] ?? "";
+  for (const line of yaml.split(/\r?\n/)) {
+    const m = /^description\s*:\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = (m[1] ?? "").trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return "";
+}
+
 // ../server/src/server/agent/handoff-mcp.ts
 import { createSdkMcpServer, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
 import { z as z33 } from "zod";
@@ -33066,8 +33602,8 @@ function buildZodValidator(schema, schemaName) {
         return { ok: true, value: result.data };
       }
       const errors = result.error.issues.map((issue) => {
-        const path39 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `${path39}: ${issue.message}`;
+        const path40 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path40}: ${issue.message}`;
       });
       return { ok: false, errors };
     }
@@ -33085,9 +33621,9 @@ function buildJsonSchemaValidator(schema) {
         return { ok: true, value };
       }
       const errors = (validate.errors ?? []).map((error) => {
-        const path39 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
+        const path40 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
         const message = error.message ?? "is invalid";
-        return `${path39}: ${message}`;
+        return `${path40}: ${message}`;
       });
       return { ok: false, errors };
     }
@@ -33494,8 +34030,8 @@ function scheduleAgentMetadataGeneration(options) {
 }
 
 // ../server/src/server/agent/write-plan-tool.ts
-import fs8 from "node:fs";
-import path14 from "node:path";
+import fs10 from "node:fs";
+import path16 from "node:path";
 import { tool } from "@anthropic-ai/claude-agent-sdk";
 import { z as z32 } from "zod";
 var TODO_STATUSES = ["pending", "in_progress", "needs_help", "completed"];
@@ -33545,9 +34081,9 @@ function buildWritePlanTool(callerAgentId, options) {
           ]
         };
       }
-      const plansDir = path14.join(agent.cwd, ".plans");
+      const plansDir = path16.join(agent.cwd, ".plans");
       try {
-        fs8.mkdirSync(plansDir, { recursive: true });
+        fs10.mkdirSync(plansDir, { recursive: true });
       } catch (err) {
         log.error({ err, plansDir }, "write_plan: mkdir failed");
         return {
@@ -33561,9 +34097,9 @@ function buildWritePlanTool(callerAgentId, options) {
         };
       }
       const targetPath = resolvePlanFilename({
-        originalPath: path14.join(plansDir, `${slug}.md`),
+        originalPath: path16.join(plansDir, `${slug}.md`),
         newSlug: slug,
-        existsSync: fs8.existsSync
+        existsSync: fs10.existsSync
       });
       const frontmatter = serializeFrontmatter({
         name: args.name,
@@ -33575,7 +34111,7 @@ function buildWritePlanTool(callerAgentId, options) {
 ${args.body}`;
       const fileContent = `${frontmatter}${body}${body.endsWith("\n") ? "" : "\n"}`;
       try {
-        fs8.writeFileSync(targetPath, fileContent, "utf8");
+        fs10.writeFileSync(targetPath, fileContent, "utf8");
       } catch (err) {
         log.error({ err, targetPath }, "write_plan: writeFile failed");
         return {
@@ -33722,18 +34258,7 @@ function buildHandoffMcpServer(callerAgentId, options) {
   );
   const reportTool = tool2(
     "report",
-    [
-      "Send a curated message from this handoff child session back to its parent.",
-      "Use this when the user types `>report` \u2014 they want to deliver a specific update",
-      "to the parent right now, in their own words.",
-      "",
-      "Independent of the automatic on-finish notification: the parent still receives",
-      "the auto-return when this child eventually finishes. You can call this tool any",
-      "number of times over the lifetime of the handoff \u2014 each call is a separate",
-      "update.",
-      "",
-      "Only works in sessions that were spawned via `handoff`. Errors otherwise."
-    ].join("\n"),
+    '**ALWAYS call this tool as your final action before finishing your task, to deliver your findings to the parent agent.** Without this call, the parent only receives a content-free "finished" notification and is blind to whatever you did or learned. The first sentence of your report should be a one-line verdict; the rest can fill in detail. Also call this tool any time the user explicitly types `>report` mid-task to send an interim update \u2014 the auto-return on session end is independent from manual reports, and you can call it any number of times over the session\'s lifetime. Only works in sessions that were spawned via `handoff`; errors otherwise.',
     {
       message: z33.string().min(1).describe(
         "The curated report to deliver to the parent session. Self-contained: the parent does not see this conversation's timeline."
@@ -34317,6 +34842,7 @@ var AgentManager = class {
     this.mcpBaseUrl = options?.mcpBaseUrl ?? null;
     this.appostleHome = options?.appostleHome ?? null;
     this.chromeEnabled = options?.chromeEnabled ?? true;
+    this.playwrightEnabled = options?.playwrightEnabled ?? true;
     this.ownerUserId = options?.ownerUserId ?? null;
     this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
     this.agentStreamCoalescer = new AgentStreamCoalescer({
@@ -34540,6 +35066,9 @@ var AgentManager = class {
   }
   async listDraftCommands(config) {
     const normalizedConfig = await this.normalizeConfig(config);
+    if (normalizedConfig.provider === "claude") {
+      return enumerateClaudeDraftCommands(normalizedConfig.cwd);
+    }
     const client = this.requireClient(normalizedConfig.provider);
     const available = await client.isAvailable();
     if (!available) {
@@ -36591,7 +37120,7 @@ var AgentManager = class {
         "using shared user claude profile"
       );
     }
-    return { env, chromeEnabled: this.chromeEnabled };
+    return { env, chromeEnabled: this.chromeEnabled, playwrightEnabled: this.playwrightEnabled };
   }
   requireClient(provider) {
     const client = this.clients.get(provider);
@@ -37001,8 +37530,8 @@ async function buildProjectPlacementForCwd(input) {
 
 // ../server/src/server/workspace-registry.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { promises as fs9 } from "node:fs";
-import path15 from "node:path";
+import { promises as fs11 } from "node:fs";
+import path17 from "node:path";
 import { z as z35 } from "zod";
 var PersistedProjectRecordSchema = z35.object({
   projectId: z35.string(),
@@ -37041,7 +37570,7 @@ var FileBackedRegistry = class {
   }
   async existsOnDisk() {
     try {
-      await fs9.access(this.filePath);
+      await fs11.access(this.filePath);
       return true;
     } catch {
       return false;
@@ -37088,7 +37617,7 @@ var FileBackedRegistry = class {
     }
     this.cache.clear();
     try {
-      const raw = await fs9.readFile(this.filePath, "utf8");
+      const raw = await fs11.readFile(this.filePath, "utf8");
       const parsed = z35.array(this.schema).parse(JSON.parse(raw));
       for (const record of parsed) {
         this.cache.set(this.getId(record), record);
@@ -37103,10 +37632,10 @@ var FileBackedRegistry = class {
   }
   async persist() {
     const records = Array.from(this.cache.values());
-    await fs9.mkdir(path15.dirname(this.filePath), { recursive: true });
+    await fs11.mkdir(path17.dirname(this.filePath), { recursive: true });
     const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID9()}.tmp`;
-    await fs9.writeFile(tempPath, JSON.stringify(records, null, 2), "utf8");
-    await fs9.rename(tempPath, this.filePath);
+    await fs11.writeFile(tempPath, JSON.stringify(records, null, 2), "utf8");
+    await fs11.rename(tempPath, this.filePath);
   }
   async enqueuePersist() {
     const nextPersist = this.persistQueue.then(() => this.persist());
@@ -37213,8 +37742,8 @@ function isVoicePermissionAllowed(request) {
 }
 
 // ../server/src/server/file-explorer/service.ts
-import { promises as fs10 } from "fs";
-import path16 from "path";
+import { promises as fs12 } from "fs";
+import path18 from "path";
 
 // ../server/src/server/path-utils.ts
 import { homedir as homedir3 } from "node:os";
@@ -37261,14 +37790,14 @@ async function listDirectoryEntries({
   relativePath = "."
 }) {
   const directoryPath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs10.stat(directoryPath);
+  const stats = await fs12.stat(directoryPath);
   if (!stats.isDirectory()) {
     throw new Error("Requested path is not a directory");
   }
-  const dirents = await fs10.readdir(directoryPath, { withFileTypes: true });
+  const dirents = await fs12.readdir(directoryPath, { withFileTypes: true });
   const entriesWithNulls = await Promise.all(
     dirents.map(async (dirent) => {
-      const targetPath = path16.join(directoryPath, dirent.name);
+      const targetPath = path18.join(directoryPath, dirent.name);
       const kind = dirent.isDirectory() ? "directory" : "file";
       try {
         return await buildEntryPayload({
@@ -37303,18 +37832,18 @@ async function readExplorerFile({
   relativePath
 }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs10.stat(filePath);
+  const stats = await fs12.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   const basePayload = {
     path: normalizeRelativePath({ root, targetPath: filePath }),
     size: stats.size,
     modifiedAt: stats.mtime.toISOString()
   };
   if (ext in IMAGE_MIME_TYPES) {
-    const buffer2 = await fs10.readFile(filePath);
+    const buffer2 = await fs12.readFile(filePath);
     return {
       ...basePayload,
       kind: "image",
@@ -37323,7 +37852,7 @@ async function readExplorerFile({
       mimeType: IMAGE_MIME_TYPES[ext]
     };
   }
-  const buffer = await fs10.readFile(filePath);
+  const buffer = await fs12.readFile(filePath);
   if (isLikelyBinary(buffer)) {
     return {
       ...basePayload,
@@ -37345,34 +37874,34 @@ async function writeTextFile({
   relativePath,
   content
 }) {
-  const ext = path16.extname(relativePath).toLowerCase();
+  const ext = path18.extname(relativePath).toLowerCase();
   if (ext in IMAGE_MIME_TYPES) {
     throw new Error(`Refusing to write '${relativePath}': binary/image file`);
   }
   const filePath = await resolveScopedPath({ root, relativePath });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs10.writeFile(tempPath, content, "utf8");
-  await fs10.rename(tempPath, filePath);
+  await fs12.writeFile(tempPath, content, "utf8");
+  await fs12.rename(tempPath, filePath);
 }
 async function deleteFile({ root, relativePath }) {
-  const ext = path16.extname(relativePath).toLowerCase();
+  const ext = path18.extname(relativePath).toLowerCase();
   if (ext !== ".md") {
     throw new Error(`Refusing to delete '${relativePath}': only .md files allowed`);
   }
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs10.stat(filePath);
+  const stats = await fs12.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  await fs10.unlink(filePath);
+  await fs12.unlink(filePath);
 }
 async function deleteEntry({ root, relativePath }) {
   const entryPath = await resolveScopedPath({ root, relativePath });
-  await fs10.rm(entryPath, { recursive: true, force: false });
+  await fs12.rm(entryPath, { recursive: true, force: false });
 }
 async function createDirectory({ root, relativePath }) {
   const dirPath = await resolveScopedPath({ root, relativePath });
-  await fs10.mkdir(dirPath, { recursive: true });
+  await fs12.mkdir(dirPath, { recursive: true });
 }
 async function moveEntry({
   root,
@@ -37381,22 +37910,22 @@ async function moveEntry({
 }) {
   const src = await resolveScopedPath({ root, relativePath: sourcePath });
   const dest = await resolveScopedPath({ root, relativePath: destinationPath });
-  await fs10.rename(src, dest);
+  await fs12.rename(src, dest);
 }
 async function getDownloadableFileInfo({ root, relativePath }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs10.stat(filePath);
+  const stats = await fs12.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   let mimeType = "application/octet-stream";
   if (ext in IMAGE_MIME_TYPES) {
     mimeType = IMAGE_MIME_TYPES[ext] ?? mimeType;
   } else if (ext in FONT_MIME_TYPES) {
     mimeType = FONT_MIME_TYPES[ext] ?? mimeType;
   } else {
-    const handle = await fs10.open(filePath, "r");
+    const handle = await fs12.open(filePath, "r");
     const sample = Buffer.alloc(8192);
     try {
       const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
@@ -37411,23 +37940,23 @@ async function getDownloadableFileInfo({ root, relativePath }) {
   return {
     path: normalizeRelativePath({ root, targetPath: filePath }),
     absolutePath: filePath,
-    fileName: path16.basename(filePath),
+    fileName: path18.basename(filePath),
     mimeType,
     size: stats.size
   };
 }
 async function resolveScopedPath({ root, relativePath = "." }) {
-  const normalizedRoot = path16.resolve(root);
+  const normalizedRoot = path18.resolve(root);
   const requestedPath = resolvePathFromBase(normalizedRoot, relativePath);
-  const relative = path16.relative(normalizedRoot, requestedPath);
-  if (relative !== "" && (relative.startsWith("..") || path16.isAbsolute(relative))) {
+  const relative = path18.relative(normalizedRoot, requestedPath);
+  if (relative !== "" && (relative.startsWith("..") || path18.isAbsolute(relative))) {
     throw new Error("Access outside of workspace is not allowed");
   }
-  const realRoot = await fs10.realpath(normalizedRoot);
+  const realRoot = await fs12.realpath(normalizedRoot);
   try {
-    const realPath = await fs10.realpath(requestedPath);
-    const realRelative = path16.relative(realRoot, realPath);
-    if (realRelative !== "" && (realRelative.startsWith("..") || path16.isAbsolute(realRelative))) {
+    const realPath = await fs12.realpath(requestedPath);
+    const realRelative = path18.relative(realRoot, realPath);
+    if (realRelative !== "" && (realRelative.startsWith("..") || path18.isAbsolute(realRelative))) {
       throw new Error("Access outside of workspace is not allowed");
     }
     return requestedPath;
@@ -37444,7 +37973,7 @@ async function buildEntryPayload({
   name,
   kind
 }) {
-  const stats = await fs10.stat(targetPath);
+  const stats = await fs12.stat(targetPath);
   return {
     name,
     path: normalizeRelativePath({ root, targetPath }),
@@ -37458,10 +37987,10 @@ function isMissingEntryError(error) {
   return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
 }
 function normalizeRelativePath({ root, targetPath }) {
-  const normalizedRoot = path16.resolve(root);
-  const normalizedTarget = path16.resolve(targetPath);
-  const relative = path16.relative(normalizedRoot, normalizedTarget);
-  return relative === "" ? "." : relative.split(path16.sep).join("/");
+  const normalizedRoot = path18.resolve(root);
+  const normalizedTarget = path18.resolve(targetPath);
+  const relative = path18.relative(normalizedRoot, normalizedTarget);
+  return relative === "" ? "." : relative.split(path18.sep).join("/");
 }
 function textMimeTypeForExtension(ext) {
   return TEXT_MIME_TYPES[ext] ?? DEFAULT_TEXT_MIME_TYPE;
@@ -37814,345 +38343,21 @@ async function getProjectIcon(projectDir) {
 }
 
 // ../server/src/utils/path.ts
-import os6 from "os";
-function expandTilde(path39) {
-  if (path39.startsWith("~/")) {
-    const homeDir3 = process.env.HOME || os6.homedir();
-    return path39.replace("~", homeDir3);
+import os8 from "os";
+function expandTilde(path40) {
+  if (path40.startsWith("~/")) {
+    const homeDir3 = process.env.HOME || os8.homedir();
+    return path40.replace("~", homeDir3);
   }
-  if (path39 === "~") {
-    return process.env.HOME || os6.homedir();
+  if (path40 === "~") {
+    return process.env.HOME || os8.homedir();
   }
-  return path39;
-}
-
-// ../server/src/server/skills/scanner.ts
-import fs11 from "node:fs/promises";
-import os7 from "node:os";
-import path17 from "node:path";
-var NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/i;
-function homeDir() {
-  return process.env.HOME || os7.homedir();
-}
-function codexHomeDir() {
-  return process.env.CODEX_HOME || path17.join(homeDir(), ".codex");
-}
-function resolveScopeDir(provider, scope, workspaceRoot) {
-  if (scope === "codex-prompts") {
-    if (provider !== "codex") {
-      throw new Error(`Scope "codex-prompts" is only valid for provider "codex"`);
-    }
-    return path17.join(codexHomeDir(), "prompts");
-  }
-  if (scope === "project") {
-    if (!workspaceRoot) {
-      throw new Error(`workspaceRoot is required for scope "project"`);
-    }
-    const dotDir = provider === "claude" ? ".claude" : ".codex";
-    return path17.join(workspaceRoot, dotDir, "skills");
-  }
-  if (provider === "claude") {
-    return path17.join(homeDir(), ".claude", "skills");
-  }
-  return path17.join(codexHomeDir(), "skills");
-}
-function allowedRoots(workspaceRoot) {
-  const roots = [
-    path17.join(homeDir(), ".claude", "skills"),
-    path17.join(codexHomeDir(), "skills"),
-    path17.join(codexHomeDir(), "prompts")
-  ];
-  if (workspaceRoot) {
-    roots.push(path17.join(workspaceRoot, ".claude", "skills"));
-    roots.push(path17.join(workspaceRoot, ".codex", "skills"));
-  }
-  return roots.map((r) => path17.resolve(r));
-}
-function isInsideAllowedRoot(absPath, workspaceRoot) {
-  const resolved = path17.resolve(absPath);
-  for (const root of allowedRoots(workspaceRoot)) {
-    const rel = path17.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path17.isAbsolute(rel)) {
-      return true;
-    }
-  }
-  return false;
-}
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-function parseSkillFile(text) {
-  const match = FRONTMATTER_RE.exec(text);
-  if (!match) {
-    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
-  }
-  const yamlBlock = match[1] ?? "";
-  const body = match[2] ?? "";
-  return {
-    rawFrontmatterLines: yamlBlock.split(/\r?\n/),
-    body,
-    hadFrontmatter: true
-  };
-}
-function readDescription(text) {
-  const parsed = parseSkillFile(text);
-  if (!parsed.hadFrontmatter) return "";
-  for (const line of parsed.rawFrontmatterLines) {
-    const m = /^description\s*:\s*(.*)$/.exec(line);
-    if (m) {
-      const value = (m[1] ?? "").trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        return value.slice(1, -1);
-      }
-      return value;
-    }
-  }
-  return "";
-}
-function findOwnedSpans(lines) {
-  const spans = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
-    if (!keyMatch) {
-      i++;
-      continue;
-    }
-    const key = keyMatch[1];
-    const value = keyMatch[2];
-    if (key !== "description" && key !== "argument-hint" && key !== "allowed-tools") {
-      i++;
-      continue;
-    }
-    let end = i + 1;
-    if (value === "") {
-      while (end < lines.length) {
-        const next = lines[end] ?? "";
-        if (/^\s+-\s+/.test(next) || /^\s*$/.test(next)) {
-          end++;
-        } else {
-          break;
-        }
-      }
-    }
-    spans.push({ key, startLine: i, endLine: end });
-    i = end;
-  }
-  return spans;
-}
-function emitFrontmatterValue(key, value) {
-  if (key === "allowed-tools") {
-    if (!Array.isArray(value) || value.length === 0) return [];
-    return [`allowed-tools:`, ...value.map((v) => `  - ${v}`)];
-  }
-  const text = typeof value === "string" ? value : "";
-  if (text.length === 0) return [];
-  const needsQuote = /[:#\n]/.test(text) || text.startsWith(" ") || text.endsWith(" ");
-  const formatted = needsQuote ? `"${text.replace(/"/g, '\\"')}"` : text;
-  return [`${key}: ${formatted}`];
-}
-function rewriteFrontmatter(originalLines, next) {
-  const spans = findOwnedSpans(originalLines);
-  const ownedKeys = new Set(spans.map((s) => s.key));
-  const replacements = /* @__PURE__ */ new Map();
-  if (next.description !== void 0) {
-    replacements.set("description", emitFrontmatterValue("description", next.description));
-  }
-  if (next.argumentHint !== void 0) {
-    replacements.set("argument-hint", emitFrontmatterValue("argument-hint", next.argumentHint));
-  }
-  if (next.allowedTools !== void 0) {
-    replacements.set("allowed-tools", emitFrontmatterValue("allowed-tools", next.allowedTools));
-  }
-  const out = [];
-  let i = 0;
-  while (i < originalLines.length) {
-    const span = spans.find((s) => s.startLine === i);
-    if (span) {
-      if (replacements.has(span.key)) {
-        out.push(...replacements.get(span.key) ?? []);
-      } else {
-        for (let j = span.startLine; j < span.endLine; j++) {
-          out.push(originalLines[j] ?? "");
-        }
-      }
-      i = span.endLine;
-      continue;
-    }
-    out.push(originalLines[i] ?? "");
-    i++;
-  }
-  for (const key of ["description", "argument-hint", "allowed-tools"]) {
-    if (replacements.has(key) && !ownedKeys.has(key)) {
-      out.push(...replacements.get(key) ?? []);
-    }
-  }
-  return out;
-}
-async function listSkills(args) {
-  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
-  let entries;
-  try {
-    entries = await fs11.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const results = [];
-  if (args.scope === "codex-prompts") {
-    for (const entry of entries) {
-      if (!entry.isFile()) continue;
-      if (!entry.name.endsWith(".md")) continue;
-      const name = entry.name.slice(0, -".md".length);
-      if (!name) continue;
-      const fullPath = path17.join(dir, entry.name);
-      const stat10 = await safeStat(fullPath);
-      if (!stat10) continue;
-      const description = await readDescriptionSafely(fullPath);
-      results.push({
-        id: `${args.provider}:${args.scope}:${name}`,
-        provider: args.provider,
-        scope: args.scope,
-        name,
-        path: fullPath,
-        description,
-        modifiedAt: stat10.mtime.toISOString(),
-        size: stat10.size
-      });
-    }
-  } else {
-    for (const entry of entries) {
-      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-      const skillDir = path17.join(dir, entry.name);
-      const skillPath = path17.join(skillDir, "SKILL.md");
-      const stat10 = await safeStat(skillPath);
-      if (!stat10) continue;
-      const description = await readDescriptionSafely(skillPath);
-      results.push({
-        id: `${args.provider}:${args.scope}:${entry.name}`,
-        provider: args.provider,
-        scope: args.scope,
-        name: entry.name,
-        path: skillPath,
-        description,
-        modifiedAt: stat10.mtime.toISOString(),
-        size: stat10.size
-      });
-    }
-  }
-  results.sort((a, b) => a.name.localeCompare(b.name));
-  return results;
-}
-async function safeStat(filePath) {
-  try {
-    const s = await fs11.stat(filePath);
-    return { mtime: s.mtime, size: s.size };
-  } catch {
-    return null;
-  }
-}
-async function readDescriptionSafely(filePath) {
-  try {
-    const text = await fs11.readFile(filePath, "utf8");
-    return readDescription(text);
-  } catch {
-    return "";
-  }
-}
-async function createSkill(args) {
-  if (!NAME_REGEX.test(args.name)) {
-    throw new Error(
-      `Invalid skill name "${args.name}". Use letters, digits, dot, underscore, dash.`
-    );
-  }
-  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
-    throw new Error(`Skill name must not contain path separators or "..".`);
-  }
-  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
-  await fs11.mkdir(dir, { recursive: true });
-  if (args.scope === "codex-prompts") {
-    const filePath2 = path17.join(dir, `${args.name}.md`);
-    try {
-      await fs11.access(filePath2);
-      throw new Error(`A prompt named "${args.name}" already exists at ${filePath2}`);
-    } catch (err) {
-      if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
-        throw err;
-      }
-      if (err instanceof Error && err.message.includes("already exists")) {
-        throw err;
-      }
-    }
-    const initial2 = buildStarterPrompt(args.name);
-    await fs11.writeFile(filePath2, initial2, "utf8");
-    return { path: filePath2 };
-  }
-  const skillDir = path17.join(dir, args.name);
-  let dirExists = false;
-  try {
-    const stat10 = await fs11.stat(skillDir);
-    dirExists = stat10.isDirectory();
-  } catch {
-    dirExists = false;
-  }
-  if (dirExists) {
-    throw new Error(`A skill named "${args.name}" already exists at ${skillDir}`);
-  }
-  await fs11.mkdir(skillDir, { recursive: true });
-  const filePath = path17.join(skillDir, "SKILL.md");
-  const initial = buildStarterSkill(args.name);
-  await fs11.writeFile(filePath, initial, "utf8");
-  return { path: filePath };
-}
-function buildStarterSkill(name) {
-  return `---
-name: ${name}
-description: ""
----
-
-# ${name}
-
-Describe when this skill should be used and what it does. The body of this
-file is loaded into the agent's context when the skill is invoked.
-`;
-}
-function buildStarterPrompt(name) {
-  return `---
-description: ""
-argument-hint: ""
----
-
-# ${name}
-
-Body of the prompt. Use \`$1\`, \`$2\`, ... or \`$ARGUMENTS\` for parameter expansion.
-`;
-}
-async function writeSkillFrontmatter(args, workspaceRoot) {
-  if (!path17.isAbsolute(args.path)) {
-    throw new Error(`writeSkillFrontmatter expects an absolute path; got "${args.path}"`);
-  }
-  if (!isInsideAllowedRoot(args.path, workspaceRoot)) {
-    throw new Error(`Path "${args.path}" is not inside an allowlisted skill root`);
-  }
-  let original;
-  try {
-    original = await fs11.readFile(args.path, "utf8");
-  } catch (err) {
-    throw new Error(
-      `Failed to read skill file: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const parsed = parseSkillFile(original);
-  const newLines = rewriteFrontmatter(parsed.rawFrontmatterLines, args.frontmatter);
-  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
-  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
-${parsed.body}` : `${nextFrontmatter}
-
-${original}`;
-  await fs11.writeFile(args.path, nextContent, "utf8");
+  return path40;
 }
 
 // ../server/src/utils/directory-suggestions.ts
 import { readdir as readdir2, realpath, stat as stat4 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 var DEFAULT_LIMIT = 30;
 var MAX_LIMIT = 100;
 var DEFAULT_MAX_DEPTH = 6;
@@ -38238,7 +38443,7 @@ function normalizeLimit(limit) {
   return Math.max(1, Math.min(MAX_LIMIT, bounded));
 }
 async function searchWithinParentDirectory(input) {
-  const parentPath = path18.resolve(input.homeRoot, input.parentPart || ".");
+  const parentPath = path19.resolve(input.homeRoot, input.parentPart || ".");
   const parentRoot = await resolveDirectory(parentPath);
   if (!parentRoot || !isPathInsideRoot(input.homeRoot, parentRoot)) {
     return [];
@@ -38303,7 +38508,7 @@ async function searchAcrossHomeTree(input) {
   return dedupeAndSort(ranked).slice(0, input.limit);
 }
 async function searchWorkspaceWithinParentDirectory(input) {
-  const parentPath = path18.resolve(input.workspaceRoot, input.parentPart || ".");
+  const parentPath = path19.resolve(input.workspaceRoot, input.parentPart || ".");
   const parentRoot = await resolveDirectory(parentPath);
   if (!parentRoot || !isPathInsideRoot(input.workspaceRoot, parentRoot)) {
     return [];
@@ -38549,15 +38754,15 @@ function findSegmentMatchIndex(segments, predicate) {
   return -1;
 }
 function normalizeRelativePath2(homeRoot, absolutePath) {
-  const relative = path18.relative(homeRoot, absolutePath);
+  const relative = path19.relative(homeRoot, absolutePath);
   if (!relative) {
     return ".";
   }
-  return relative.split(path18.sep).join("/");
+  return relative.split(path19.sep).join("/");
 }
 function isPathInsideRoot(root, target) {
-  const relative = path18.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path18.isAbsolute(relative);
+  const relative = path19.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path19.isAbsolute(relative);
 }
 function normalizeQueryParts(query2, homeRoot) {
   const typedQuery = query2.trim().replace(/\\/g, "/");
@@ -38573,9 +38778,9 @@ function normalizeQueryParts(query2, homeRoot) {
       normalized = normalized.slice(1);
     }
   }
-  if (path18.isAbsolute(normalized)) {
+  if (path19.isAbsolute(normalized)) {
     isRooted = true;
-    const absolute = path18.resolve(normalized);
+    const absolute = path19.resolve(normalized);
     if (!isPathInsideRoot(homeRoot, absolute)) {
       return null;
     }
@@ -38614,8 +38819,8 @@ function normalizeQueryParts(query2, homeRoot) {
 }
 function normalizeWorkspaceQueryParts(query2, workspaceRoot) {
   let normalized = query2.trim().replace(/\\/g, "/");
-  if (path18.isAbsolute(normalized)) {
-    const absolute = path18.resolve(normalized);
+  if (path19.isAbsolute(normalized)) {
+    const absolute = path19.resolve(normalized);
     if (!isPathInsideRoot(workspaceRoot, absolute)) {
       return null;
     }
@@ -38641,7 +38846,7 @@ function normalizeWorkspaceQueryParts(query2, workspaceRoot) {
 }
 async function resolveDirectory(inputPath) {
   try {
-    const resolved = await realpath(path18.resolve(inputPath));
+    const resolved = await realpath(path19.resolve(inputPath));
     const stats = await stat4(resolved);
     if (!stats.isDirectory()) {
       return null;
@@ -38668,7 +38873,7 @@ async function listChildDirectories(input) {
     if (!dirent.isDirectory() && !dirent.isSymbolicLink()) {
       continue;
     }
-    const candidatePath = path18.join(input.directory, dirent.name);
+    const candidatePath = path19.join(input.directory, dirent.name);
     const absolutePath = await resolveDirectoryCandidate({
       candidatePath,
       dirent,
@@ -38705,7 +38910,7 @@ async function listWorkspaceChildEntries(input) {
     if (isIgnoredWorkspaceDirectoryName(dirent.name)) {
       continue;
     }
-    const candidatePath = path18.join(input.directory, dirent.name);
+    const candidatePath = path19.join(input.directory, dirent.name);
     const entry = await resolveWorkspaceCandidate({
       candidatePath,
       dirent,
@@ -38728,7 +38933,7 @@ async function listWorkspaceChildEntries(input) {
 }
 async function resolveDirectoryCandidate(input) {
   if (input.dirent.isDirectory()) {
-    const resolved2 = path18.resolve(input.candidatePath);
+    const resolved2 = path19.resolve(input.candidatePath);
     return isPathInsideRoot(input.homeRoot, resolved2) ? resolved2 : null;
   }
   const resolved = await resolveDirectory(input.candidatePath);
@@ -38739,14 +38944,14 @@ async function resolveDirectoryCandidate(input) {
 }
 async function resolveWorkspaceCandidate(input) {
   if (input.dirent.isDirectory()) {
-    const resolved = path18.resolve(input.candidatePath);
+    const resolved = path19.resolve(input.candidatePath);
     if (!isPathInsideRoot(input.workspaceRoot, resolved)) {
       return null;
     }
     return { absolutePath: resolved, kind: "directory" };
   }
   if (input.dirent.isFile()) {
-    const resolved = path18.resolve(input.candidatePath);
+    const resolved = path19.resolve(input.candidatePath);
     if (!isPathInsideRoot(input.workspaceRoot, resolved)) {
       return null;
     }
@@ -38826,7 +39031,7 @@ function pruneWorkspaceEntryListCache() {
 // ../server/src/utils/directory-listing.ts
 import { readdir as readdir3, stat as stat5, realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 var DEFAULT_LIMIT2 = 500;
 async function listDirectoryContents(options) {
   const includeFiles = options.includeFiles ?? false;
@@ -38837,7 +39042,7 @@ async function listDirectoryContents(options) {
   const collected = [];
   for (const dirent of dirents) {
     if (!includeHidden && dirent.name.startsWith(".")) continue;
-    const childPath = path19.join(resolvedPath, dirent.name);
+    const childPath = path20.join(resolvedPath, dirent.name);
     const kind = await classifyEntry(dirent, childPath);
     if (!kind) continue;
     if (kind === "file" && !includeFiles) continue;
@@ -38845,7 +39050,7 @@ async function listDirectoryContents(options) {
     if (collected.length >= limit) break;
   }
   collected.sort(compareEntries);
-  const parent = path19.dirname(resolvedPath);
+  const parent = path20.dirname(resolvedPath);
   return {
     path: resolvedPath,
     parent: parent === resolvedPath ? null : parent,
@@ -38856,12 +39061,12 @@ async function resolveAbsolutePath(rawPath) {
   const home = process.env.HOME ?? homedir4();
   const trimmed = rawPath.trim();
   if (trimmed === "" || trimmed === "~") {
-    return path19.resolve(home);
+    return path20.resolve(home);
   }
   if (trimmed.startsWith("~/")) {
-    return path19.resolve(home, trimmed.slice(2));
+    return path20.resolve(home, trimmed.slice(2));
   }
-  if (!path19.isAbsolute(trimmed)) {
+  if (!path20.isAbsolute(trimmed)) {
     throw new Error(
       `list_directory requires an absolute path, an empty string, or a "~"-prefixed path; got ${JSON.stringify(rawPath)}`
     );
@@ -38869,7 +39074,7 @@ async function resolveAbsolutePath(rawPath) {
   try {
     return await realpath2(trimmed);
   } catch {
-    return path19.resolve(trimmed);
+    return path20.resolve(trimmed);
   }
 }
 async function classifyEntry(dirent, fullPath) {
@@ -38910,8 +39115,8 @@ function resolveClientMessageId(clientMessageId, generateId = uuidv45) {
 
 // ../server/src/server/chat/chat-service.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
-import { promises as fs12 } from "node:fs";
-import path20 from "node:path";
+import { promises as fs13 } from "node:fs";
+import path21 from "node:path";
 import { z as z36 } from "zod";
 var ChatStorePayloadSchema = z36.object({
   rooms: z36.array(ChatRoomSchema),
@@ -38957,7 +39162,7 @@ var FileBackedChatService = class {
     this.messagesByRoomId = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
     this.waitersByRoomId = /* @__PURE__ */ new Map();
-    this.filePath = path20.join(options.appostleHome, "chat", "rooms.json");
+    this.filePath = path21.join(options.appostleHome, "chat", "rooms.json");
     this.logger = options.logger.child({ component: "chat-service" });
   }
   async initialize() {
@@ -39152,7 +39357,7 @@ var FileBackedChatService = class {
     this.rooms.clear();
     this.messagesByRoomId.clear();
     try {
-      const raw = await fs12.readFile(this.filePath, "utf8");
+      const raw = await fs13.readFile(this.filePath, "utf8");
       const parsed = ChatStorePayloadSchema.parse(JSON.parse(raw));
       for (const room of parsed.rooms) {
         this.rooms.set(room.id, room);
@@ -39183,10 +39388,10 @@ var FileBackedChatService = class {
       ),
       messages: Array.from(this.messagesByRoomId.values()).flat().sort((left, right) => left.createdAt.localeCompare(right.createdAt))
     };
-    await fs12.mkdir(path20.dirname(this.filePath), { recursive: true });
+    await fs13.mkdir(path21.dirname(this.filePath), { recursive: true });
     const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID10()}.tmp`;
-    await fs12.writeFile(tempPath, JSON.stringify(payload, null, 2), "utf8");
-    await fs12.rename(tempPath, this.filePath);
+    await fs13.writeFile(tempPath, JSON.stringify(payload, null, 2), "utf8");
+    await fs13.rename(tempPath, this.filePath);
   }
   /**
    * Look up a room by name, scoped to a specific owner (used by createRoom's
@@ -39358,42 +39563,42 @@ function buildChatMentionNotification(input) {
 }
 
 // ../server/src/server/roles/scanner.ts
-import fs13 from "node:fs/promises";
-import os8 from "node:os";
-import path21 from "node:path";
+import fs14 from "node:fs/promises";
+import os9 from "node:os";
+import path22 from "node:path";
 var NAME_REGEX2 = /^[a-z0-9][a-z0-9._-]*$/i;
 function homeDir2() {
-  return process.env.HOME || os8.homedir();
+  return process.env.HOME || os9.homedir();
 }
 function resolveScopeDir2(scope, workspaceRoot) {
   if (scope === "project") {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path21.join(workspaceRoot, ".roles");
+    return path22.join(workspaceRoot, ".roles");
   }
-  return path21.join(homeDir2(), ".appostle", ".roles");
+  return path22.join(homeDir2(), ".appostle", ".roles");
 }
 function allowedRoots2(workspaceRoot) {
-  const roots = [path21.join(homeDir2(), ".appostle", ".roles")];
+  const roots = [path22.join(homeDir2(), ".appostle", ".roles")];
   if (workspaceRoot) {
-    roots.push(path21.join(workspaceRoot, ".roles"));
+    roots.push(path22.join(workspaceRoot, ".roles"));
   }
-  return roots.map((r) => path21.resolve(r));
+  return roots.map((r) => path22.resolve(r));
 }
 function isInsideAllowedRoot2(absPath, workspaceRoot) {
-  const resolved = path21.resolve(absPath);
+  const resolved = path22.resolve(absPath);
   for (const root of allowedRoots2(workspaceRoot)) {
-    const rel = path21.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path21.isAbsolute(rel)) {
+    const rel = path22.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel)) {
       return true;
     }
   }
   return false;
 }
-var FRONTMATTER_RE2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var FRONTMATTER_RE3 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 function parseRoleFile(text) {
-  const match = FRONTMATTER_RE2.exec(text);
+  const match = FRONTMATTER_RE3.exec(text);
   if (!match) {
     return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
   }
@@ -39573,7 +39778,7 @@ function rewriteFrontmatter2(originalLines, next) {
 async function readRolesFromDir(scope, dir, category) {
   let entries;
   try {
-    entries = await fs13.readdir(dir, { withFileTypes: true });
+    entries = await fs14.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -39583,17 +39788,17 @@ async function readRolesFromDir(scope, dir, category) {
     if (!entry.name.endsWith(".md")) continue;
     const name = entry.name.slice(0, -".md".length);
     if (!name || !NAME_REGEX2.test(name)) continue;
-    const fullPath = path21.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     let stat10;
     try {
-      const s = await fs13.stat(fullPath);
+      const s = await fs14.stat(fullPath);
       stat10 = { mtime: s.mtime, size: s.size };
     } catch {
       continue;
     }
     let parsed;
     try {
-      const text = await fs13.readFile(fullPath, "utf8");
+      const text = await fs14.readFile(fullPath, "utf8");
       parsed = parseFrontmatter(text);
     } catch {
       parsed = {
@@ -39627,13 +39832,13 @@ async function readRolesFromDir(scope, dir, category) {
 async function readRolesFromScopeDir(scope, scopeDir) {
   let topEntries;
   try {
-    topEntries = await fs13.readdir(scopeDir, { withFileTypes: true });
+    topEntries = await fs14.readdir(scopeDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const flat = await readRolesFromDir(scope, scopeDir, null);
   const categoryResults = await Promise.all(
-    topEntries.filter((e) => e.isDirectory() && NAME_REGEX2.test(e.name)).map((e) => readRolesFromDir(scope, path21.join(scopeDir, e.name), e.name))
+    topEntries.filter((e) => e.isDirectory() && NAME_REGEX2.test(e.name)).map((e) => readRolesFromDir(scope, path22.join(scopeDir, e.name), e.name))
   );
   const all = [...flat, ...categoryResults.flat()];
   all.sort((a, b) => {
@@ -39668,7 +39873,7 @@ async function resolveRole(args) {
   const match = roles.find((r) => r.name === args.roleName);
   if (!match) return null;
   try {
-    const text = await fs13.readFile(match.path, "utf8");
+    const text = await fs14.readFile(match.path, "utf8");
     const parsed = parseRoleFile(text);
     const fm = parseFrontmatter(text);
     const body = parsed.body.trim();
@@ -39688,11 +39893,11 @@ async function createRole(args) {
     throw new Error(`Role name must not contain path separators or "..".`);
   }
   const scopeDir = resolveScopeDir2(args.scope, args.workspaceRoot);
-  const dir = args.category ? path21.join(scopeDir, args.category) : scopeDir;
-  await fs13.mkdir(dir, { recursive: true });
-  const filePath = path21.join(dir, `${args.name}.md`);
+  const dir = args.category ? path22.join(scopeDir, args.category) : scopeDir;
+  await fs14.mkdir(dir, { recursive: true });
+  const filePath = path22.join(dir, `${args.name}.md`);
   try {
-    await fs13.access(filePath);
+    await fs14.access(filePath);
     throw new Error(`A role named "${args.name}" already exists at ${filePath}`);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
@@ -39703,7 +39908,7 @@ async function createRole(args) {
     }
   }
   const initial = buildStarterRole(args.name);
-  await fs13.writeFile(filePath, initial, "utf8");
+  await fs14.writeFile(filePath, initial, "utf8");
   return { path: filePath };
 }
 function buildStarterRole(name) {
@@ -39724,7 +39929,7 @@ the role is invoked.
 `;
 }
 async function writeRoleFrontmatter(args, workspaceRoot) {
-  if (!path21.isAbsolute(args.path)) {
+  if (!path22.isAbsolute(args.path)) {
     throw new Error(`writeRoleFrontmatter expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
@@ -39732,7 +39937,7 @@ async function writeRoleFrontmatter(args, workspaceRoot) {
   }
   let original;
   try {
-    original = await fs13.readFile(args.path, "utf8");
+    original = await fs14.readFile(args.path, "utf8");
   } catch (err) {
     throw new Error(
       `Failed to read role file: ${err instanceof Error ? err.message : String(err)}`
@@ -39745,23 +39950,23 @@ async function writeRoleFrontmatter(args, workspaceRoot) {
 ${parsed.body}` : `${nextFrontmatter}
 
 ${original}`;
-  await fs13.writeFile(args.path, nextContent, "utf8");
+  await fs14.writeFile(args.path, nextContent, "utf8");
 }
 async function moveRole(args, workspaceRoot) {
-  if (!path21.isAbsolute(args.path)) {
+  if (!path22.isAbsolute(args.path)) {
     throw new Error(`moveRole expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
     throw new Error(`Path "${args.path}" is not inside an allowlisted role root`);
   }
-  const oldDir = path21.dirname(args.path);
-  const oldFilename = path21.basename(args.path, ".md");
+  const oldDir = path22.dirname(args.path);
+  const oldFilename = path22.basename(args.path, ".md");
   const roots = allowedRoots2(workspaceRoot);
-  const rolesRoot = roots.find((r) => path21.resolve(args.path).startsWith(r));
+  const rolesRoot = roots.find((r) => path22.resolve(args.path).startsWith(r));
   if (!rolesRoot) {
     throw new Error(`Cannot determine roles root for "${args.path}"`);
   }
-  const relFromRoot = path21.relative(rolesRoot, path21.dirname(args.path));
+  const relFromRoot = path22.relative(rolesRoot, path22.dirname(args.path));
   const currentCategory = relFromRoot && relFromRoot !== "." ? relFromRoot : "";
   const newName = args.newName ?? oldFilename;
   const newCategory = args.newCategory !== void 0 ? args.newCategory : currentCategory;
@@ -39771,19 +39976,19 @@ async function moveRole(args, workspaceRoot) {
   if (newCategory && !NAME_REGEX2.test(newCategory)) {
     throw new Error(`Invalid category name: "${newCategory}"`);
   }
-  const newDir = newCategory ? path21.join(rolesRoot, newCategory) : rolesRoot;
-  const newPath = path21.join(newDir, `${newName}.md`);
-  if (path21.resolve(newPath) === path21.resolve(args.path)) {
+  const newDir = newCategory ? path22.join(rolesRoot, newCategory) : rolesRoot;
+  const newPath = path22.join(newDir, `${newName}.md`);
+  if (path22.resolve(newPath) === path22.resolve(args.path)) {
     return { path: args.path };
   }
-  await fs13.mkdir(newDir, { recursive: true });
+  await fs14.mkdir(newDir, { recursive: true });
   try {
-    await fs13.access(newPath);
+    await fs14.access(newPath);
     throw new Error(`A role already exists at "${newPath}"`);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  await fs13.rename(args.path, newPath);
+  await fs14.rename(args.path, newPath);
   const frontmatterPatch = {};
   if (newName !== oldFilename) {
     frontmatterPatch.description = void 0;
@@ -39799,9 +40004,9 @@ async function moveRole(args, workspaceRoot) {
   );
   if (oldDir !== rolesRoot) {
     try {
-      const remaining = await fs13.readdir(oldDir);
+      const remaining = await fs14.readdir(oldDir);
       if (remaining.length === 0) {
-        await fs13.rmdir(oldDir);
+        await fs14.rmdir(oldDir);
       }
     } catch {
     }
@@ -39810,18 +40015,18 @@ async function moveRole(args, workspaceRoot) {
 }
 
 // ../server/src/server/brands/scanner.ts
-import fs14 from "node:fs/promises";
-import path22 from "node:path";
+import fs15 from "node:fs/promises";
+import path23 from "node:path";
 var CATEGORY_REGEX = /^[a-z0-9][a-z0-9_-]*$/i;
 function resolveAssetsDir(workspaceRoot, category) {
-  const base = path22.join(workspaceRoot, ".appostle", "brand", "assets");
+  const base = path23.join(workspaceRoot, ".appostle", "brand", "assets");
   if (!category) return base;
   if (!CATEGORY_REGEX.test(category) || category.includes("..")) {
     throw new Error(
       `Invalid asset category "${category}". Use letters, digits, dot, underscore, dash.`
     );
   }
-  return path22.join(base, category);
+  return path23.join(base, category);
 }
 function relativePathFor(category, fileName) {
   return category ? `assets/${category}/${fileName}` : `assets/${fileName}`;
@@ -39829,7 +40034,7 @@ function relativePathFor(category, fileName) {
 async function removeSiblingExtensions(dir, targetName, keepFileName) {
   let entries;
   try {
-    entries = await fs14.readdir(dir);
+    entries = await fs15.readdir(dir);
   } catch {
     return;
   }
@@ -39837,9 +40042,9 @@ async function removeSiblingExtensions(dir, targetName, keepFileName) {
     if (entry === keepFileName) continue;
     if (!entry.startsWith(`${targetName}.`)) continue;
     try {
-      const stat10 = await fs14.stat(path22.join(dir, entry));
+      const stat10 = await fs15.stat(path23.join(dir, entry));
       if (!stat10.isFile()) continue;
-      await fs14.unlink(path22.join(dir, entry));
+      await fs15.unlink(path23.join(dir, entry));
     } catch {
     }
   }
@@ -39850,7 +40055,7 @@ function convertSvgToMono(svg, color) {
 async function runDerivations(options) {
   const { primaryAbsolutePath, assetsDir, category, derive } = options;
   if (derive.length === 0) return [];
-  const ext = path22.extname(primaryAbsolutePath).toLowerCase();
+  const ext = path23.extname(primaryAbsolutePath).toLowerCase();
   const isSvg = ext === ".svg";
   const results = [];
   for (const spec of derive) {
@@ -39882,12 +40087,12 @@ async function runDerivations(options) {
       continue;
     }
     try {
-      const sourceText = await fs14.readFile(primaryAbsolutePath, "utf8");
+      const sourceText = await fs15.readFile(primaryAbsolutePath, "utf8");
       const monoText = convertSvgToMono(sourceText, spec.color);
       const fileName = `${spec.targetName}${ext}`;
-      const destAbs = path22.resolve(assetsDir, fileName);
-      const rel = path22.relative(path22.resolve(assetsDir), destAbs);
-      if (rel.startsWith("..") || path22.isAbsolute(rel)) {
+      const destAbs = path23.resolve(assetsDir, fileName);
+      const rel = path23.relative(path23.resolve(assetsDir), destAbs);
+      if (rel.startsWith("..") || path23.isAbsolute(rel)) {
         results.push({
           targetName: spec.targetName,
           relativePath: "",
@@ -39896,7 +40101,7 @@ async function runDerivations(options) {
         });
         continue;
       }
-      await fs14.writeFile(destAbs, monoText, "utf8");
+      await fs15.writeFile(destAbs, monoText, "utf8");
       results.push({
         targetName: spec.targetName,
         relativePath: relativePathFor(category, fileName),
@@ -39921,30 +40126,30 @@ function resolveScopeDir3(scope, workspaceRoot) {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path22.join(workspaceRoot, ".appostle", "brand");
+    return path23.join(workspaceRoot, ".appostle", "brand");
   }
   throw new Error(`Unknown scope: ${scope}`);
 }
 function allowedRoots3(workspaceRoot) {
   const roots = [];
   if (workspaceRoot) {
-    roots.push(path22.join(workspaceRoot, ".appostle", "brand"));
+    roots.push(path23.join(workspaceRoot, ".appostle", "brand"));
   }
-  return roots.map((r) => path22.resolve(r));
+  return roots.map((r) => path23.resolve(r));
 }
 function isInsideAllowedRoot3(absPath, workspaceRoot) {
-  const resolved = path22.resolve(absPath);
+  const resolved = path23.resolve(absPath);
   for (const root of allowedRoots3(workspaceRoot)) {
-    const rel = path22.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel)) {
+    const rel = path23.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path23.isAbsolute(rel)) {
       return true;
     }
   }
   return false;
 }
-var FRONTMATTER_RE3 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var FRONTMATTER_RE4 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 function parseBrandFile(text) {
-  const match = FRONTMATTER_RE3.exec(text);
+  const match = FRONTMATTER_RE4.exec(text);
   if (!match) {
     return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
   }
@@ -40140,7 +40345,7 @@ function rewriteFrontmatter3(originalLines, next) {
 async function readBrandsFromDir(scope, dir) {
   let entries;
   try {
-    entries = await fs14.readdir(dir, { withFileTypes: true });
+    entries = await fs15.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -40150,19 +40355,21 @@ async function readBrandsFromDir(scope, dir) {
     if (!entry.name.endsWith(".md")) continue;
     const name = entry.name.slice(0, -".md".length);
     if (!name || !NAME_REGEX3.test(name)) continue;
-    const fullPath = path22.join(dir, entry.name);
+    const fullPath = path23.join(dir, entry.name);
     let stat10;
     try {
-      const s = await fs14.stat(fullPath);
+      const s = await fs15.stat(fullPath);
       stat10 = { mtime: s.mtime, size: s.size };
     } catch {
       continue;
     }
     let parsed;
+    let body = "";
     try {
-      const text = await fs14.readFile(fullPath, "utf8");
-      const { rawFrontmatterLines, hadFrontmatter } = parseBrandFile(text);
+      const text = await fs15.readFile(fullPath, "utf8");
+      const { rawFrontmatterLines, body: parsedBody, hadFrontmatter } = parseBrandFile(text);
       parsed = hadFrontmatter ? parseFrontmatter2(rawFrontmatterLines) : { description: "", variables: [] };
+      body = parsedBody;
     } catch {
       parsed = { description: "", variables: [] };
     }
@@ -40174,7 +40381,8 @@ async function readBrandsFromDir(scope, dir) {
       variables: parsed.variables,
       path: fullPath,
       modifiedAt: stat10.mtime.toISOString(),
-      size: stat10.size
+      size: stat10.size,
+      body
     });
   }
   results.sort((a, b) => a.name.localeCompare(b.name));
@@ -40193,10 +40401,10 @@ async function createBrand(args) {
     throw new Error(`Brand name must not contain path separators or "..".`);
   }
   const dir = resolveScopeDir3("project", args.workspaceRoot);
-  await fs14.mkdir(dir, { recursive: true });
-  const filePath = path22.join(dir, `${args.name}.md`);
+  await fs15.mkdir(dir, { recursive: true });
+  const filePath = path23.join(dir, `${args.name}.md`);
   try {
-    await fs14.access(filePath);
+    await fs15.access(filePath);
     throw new Error(`A brand named "${args.name}" already exists at ${filePath}`);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
@@ -40206,7 +40414,7 @@ async function createBrand(args) {
       throw err;
     }
   }
-  await fs14.writeFile(filePath, buildStarterBrand(args.name), "utf8");
+  await fs15.writeFile(filePath, buildStarterBrand(args.name), "utf8");
   return { path: filePath };
 }
 function buildStarterBrand(name) {
@@ -40250,7 +40458,7 @@ async function copyBrandAsset(args) {
   if (!args.workspaceRoot) {
     throw new Error("workspaceRoot is required to copy a brand asset");
   }
-  if (!args.sourcePath || !path22.isAbsolute(args.sourcePath)) {
+  if (!args.sourcePath || !path23.isAbsolute(args.sourcePath)) {
     throw new Error(`copyBrandAsset expects an absolute sourcePath; got "${args.sourcePath}"`);
   }
   if (!TARGET_NAME_REGEX.test(args.targetName) || args.targetName.includes("..")) {
@@ -40258,21 +40466,21 @@ async function copyBrandAsset(args) {
       `Invalid targetName "${args.targetName}". Use letters, digits, dot, underscore, dash.`
     );
   }
-  const stats = await fs14.stat(args.sourcePath);
+  const stats = await fs15.stat(args.sourcePath);
   if (!stats.isFile()) {
     throw new Error(`Source path is not a regular file: ${args.sourcePath}`);
   }
-  const ext = path22.extname(args.sourcePath).toLowerCase();
+  const ext = path23.extname(args.sourcePath).toLowerCase();
   const fileName = `${args.targetName}${ext}`;
   const assetsDir = resolveAssetsDir(args.workspaceRoot, args.category);
-  const destAbs = path22.resolve(assetsDir, fileName);
-  const rel = path22.relative(path22.resolve(assetsDir), destAbs);
-  if (rel.startsWith("..") || path22.isAbsolute(rel)) {
+  const destAbs = path23.resolve(assetsDir, fileName);
+  const rel = path23.relative(path23.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path23.isAbsolute(rel)) {
     throw new Error(`Refusing to write outside of .appostle/brand/assets: ${destAbs}`);
   }
-  await fs14.mkdir(assetsDir, { recursive: true });
+  await fs15.mkdir(assetsDir, { recursive: true });
   await removeSiblingExtensions(assetsDir, args.targetName, fileName);
-  await fs14.copyFile(args.sourcePath, destAbs);
+  await fs15.copyFile(args.sourcePath, destAbs);
   const derived = await runDerivations({
     primaryAbsolutePath: destAbs,
     assetsDir,
@@ -40297,13 +40505,13 @@ async function uploadBrandAsset(args) {
   if (!args.dataBase64 || args.dataBase64.trim().length === 0) {
     throw new Error("No file data provided for brand asset upload");
   }
-  const extFromSource = args.sourceName ? path22.extname(args.sourceName).toLowerCase() : "";
+  const extFromSource = args.sourceName ? path23.extname(args.sourceName).toLowerCase() : "";
   const ext = extFromSource || ".png";
   const fileName = `${args.targetName}${ext}`;
   const assetsDir = resolveAssetsDir(args.workspaceRoot, args.category);
-  const destAbs = path22.resolve(assetsDir, fileName);
-  const rel = path22.relative(path22.resolve(assetsDir), destAbs);
-  if (rel.startsWith("..") || path22.isAbsolute(rel)) {
+  const destAbs = path23.resolve(assetsDir, fileName);
+  const rel = path23.relative(path23.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path23.isAbsolute(rel)) {
     throw new Error(`Refusing to write outside of .appostle/brand/assets: ${destAbs}`);
   }
   let data;
@@ -40315,9 +40523,9 @@ async function uploadBrandAsset(args) {
   if (data.length === 0) {
     throw new Error("Uploaded brand asset is empty");
   }
-  await fs14.mkdir(assetsDir, { recursive: true });
+  await fs15.mkdir(assetsDir, { recursive: true });
   await removeSiblingExtensions(assetsDir, args.targetName, fileName);
-  await fs14.writeFile(destAbs, data);
+  await fs15.writeFile(destAbs, data);
   const derived = await runDerivations({
     primaryAbsolutePath: destAbs,
     assetsDir,
@@ -40331,7 +40539,7 @@ async function uploadBrandAsset(args) {
   };
 }
 async function writeBrandFrontmatter(args, workspaceRoot) {
-  if (!path22.isAbsolute(args.path)) {
+  if (!path23.isAbsolute(args.path)) {
     throw new Error(`writeBrandFrontmatter expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot3(args.path, workspaceRoot)) {
@@ -40339,7 +40547,7 @@ async function writeBrandFrontmatter(args, workspaceRoot) {
   }
   let original;
   try {
-    original = await fs14.readFile(args.path, "utf8");
+    original = await fs15.readFile(args.path, "utf8");
   } catch (err) {
     throw new Error(
       `Failed to read brand file: ${err instanceof Error ? err.message : String(err)}`
@@ -40352,7 +40560,7 @@ async function writeBrandFrontmatter(args, workspaceRoot) {
 ${parsed.body}` : `${nextFrontmatter}
 
 ${original}`;
-  await fs14.writeFile(args.path, nextContent, "utf8");
+  await fs15.writeFile(args.path, nextContent, "utf8");
 }
 
 // ../server/src/server/brand/token-generator.ts
@@ -40613,73 +40821,194 @@ async function generateAndApplyBrandTokens(options) {
   return { generatedCount: acceptedUpdates.size };
 }
 
+// ../server/src/server/brand/photography-analyzer.ts
+import { z as z38 } from "zod";
+var PhotographyResponseSchema = z38.object({
+  dna: z38.string().min(1),
+  dials: z38.record(z38.string(), z38.string())
+});
+function buildPrompt3(args) {
+  const dialLines = args.selectVars.map((v) => {
+    const options = (v.options ?? []).join(", ");
+    return `- ${v.key} (${v.label || v.key}): current="${v.value || "(unset)"}" options=[${options}]`;
+  }).join("\n");
+  const refSection = args.referenceDescriptions.length > 0 ? [
+    "",
+    "Reference image filenames/descriptions provided by the user:",
+    ...args.referenceDescriptions.map((r) => `- ${r}`)
+  ].join("\n") : "";
+  return [
+    "You are a photography director analyzing a brand's photographic identity.",
+    "The user has provided a brief describing the visual direction they want.",
+    "Your job is to:",
+    "1. Write a rich, specific Style DNA (2-3 sentences describing the photographic",
+    "   identity in concrete visual terms \u2014 lighting quality, tonal mood, depth",
+    "   characteristics, color rendering. No marketing fluff.)",
+    "2. Pre-dial every camera control to match that style direction.",
+    "   ONLY use values that appear in the options list for each dial.",
+    "",
+    "User brief:",
+    args.brief,
+    refSection,
+    "",
+    "Camera dials (key, current value, valid options):",
+    dialLines,
+    "",
+    "Return JSON only with the shape:",
+    '{ "dna": "Rich style DNA description...", "dials": { "key": "value", ... } }',
+    "",
+    "Rules:",
+    "- The dna field must be a non-empty string, 2-3 sentences.",
+    "- Every value in dials must be one of the listed options for that key.",
+    "- Include ALL dial keys in dials, even if you keep the current value.",
+    "- Do not invent new keys. Do not output anything outside the JSON."
+  ].filter((line) => line !== "").join("\n");
+}
+async function analyzeAndApplyPhotographyStyle(options) {
+  const { agentManager, workspaceRoot, brandPath, brief, referenceDescriptions, logger } = options;
+  const brands = await listBrands({ workspaceRoot });
+  const photoBrand = brands.find((b) => b.path === brandPath) ?? null;
+  if (!photoBrand) {
+    throw new Error(`Brand file not found at ${brandPath}`);
+  }
+  const allVars = photoBrand.variables;
+  const selectVars = allVars.filter(
+    (v) => v.type === "select" && v.options && v.options.length > 0
+  );
+  if (selectVars.length === 0) {
+    throw new Error("No camera dials found in photography brand file");
+  }
+  const validOptions = /* @__PURE__ */ new Map();
+  for (const v of selectVars) {
+    validOptions.set(v.key, new Set(v.options ?? []));
+  }
+  const agentPrompt = buildPrompt3({
+    brief,
+    referenceDescriptions: referenceDescriptions ?? [],
+    selectVars
+  });
+  let response;
+  try {
+    response = await generateStructuredAgentResponseWithFallback({
+      manager: agentManager,
+      cwd: workspaceRoot,
+      prompt: agentPrompt,
+      schema: PhotographyResponseSchema,
+      schemaName: "PhotographyAnalysis",
+      maxRetries: 2,
+      providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+      agentConfigOverrides: {
+        title: "Photography style analyzer",
+        internal: true
+      }
+    });
+  } catch (error) {
+    if (error instanceof StructuredAgentResponseError || error instanceof StructuredAgentFallbackError) {
+      logger.warn({ err: error, brandPath }, "Structured photography analysis failed");
+      throw new Error("Photography analysis failed \u2014 the agent did not return valid JSON");
+    }
+    throw error;
+  }
+  const acceptedUpdates = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(response.dials)) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    const opts = validOptions.get(key);
+    if (!opts) continue;
+    if (!opts.has(trimmed)) continue;
+    acceptedUpdates.set(key, trimmed);
+  }
+  acceptedUpdates.set("photo.dna", response.dna);
+  acceptedUpdates.set("photo.brief", brief);
+  const nextVariables = allVars.map((v) => {
+    const update = acceptedUpdates.get(v.key);
+    if (update === void 0) return v;
+    return { ...v, value: update };
+  });
+  await writeBrandFrontmatter(
+    {
+      path: brandPath,
+      frontmatter: {
+        description: photoBrand.description,
+        variables: nextVariables
+      }
+    },
+    workspaceRoot
+  );
+  logger.info(
+    { brandPath, updatedCount: acceptedUpdates.size },
+    "photography-analyzer: applied style analysis"
+  );
+  return { updatedCount: acceptedUpdates.size };
+}
+
 // ../server/src/server/brand/layout-generator.ts
-import { promises as fs15 } from "node:fs";
-import path23 from "node:path";
+import { promises as fs16 } from "node:fs";
+import path24 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var QA_FILENAME = "layout-qa.md";
 var PROMPT_FILENAME = "layout-prompt.md";
 var MAX_LOOKUP_LEVELS = 10;
 var ROLE_FILE_RELATIVE = ".appostle/brand/assets/role/brand-layout-role.md";
 async function findFileUpward(filename) {
-  let dir = path23.dirname(fileURLToPath3(import.meta.url));
+  let dir = path24.dirname(fileURLToPath3(import.meta.url));
   for (let i = 0; i < MAX_LOOKUP_LEVELS; i++) {
-    const candidate = path23.join(dir, filename);
+    const candidate = path24.join(dir, filename);
     try {
-      await fs15.access(candidate);
+      await fs16.access(candidate);
       return candidate;
     } catch {
     }
-    const parent = path23.dirname(dir);
+    const parent = path24.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function getRoleFilePath(workspaceRoot) {
-  return path23.join(workspaceRoot, ROLE_FILE_RELATIVE);
+  return path24.join(workspaceRoot, ROLE_FILE_RELATIVE);
 }
 async function readRoleFile(workspaceRoot) {
   try {
-    return await fs15.readFile(getRoleFilePath(workspaceRoot), "utf8");
+    return await fs16.readFile(getRoleFilePath(workspaceRoot), "utf8");
   } catch {
     return null;
   }
 }
 async function writeRoleFile(workspaceRoot, content) {
   const filePath = getRoleFilePath(workspaceRoot);
-  await fs15.mkdir(path23.dirname(filePath), { recursive: true });
-  await fs15.writeFile(filePath, content, "utf8");
-}
-var QaNextResponseSchema = z38.object({
-  done: z38.boolean(),
-  question: z38.string().optional(),
-  options: z38.array(z38.string()).optional(),
-  roleDocument: z38.string().optional()
-});
-var RefinementResponseSchema = z38.object({
-  roleDocument: z38.string()
-});
-var WireframeBlockSchema = z38.object({
-  type: z38.enum(["headline", "subheadline", "text", "image", "cta", "spacer"]),
-  widthFraction: z38.number(),
-  heightVh: z38.number()
-});
-var WireframeSectionSchema = z38.object({
-  type: z38.enum(["hero", "features", "content", "cta", "footer", "divider"]),
-  widthMode: z38.enum(["full-bleed", "contained"]),
-  heightVh: z38.number(),
-  arrangement: z38.enum(["single-column", "split", "asymmetric-grid", "bento", "stacked"]),
-  blocks: z38.array(WireframeBlockSchema),
-  bg: z38.enum(["neutral", "alt", "accent", "image"]),
-  gapAfterVh: z38.number()
-});
-var WireframeDataSchema = z38.object({
-  viewport: z38.object({ width: z38.number(), height: z38.number() }),
-  maxWidth: z38.number(),
-  pageBg: z38.string(),
-  sections: z38.array(WireframeSectionSchema)
+  await fs16.mkdir(path24.dirname(filePath), { recursive: true });
+  await fs16.writeFile(filePath, content, "utf8");
+}
+var QaNextResponseSchema = z39.object({
+  done: z39.boolean(),
+  question: z39.string().optional(),
+  options: z39.array(z39.string()).optional(),
+  roleDocument: z39.string().optional()
+});
+var RefinementResponseSchema = z39.object({
+  roleDocument: z39.string()
+});
+var WireframeBlockSchema = z39.object({
+  type: z39.enum(["headline", "subheadline", "text", "image", "cta", "spacer"]),
+  widthFraction: z39.number(),
+  heightVh: z39.number()
+});
+var WireframeSectionSchema = z39.object({
+  type: z39.enum(["hero", "features", "content", "cta", "footer", "divider"]),
+  widthMode: z39.enum(["full-bleed", "contained"]),
+  heightVh: z39.number(),
+  arrangement: z39.enum(["single-column", "split", "asymmetric-grid", "bento", "stacked"]),
+  blocks: z39.array(WireframeBlockSchema),
+  bg: z39.enum(["neutral", "alt", "accent", "image"]),
+  gapAfterVh: z39.number()
+});
+var WireframeDataSchema = z39.object({
+  viewport: z39.object({ width: z39.number(), height: z39.number() }),
+  maxWidth: z39.number(),
+  pageBg: z39.string(),
+  sections: z39.array(WireframeSectionSchema)
 });
 function buildFullBrandContext(allBrands) {
   const lines = [];
@@ -40736,7 +41065,7 @@ async function loadSpecFile(filename, logger) {
     );
   }
   try {
-    const content = await fs15.readFile(filePath, "utf8");
+    const content = await fs16.readFile(filePath, "utf8");
     logger.debug({ filePath }, `layout-generator: loaded ${filename} from disk`);
     return content;
   } catch (err) {
@@ -41208,57 +41537,57 @@ async function fetchGitLabUsername(fetchImpl, accessToken) {
     return null;
   }
 }
-async function readCredential(path39, log) {
+async function readCredential(path40, log) {
   try {
-    const raw = await readFile3(path39, "utf8");
+    const raw = await readFile3(path40, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.gitlab ?? null;
   } catch (error) {
     if (isNotFound(error)) return null;
-    log.warn({ err: error, path: path39 }, "oauth.credentials.read_failed");
+    log.warn({ err: error, path: path40 }, "oauth.credentials.read_failed");
     return null;
   }
 }
-async function persistCredential(path39, credential, log) {
-  await mkdir4(dirname6(path39), { recursive: true });
+async function persistCredential(path40, credential, log) {
+  await mkdir4(dirname6(path40), { recursive: true });
   let current = {};
   try {
-    const raw = await readFile3(path39, "utf8");
+    const raw = await readFile3(path40, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (!isNotFound(error)) {
-      log.warn({ err: error, path: path39 }, "oauth.credentials.read_failed_overwriting");
+      log.warn({ err: error, path: path40 }, "oauth.credentials.read_failed_overwriting");
     }
   }
   const next = { ...current, gitlab: credential };
-  const tmpPath = `${path39}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path40}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(next, null, 2), { mode: 384 });
-  await rename(tmpPath, path39);
+  await rename(tmpPath, path40);
 }
-async function deleteCredential(path39, log) {
+async function deleteCredential(path40, log) {
   let current = {};
   try {
-    const raw = await readFile3(path39, "utf8");
+    const raw = await readFile3(path40, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path39 }, "oauth.credentials.delete_read_failed");
+    log.warn({ err: error, path: path40 }, "oauth.credentials.delete_read_failed");
     return;
   }
   delete current.gitlab;
   if (Object.keys(current).length === 0) {
     try {
-      await unlink(path39);
+      await unlink(path40);
     } catch (error) {
       if (!isNotFound(error)) {
-        log.warn({ err: error, path: path39 }, "oauth.credentials.unlink_failed");
+        log.warn({ err: error, path: path40 }, "oauth.credentials.unlink_failed");
       }
     }
     return;
   }
-  const tmpPath = `${path39}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path40}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(current, null, 2), { mode: 384 });
-  await rename(tmpPath, path39);
+  await rename(tmpPath, path40);
 }
 function defaultGlabConfigPath() {
   const home = homedir5();
@@ -41273,15 +41602,15 @@ function defaultGlabConfigPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
   return join13(xdg && xdg.length > 0 ? xdg : join13(home, ".config"), "glab-cli", "config.yml");
 }
-async function writeGlabConfig(path39, credential, log) {
-  await mkdir4(dirname6(path39), { recursive: true });
+async function writeGlabConfig(path40, credential, log) {
+  await mkdir4(dirname6(path40), { recursive: true });
   let doc;
   try {
-    const raw = await readFile3(path39, "utf8");
+    const raw = await readFile3(path40, "utf8");
     doc = YAML.parseDocument(raw);
     if (doc.errors.length > 0) {
       log.warn(
-        { errors: doc.errors.map((e) => e.message), path: path39 },
+        { errors: doc.errors.map((e) => e.message), path: path40 },
         "oauth.glab.parse_errors_replacing"
       );
       doc = YAML.parseDocument("{}");
@@ -41290,7 +41619,7 @@ async function writeGlabConfig(path39, credential, log) {
     if (isNotFound(error)) {
       doc = YAML.parseDocument("{}");
     } else {
-      log.warn({ err: error, path: path39 }, "oauth.glab.read_failed_replacing");
+      log.warn({ err: error, path: path40 }, "oauth.glab.read_failed_replacing");
       doc = YAML.parseDocument("{}");
     }
   }
@@ -41303,18 +41632,18 @@ async function writeGlabConfig(path39, credential, log) {
   if (credential.username) {
     hostEntry.set("user", credential.username);
   }
-  const tmpPath = `${path39}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path40}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path39);
+  await rename(tmpPath, path40);
 }
-async function removeGlabHost(path39, log) {
+async function removeGlabHost(path40, log) {
   let doc;
   try {
-    const raw = await readFile3(path39, "utf8");
+    const raw = await readFile3(path40, "utf8");
     doc = YAML.parseDocument(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path39 }, "oauth.glab.remove_read_failed");
+    log.warn({ err: error, path: path40 }, "oauth.glab.remove_read_failed");
     return;
   }
   const hosts = doc.get("hosts");
@@ -41323,9 +41652,9 @@ async function removeGlabHost(path39, log) {
   if (hosts.items.length === 0) {
     doc.delete("hosts");
   }
-  const tmpPath = `${path39}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path40}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path39);
+  await rename(tmpPath, path40);
 }
 function ensureMap(doc, key) {
   const existing = doc.get(key);
@@ -42364,7 +42693,7 @@ var MIN_STREAMING_SEGMENT_DURATION_MS = 1e3;
 var MIN_STREAMING_SEGMENT_BYTES = Math.round(
   PCM_BYTES_PER_MS * MIN_STREAMING_SEGMENT_DURATION_MS
 );
-var AgentIdSchema2 = z39.string().uuid();
+var AgentIdSchema2 = z40.string().uuid();
 var VOICE_INTERRUPT_CONFIRMATION_MS = 500;
 var VoiceFeatureUnavailableError = class extends Error {
   constructor(context) {
@@ -43745,6 +44074,9 @@ var Session = class _Session {
           case "brands/generate-wireframe":
             await this.handleBrandGenerateWireframeRequest(msg);
             break;
+          case "brands/analyze-photography":
+            await this.handleBrandAnalyzePhotographyRequest(msg);
+            break;
           case "rightfont/library":
             await this.handleRightFontLibraryRequest(msg);
             break;
@@ -45404,8 +45736,8 @@ var Session = class _Session {
   }
   async generateCommitMessage(cwd) {
     const files = await listUncommittedFiles(cwd);
-    const schema = z39.object({
-      message: z39.string().min(1).max(100).describe(
+    const schema = z40.object({
+      message: z40.string().min(1).max(100).describe(
         "Short feature-level summary, lowercase, imperative mood, no trailing period, no filename references."
       )
     });
@@ -45450,9 +45782,9 @@ var Session = class _Session {
       },
       { appostleHome: this.appostleHome }
     );
-    const schema = z39.object({
-      title: z39.string().min(1).max(72),
-      body: z39.string().min(1)
+    const schema = z40.object({
+      title: z40.string().min(1).max(72),
+      body: z40.string().min(1)
     });
     const fileList = diff.structured && diff.structured.length > 0 ? [
       "Files changed:",
@@ -46393,7 +46725,7 @@ var Session = class _Session {
         homeDir: process.env.HOME ?? homedir6(),
         query: query2,
         limit
-      })).map((path39) => ({ path: path39, kind: "directory" }));
+      })).map((path40) => ({ path: path40, kind: "directory" }));
       const directories = entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path);
       this.emit({
         type: "directory_suggestions_response",
@@ -50944,6 +51276,38 @@ ${details}`.trim());
       });
     }
   }
+  async handleBrandAnalyzePhotographyRequest(request) {
+    const { requestId, workspaceRoot, brandPath, brief, referenceDescriptions } = request;
+    try {
+      const result = await analyzeAndApplyPhotographyStyle({
+        agentManager: this.agentManager,
+        workspaceRoot: expandTilde(workspaceRoot),
+        brandPath: expandTilde(brandPath),
+        brief,
+        referenceDescriptions,
+        logger: this.sessionLogger
+      });
+      this.emit({
+        type: "brands/analyze-photography/response",
+        payload: {
+          requestId,
+          updatedCount: result.updatedCount,
+          error: null
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.error({ err: error, brandPath }, "Failed to analyze photography style");
+      this.emit({
+        type: "brands/analyze-photography/response",
+        payload: {
+          requestId,
+          updatedCount: 0,
+          error: message
+        }
+      });
+    }
+  }
   async handleRightFontLibraryRequest(request) {
     const { requestId, libraryPath } = request;
     try {
@@ -53802,13 +54166,13 @@ import { join as join19 } from "node:path";
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir6, rename as rename2, rm as rm2, stat as stat6 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { spawn as spawn7 } from "node:child_process";
 
 // ../server/src/server/speech/providers/local/sherpa/model-catalog.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var SHERPA_ONNX_MODEL_CATALOG = {
   "zipformer-bilingual-zh-en-2023-02-20": {
     kind: "stt-online",
@@ -53901,7 +54265,7 @@ function buildAliasMap(modelIds) {
 }
 function createAliasedModelIdSchema(params) {
   const validIds = new Set(params.modelIds);
-  return z40.string().trim().toLowerCase().refine(
+  return z41.string().trim().toLowerCase().refine(
     (value) => validIds.has(value) || Object.prototype.hasOwnProperty.call(params.aliases, value),
     {
       message: "Invalid model id"
@@ -53938,11 +54302,11 @@ function getSherpaOnnxModelSpec(id) {
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 function getSherpaOnnxModelDir(modelsDir, modelId) {
   const spec = getSherpaOnnxModelSpec(modelId);
-  return path24.join(modelsDir, spec.extractedDir);
+  return path25.join(modelsDir, spec.extractedDir);
 }
 async function hasRequiredFiles(modelDir, requiredFiles) {
   for (const rel of requiredFiles) {
-    const abs = path24.join(modelDir, rel);
+    const abs = path25.join(modelDir, rel);
     try {
       const s = await stat6(abs);
       if (s.isDirectory()) {
@@ -53968,7 +54332,7 @@ async function downloadToFile(options) {
     throw new Error(`Failed to download ${url}: missing response body`);
   }
   const tmpPath = `${outputPath}.tmp-${Date.now()}`;
-  await mkdir6(path24.dirname(outputPath), { recursive: true });
+  await mkdir6(path25.dirname(outputPath), { recursive: true });
   const nodeStream = Readable2.fromWeb(res.body);
   try {
     await pipeline(nodeStream, createWriteStream(tmpPath));
@@ -54005,16 +54369,16 @@ async function ensureSherpaOnnxModel(options) {
     modelId: options.modelId
   });
   const spec = getSherpaOnnxModelSpec(options.modelId);
-  const modelDir = path24.join(options.modelsDir, spec.extractedDir);
+  const modelDir = path25.join(options.modelsDir, spec.extractedDir);
   if (await hasRequiredFiles(modelDir, spec.requiredFiles)) {
     return modelDir;
   }
   logger.info({ modelsDir: options.modelsDir }, "Starting model download");
   try {
     if (spec.archiveUrl) {
-      const downloadsDir = path24.join(options.modelsDir, ".downloads");
-      const archiveFilename = path24.basename(new URL(spec.archiveUrl).pathname);
-      const archivePath = path24.join(downloadsDir, archiveFilename);
+      const downloadsDir = path25.join(options.modelsDir, ".downloads");
+      const archiveFilename = path25.basename(new URL(spec.archiveUrl).pathname);
+      const archivePath = path25.join(downloadsDir, archiveFilename);
       if (!await isNonEmptyFile(archivePath)) {
         await downloadToFile({
           url: spec.archiveUrl,
@@ -54059,7 +54423,7 @@ async function ensureSherpaOnnxModel(options) {
     if (spec.downloadFiles && spec.downloadFiles.length > 0) {
       await mkdir6(modelDir, { recursive: true });
       for (const file of spec.downloadFiles) {
-        const dst = path24.join(modelDir, file.relPath);
+        const dst = path25.join(modelDir, file.relPath);
         if (await isNonEmptyFile(dst)) {
           continue;
         }
@@ -54122,13 +54486,13 @@ import { existsSync as existsSync16 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.ts
 import { createRequire as createRequire4 } from "node:module";
-import path26 from "node:path";
+import path27 from "node:path";
 import { existsSync as existsSync15 } from "node:fs";
 import { spawnSync } from "node:child_process";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-runtime-env.ts
 import { createRequire as createRequire3 } from "node:module";
-import path25 from "node:path";
+import path26 from "node:path";
 function sherpaPlatformArch(platform = process.platform, arch = process.arch) {
   const normalizedPlatform = platform === "win32" ? "win" : platform;
   return `${normalizedPlatform}-${arch}`;
@@ -54149,11 +54513,11 @@ function sherpaLoaderEnvKey(platform = process.platform) {
   return null;
 }
 function prependEnvPath(existing, value) {
-  const parts = (existing ?? "").split(path25.delimiter).filter(Boolean);
+  const parts = (existing ?? "").split(path26.delimiter).filter(Boolean);
   if (parts.includes(value)) {
-    return parts.join(path25.delimiter);
+    return parts.join(path26.delimiter);
   }
-  return [value, ...parts].join(path25.delimiter);
+  return [value, ...parts].join(path26.delimiter);
 }
 function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch) {
   const key = sherpaLoaderEnvKey(platform);
@@ -54166,7 +54530,7 @@ function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch
     const pkgJson = require4.resolve(`${packageName}/package.json`);
     return {
       key,
-      libDir: path25.dirname(pkgJson),
+      libDir: path26.dirname(pkgJson),
       packageName
     };
   } catch {
@@ -54275,7 +54639,7 @@ function loadSherpaOnnxNode() {
   const platformPkgDir = resolvedEnv?.libDir ?? null;
   if (platformPkgDir) {
     applySherpaLoaderEnv(process.env);
-    const addonPath = path26.join(platformPkgDir, "sherpa-onnx.node");
+    const addonPath = path27.join(platformPkgDir, "sherpa-onnx.node");
     if (existsSync15(addonPath)) {
       const byPath = loadWithRequire(require4, addonPath, attempts);
       if (byPath) {
@@ -55047,7 +55411,7 @@ var SherpaOnnxTTS = class {
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-provider.ts
 import { copyFile, mkdir as mkdir7, stat as stat7 } from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-session.ts
 import { EventEmitter as EventEmitter6 } from "node:events";
@@ -55239,8 +55603,8 @@ var SherpaSileroVadSession = class extends EventEmitter6 {
 var SILERO_VAD_DIR = "silero-vad";
 var SILERO_VAD_FILE = "silero_vad.onnx";
 async function ensureSileroVadModel(modelsDir, logger) {
-  const destDir = path27.join(modelsDir, SILERO_VAD_DIR);
-  const destPath = path27.join(destDir, SILERO_VAD_FILE);
+  const destDir = path28.join(modelsDir, SILERO_VAD_DIR);
+  const destPath = path28.join(destDir, SILERO_VAD_FILE);
   try {
     const s = await stat7(destPath);
     if (s.isFile() && s.size > 0) return destPath;
@@ -55533,20 +55897,20 @@ async function initializeLocalSpeechServices(params) {
 }
 
 // ../server/src/server/speech/providers/openai/config.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL = "gpt-4o-transcribe";
 var DEFAULT_OPENAI_TTS_MODEL = "tts-1";
-var OpenAiTtsVoiceSchema = z41.enum(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]);
-var OpenAiTtsModelSchema = z41.enum(["tts-1", "tts-1-hd"]);
-var NumberLikeSchema = z41.union([z41.number(), z41.string().trim().min(1)]);
-var OptionalFiniteNumberSchema = NumberLikeSchema.pipe(z41.coerce.number().finite()).optional();
-var OptionalTrimmedStringSchema = z41.string().trim().optional().transform((value) => value && value.length > 0 ? value : void 0);
-var OpenAiSpeechResolutionSchema = z41.object({
+var OpenAiTtsVoiceSchema = z42.enum(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]);
+var OpenAiTtsModelSchema = z42.enum(["tts-1", "tts-1-hd"]);
+var NumberLikeSchema = z42.union([z42.number(), z42.string().trim().min(1)]);
+var OptionalFiniteNumberSchema = NumberLikeSchema.pipe(z42.coerce.number().finite()).optional();
+var OptionalTrimmedStringSchema = z42.string().trim().optional().transform((value) => value && value.length > 0 ? value : void 0);
+var OpenAiSpeechResolutionSchema = z42.object({
   apiKey: OptionalTrimmedStringSchema,
   sttConfidenceThreshold: OptionalFiniteNumberSchema,
   sttModel: OptionalTrimmedStringSchema,
-  ttsVoice: z41.string().trim().toLowerCase().pipe(OpenAiTtsVoiceSchema).default("alloy"),
-  ttsModel: z41.string().trim().toLowerCase().pipe(OpenAiTtsModelSchema).default(DEFAULT_OPENAI_TTS_MODEL),
+  ttsVoice: z42.string().trim().toLowerCase().pipe(OpenAiTtsVoiceSchema).default("alloy"),
+  ttsModel: z42.string().trim().toLowerCase().pipe(OpenAiTtsModelSchema).default(DEFAULT_OPENAI_TTS_MODEL),
   realtimeTranscriptionModel: OptionalTrimmedStringSchema.default(
     DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL
   )
@@ -55894,7 +56258,7 @@ var OpenAISTT = class {
       const supportsLogprobs = modelToUse === "gpt-4o-transcribe" || modelToUse === "gpt-4o-mini-transcribe";
       const includeLogprobs = ["logprobs"];
       const response = await this.openaiClient.audio.transcriptions.create({
-        file: await import("fs").then((fs19) => fs19.createReadStream(tempFilePath)),
+        file: await import("fs").then((fs20) => fs20.createReadStream(tempFilePath)),
         language,
         model: modelToUse,
         ...supportsLogprobs ? { include: includeLogprobs } : {},
@@ -56658,72 +57022,72 @@ function createSpeechService(params) {
 
 // ../server/src/server/agent/agent-storage.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
-import { promises as fs16 } from "node:fs";
-import path28 from "node:path";
-import { z as z42 } from "zod";
-var SERIALIZABLE_CONFIG_SCHEMA = z42.object({
-  title: z42.string().nullable().optional(),
-  modeId: z42.string().nullable().optional(),
-  model: z42.string().nullable().optional(),
-  thinkingOptionId: z42.string().nullable().optional(),
-  featureValues: z42.record(z42.unknown()).nullable().optional(),
-  extra: z42.record(z42.any()).nullable().optional(),
-  systemPrompt: z42.string().nullable().optional(),
-  mcpServers: z42.record(z42.any()).nullable().optional()
+import { promises as fs17 } from "node:fs";
+import path29 from "node:path";
+import { z as z43 } from "zod";
+var SERIALIZABLE_CONFIG_SCHEMA = z43.object({
+  title: z43.string().nullable().optional(),
+  modeId: z43.string().nullable().optional(),
+  model: z43.string().nullable().optional(),
+  thinkingOptionId: z43.string().nullable().optional(),
+  featureValues: z43.record(z43.unknown()).nullable().optional(),
+  extra: z43.record(z43.any()).nullable().optional(),
+  systemPrompt: z43.string().nullable().optional(),
+  mcpServers: z43.record(z43.any()).nullable().optional()
 }).nullable().optional();
-var PERSISTENCE_HANDLE_SCHEMA = z42.object({
-  provider: z42.string(),
-  sessionId: z42.string(),
-  nativeHandle: z42.any().optional(),
-  metadata: z42.record(z42.any()).optional()
+var PERSISTENCE_HANDLE_SCHEMA = z43.object({
+  provider: z43.string(),
+  sessionId: z43.string(),
+  nativeHandle: z43.any().optional(),
+  metadata: z43.record(z43.any()).optional()
 }).nullable().optional();
-var STORED_AGENT_SCHEMA = z42.object({
-  id: z42.string(),
-  provider: z42.string(),
-  cwd: z42.string(),
-  createdAt: z42.string(),
-  updatedAt: z42.string(),
-  lastActivityAt: z42.string().optional(),
-  lastUserMessageAt: z42.string().nullable().optional(),
-  title: z42.string().nullable().optional(),
-  labels: z42.record(z42.string()).default({}),
+var STORED_AGENT_SCHEMA = z43.object({
+  id: z43.string(),
+  provider: z43.string(),
+  cwd: z43.string(),
+  createdAt: z43.string(),
+  updatedAt: z43.string(),
+  lastActivityAt: z43.string().optional(),
+  lastUserMessageAt: z43.string().nullable().optional(),
+  title: z43.string().nullable().optional(),
+  labels: z43.record(z43.string()).default({}),
   lastStatus: AgentStatusSchema.default("closed"),
-  lastModeId: z42.string().nullable().optional(),
+  lastModeId: z43.string().nullable().optional(),
   config: SERIALIZABLE_CONFIG_SCHEMA,
-  runtimeInfo: z42.object({
-    provider: z42.string(),
-    sessionId: z42.string().nullable(),
-    model: z42.string().nullable().optional(),
-    thinkingOptionId: z42.string().nullable().optional(),
-    modeId: z42.string().nullable().optional(),
-    extra: z42.record(z42.unknown()).optional()
+  runtimeInfo: z43.object({
+    provider: z43.string(),
+    sessionId: z43.string().nullable(),
+    model: z43.string().nullable().optional(),
+    thinkingOptionId: z43.string().nullable().optional(),
+    modeId: z43.string().nullable().optional(),
+    extra: z43.record(z43.unknown()).optional()
   }).optional(),
-  features: z42.array(AgentFeatureSchema).optional(),
+  features: z43.array(AgentFeatureSchema).optional(),
   persistence: PERSISTENCE_HANDLE_SCHEMA,
-  lastError: z42.string().nullable().optional(),
-  requiresAttention: z42.boolean().optional(),
-  attentionReason: z42.enum(["finished", "error", "permission"]).nullable().optional(),
-  attentionTimestamp: z42.string().nullable().optional(),
-  internal: z42.boolean().optional(),
-  archivedAt: z42.string().nullable().optional(),
+  lastError: z43.string().nullable().optional(),
+  requiresAttention: z43.boolean().optional(),
+  attentionReason: z43.enum(["finished", "error", "permission"]).nullable().optional(),
+  attentionTimestamp: z43.string().nullable().optional(),
+  internal: z43.boolean().optional(),
+  archivedAt: z43.string().nullable().optional(),
   // Fork lineage (optional for backward compat with pre-fork records).
-  parentAgentId: z42.string().optional(),
-  forkedFromMessageUuid: z42.string().optional(),
+  parentAgentId: z43.string().optional(),
+  forkedFromMessageUuid: z43.string().optional(),
   // Multi-tenant session isolation: the auth-server user-id that created
   // (and therefore owns) this agent + the additive ACL of other users
   // granted access. Both optional/null-default for backward compatibility
   // with pre-Phase-2c records — those load with `null` owner and stay
   // visible to every connecting user (matches today's single-tenant
   // behavior). Set on new agents at create time via Session.ownerUserId.
-  ownerUserId: z42.string().nullable().optional(),
-  sharedWithUserIds: z42.array(z42.string()).default([]),
+  ownerUserId: z43.string().nullable().optional(),
+  sharedWithUserIds: z43.array(z43.string()).default([]),
   // Owner's display username — needed on resume to route to the correct
   // `CLAUDE_CONFIG_DIR` via `ensureClaudeProfile(username)` for agents
   // created by a shared (non-owner) user. Without this, a resumed shared-
   // user agent would silently fall back to the daemon owner's Claude
   // profile/subscription. Optional — pre-Phase-3 records rehydrate without
   // per-user profile routing.
-  ownerUsername: z42.string().optional()
+  ownerUsername: z43.string().optional()
 });
 function parseStoredAgentRecord(value) {
   return STORED_AGENT_SCHEMA.parse(value);
@@ -56761,12 +57125,12 @@ var AgentStorage = class {
       }
       const nextPath = this.buildRecordPath(record);
       const previousPath = this.pathById.get(agentId);
-      await fs16.mkdir(path28.dirname(nextPath), { recursive: true });
+      await fs17.mkdir(path29.dirname(nextPath), { recursive: true });
       await writeFileAtomically(nextPath, JSON.stringify(record, null, 2));
       this.addIndexedPath(agentId, nextPath);
       if (previousPath && previousPath !== nextPath) {
         try {
-          await fs16.unlink(previousPath);
+          await fs17.unlink(previousPath);
         } catch {
         }
         this.removeIndexedPath(agentId, previousPath);
@@ -56794,7 +57158,7 @@ var AgentStorage = class {
     const paths = Array.from(this.pathsById.get(agentId) ?? []);
     for (const filePath of paths) {
       try {
-        await fs16.unlink(filePath);
+        await fs17.unlink(filePath);
       } catch (error) {
         const code = error.code;
         if (code && code !== "ENOENT") {
@@ -56868,7 +57232,7 @@ var AgentStorage = class {
     const records = [];
     let entries = [];
     try {
-      entries = await fs16.readdir(this.baseDir, { withFileTypes: true });
+      entries = await fs17.readdir(this.baseDir, { withFileTypes: true });
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -56877,7 +57241,7 @@ var AgentStorage = class {
     }
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".json")) {
-        const rootPath = path28.join(this.baseDir, entry.name);
+        const rootPath = path29.join(this.baseDir, entry.name);
         const rootRecord = await this.readRecordFile(rootPath);
         if (!rootRecord) {
           continue;
@@ -56891,10 +57255,10 @@ var AgentStorage = class {
       if (!entry.isDirectory()) {
         continue;
       }
-      const projectDir = path28.join(this.baseDir, entry.name);
+      const projectDir = path29.join(this.baseDir, entry.name);
       let files = [];
       try {
-        files = await fs16.readdir(projectDir, { withFileTypes: true });
+        files = await fs17.readdir(projectDir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -56902,7 +57266,7 @@ var AgentStorage = class {
         if (!file.isFile() || !file.name.endsWith(".json")) {
           continue;
         }
-        const filePath = path28.join(projectDir, file.name);
+        const filePath = path29.join(projectDir, file.name);
         const record = await this.readRecordFile(filePath);
         if (!record) {
           continue;
@@ -56917,7 +57281,7 @@ var AgentStorage = class {
   }
   async readRecordFile(filePath) {
     try {
-      const content = await fs16.readFile(filePath, "utf8");
+      const content = await fs17.readFile(filePath, "utf8");
       const parsed = JSON.parse(content);
       return parseStoredAgentRecord(parsed);
     } catch (error) {
@@ -56927,7 +57291,7 @@ var AgentStorage = class {
   }
   buildRecordPath(record) {
     const projectDir = projectDirNameFromCwd(record.cwd);
-    return path28.join(this.baseDir, projectDir, `${record.id}.json`);
+    return path29.join(this.baseDir, projectDir, `${record.id}.json`);
   }
   addIndexedPath(agentId, filePath) {
     const paths = this.pathsById.get(agentId) ?? /* @__PURE__ */ new Set();
@@ -56949,7 +57313,7 @@ var AgentStorage = class {
   }
 };
 function projectDirNameFromCwd(cwd) {
-  const { root } = path28.win32.parse(cwd);
+  const { root } = path29.win32.parse(cwd);
   const withoutRoot = cwd.slice(root.length).replace(/[\\/]+$/, "");
   const sanitizedRoot = root.replace(/[:\\/]+/g, "-").replace(/^-+|-+$/g, "");
   const prefix = sanitizedRoot ? sanitizedRoot + "-" : "";
@@ -56959,15 +57323,15 @@ function projectDirNameFromCwd(cwd) {
   return prefix + withoutRoot.replace(/[\\/]+/g, "-");
 }
 async function writeFileAtomically(targetPath, payload) {
-  const directory = path28.dirname(targetPath);
-  const tempPath = path28.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID12()}`);
-  await fs16.writeFile(tempPath, payload, "utf8");
-  await fs16.rename(tempPath, targetPath);
+  const directory = path29.dirname(targetPath);
+  const tempPath = path29.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID12()}`);
+  await fs17.writeFile(tempPath, payload, "utf8");
+  await fs17.rename(tempPath, targetPath);
 }
 
 // ../server/src/server/agent/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // ../server/src/server/json-utils.ts
 function ensureValidJson(value) {
@@ -57100,16 +57464,16 @@ function resolveChildAgentCwd(params) {
   }
   return resolvePathFromBase(params.parentCwd, requestedCwd);
 }
-var TerminalSummarySchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  cwd: z43.string()
+var TerminalSummarySchema = z44.object({
+  id: z44.string(),
+  name: z44.string(),
+  cwd: z44.string()
 });
-var WorktreeSummarySchema = z43.object({
-  path: z43.string(),
-  createdAt: z43.string(),
-  branchName: z43.string().optional(),
-  head: z43.string().optional()
+var WorktreeSummarySchema = z44.object({
+  path: z44.string(),
+  createdAt: z44.string(),
+  branchName: z44.string().optional(),
+  head: z44.string().optional()
 });
 function resolveTerminalKeyToken(key, literal) {
   if (literal) {
@@ -57246,48 +57610,48 @@ async function createAgentMcpServer(options) {
     };
   };
   const agentToAgentInputSchema = {
-    cwd: z43.string().optional().describe("Optional working directory. Defaults to the caller agent working directory."),
-    title: z43.string().trim().min(1, "Title is required").max(60, "Title must be 60 characters or fewer").describe("Short descriptive title (<= 60 chars) summarizing the agent's focus."),
+    cwd: z44.string().optional().describe("Optional working directory. Defaults to the caller agent working directory."),
+    title: z44.string().trim().min(1, "Title is required").max(60, "Title must be 60 characters or fewer").describe("Short descriptive title (<= 60 chars) summarizing the agent's focus."),
     provider: AgentProviderEnum.optional().describe(
       "Optional agent implementation to spawn. Defaults to 'claude'."
     ),
-    model: z43.string().optional().describe("Model to use (e.g. claude-sonnet-4-20250514)"),
-    thinking: z43.string().optional().describe("Thinking option ID"),
-    labels: z43.record(z43.string(), z43.string()).optional().describe("Labels to set on the agent"),
-    initialPrompt: z43.string().trim().min(1, "initialPrompt is required").describe("Required first task to run immediately after creation."),
-    background: z43.boolean().optional().default(false).describe(
+    model: z44.string().optional().describe("Model to use (e.g. claude-sonnet-4-20250514)"),
+    thinking: z44.string().optional().describe("Thinking option ID"),
+    labels: z44.record(z44.string(), z44.string()).optional().describe("Labels to set on the agent"),
+    initialPrompt: z44.string().trim().min(1, "initialPrompt is required").describe("Required first task to run immediately after creation."),
+    background: z44.boolean().optional().default(false).describe(
       "Run agent in background. If false (default), waits for completion or permission request. If true, returns immediately."
     ),
-    notifyOnFinish: z43.boolean().optional().default(false).describe(
+    notifyOnFinish: z44.boolean().optional().default(false).describe(
       "Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."
     )
   };
   const topLevelInputSchema = {
-    cwd: z43.string().describe("Required working directory for the agent (absolute, relative, or ~)."),
-    title: z43.string().trim().min(1, "Title is required").max(60, "Title must be 60 characters or fewer").describe("Short descriptive title (<= 60 chars) summarizing the agent's focus."),
+    cwd: z44.string().describe("Required working directory for the agent (absolute, relative, or ~)."),
+    title: z44.string().trim().min(1, "Title is required").max(60, "Title must be 60 characters or fewer").describe("Short descriptive title (<= 60 chars) summarizing the agent's focus."),
     provider: AgentProviderEnum.optional().describe(
       "Optional agent implementation to spawn. Defaults to 'claude'."
     ),
-    model: z43.string().optional().describe("Model to use (e.g. claude-sonnet-4-20250514)"),
-    thinking: z43.string().optional().describe("Thinking option ID"),
-    labels: z43.record(z43.string(), z43.string()).optional().describe("Labels to set on the agent"),
-    initialPrompt: z43.string().trim().min(1, "initialPrompt is required").describe("Required first task to run immediately after creation."),
-    mode: z43.string().optional().describe("Optional session mode to configure before the first run."),
-    worktreeName: z43.string().optional().describe("Optional git worktree branch name (lowercase alphanumerics + hyphen)."),
-    baseBranch: z43.string().optional().describe("Required when worktreeName is set: the base branch to diff/merge against."),
-    refName: z43.string().min(1).optional().describe("Optional source ref for worktree creation."),
-    action: z43.enum(["branch-off", "checkout"]).optional().describe("Optional worktree creation action."),
-    githubPrNumber: z43.number().int().positive().optional().describe("Optional GitHub pull request number to checkout."),
-    background: z43.boolean().optional().default(false).describe(
+    model: z44.string().optional().describe("Model to use (e.g. claude-sonnet-4-20250514)"),
+    thinking: z44.string().optional().describe("Thinking option ID"),
+    labels: z44.record(z44.string(), z44.string()).optional().describe("Labels to set on the agent"),
+    initialPrompt: z44.string().trim().min(1, "initialPrompt is required").describe("Required first task to run immediately after creation."),
+    mode: z44.string().optional().describe("Optional session mode to configure before the first run."),
+    worktreeName: z44.string().optional().describe("Optional git worktree branch name (lowercase alphanumerics + hyphen)."),
+    baseBranch: z44.string().optional().describe("Required when worktreeName is set: the base branch to diff/merge against."),
+    refName: z44.string().min(1).optional().describe("Optional source ref for worktree creation."),
+    action: z44.enum(["branch-off", "checkout"]).optional().describe("Optional worktree creation action."),
+    githubPrNumber: z44.number().int().positive().optional().describe("Optional GitHub pull request number to checkout."),
+    background: z44.boolean().optional().default(false).describe(
       "Run agent in background. If false (default), waits for completion or permission request. If true, returns immediately."
     ),
-    notifyOnFinish: z43.boolean().optional().default(false).describe(
+    notifyOnFinish: z44.boolean().optional().default(false).describe(
       "Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."
     )
   };
   const createAgentInputSchema = callerAgentId ? agentToAgentInputSchema : topLevelInputSchema;
-  const agentToAgentCreateAgentArgsSchema = z43.object(agentToAgentInputSchema);
-  const topLevelCreateAgentArgsSchema = z43.object(topLevelInputSchema);
+  const agentToAgentCreateAgentArgsSchema = z44.object(agentToAgentInputSchema);
+  const topLevelCreateAgentArgsSchema = z44.object(topLevelInputSchema);
   if (options.voiceOnly || options.enableVoiceTools || callerContext?.enableVoiceTools) {
     server.registerTool(
       "speak",
@@ -57295,10 +57659,10 @@ async function createAgentMcpServer(options) {
         title: "Speak",
         description: "Speak text to the user via daemon-managed voice output. Blocks until playback completes.",
         inputSchema: {
-          text: z43.string().trim().min(1, "text is required").max(4e3, "text must be 4000 characters or fewer")
+          text: z44.string().trim().min(1, "text is required").max(4e3, "text must be 4000 characters or fewer")
         },
         outputSchema: {
-          ok: z43.boolean()
+          ok: z44.boolean()
         }
       },
       async (args, context) => {
@@ -57331,19 +57695,19 @@ async function createAgentMcpServer(options) {
       description: "Create a new Claude or Codex agent tied to a working directory. Optionally run an initial prompt immediately or create a git worktree for the agent.",
       inputSchema: createAgentInputSchema,
       outputSchema: {
-        agentId: z43.string(),
+        agentId: z44.string(),
         type: AgentProviderEnum,
         status: AgentStatusEnum,
-        cwd: z43.string(),
-        currentModeId: z43.string().nullable(),
-        availableModes: z43.array(
-          z43.object({
-            id: z43.string(),
-            label: z43.string(),
-            description: z43.string().nullable().optional()
+        cwd: z44.string(),
+        currentModeId: z44.string().nullable(),
+        availableModes: z44.array(
+          z44.object({
+            id: z44.string(),
+            label: z44.string(),
+            description: z44.string().nullable().optional()
           })
         ),
-        lastMessage: z43.string().nullable().optional(),
+        lastMessage: z44.string().nullable().optional(),
         permission: AgentPermissionRequestPayloadSchema.nullable().optional()
       }
     },
@@ -57530,13 +57894,13 @@ async function createAgentMcpServer(options) {
       title: "Wait for agent",
       description: "Block until the agent requests permission or the current run completes. Returns the pending permission (if any) and recent activity summary.",
       inputSchema: {
-        agentId: z43.string().describe("Agent identifier returned by the create_agent tool")
+        agentId: z44.string().describe("Agent identifier returned by the create_agent tool")
       },
       outputSchema: {
-        agentId: z43.string(),
+        agentId: z44.string(),
         status: AgentStatusEnum,
         permission: AgentPermissionRequestPayloadSchema.nullable(),
-        lastMessage: z43.string().nullable()
+        lastMessage: z44.string().nullable()
       }
     },
     async ({ agentId }, { signal }) => {
@@ -57597,20 +57961,20 @@ async function createAgentMcpServer(options) {
       title: "Send agent prompt",
       description: "Send a task to a running agent. Returns immediately after the agent begins processing.",
       inputSchema: {
-        agentId: z43.string(),
-        prompt: z43.string(),
-        sessionMode: z43.string().optional().describe("Optional mode to set before running the prompt."),
-        background: z43.boolean().optional().default(false).describe(
+        agentId: z44.string(),
+        prompt: z44.string(),
+        sessionMode: z44.string().optional().describe("Optional mode to set before running the prompt."),
+        background: z44.boolean().optional().default(false).describe(
           "Run agent in background. If false (default), waits for completion or permission request. If true, returns immediately."
         ),
-        notifyOnFinish: z43.boolean().optional().default(false).describe(
+        notifyOnFinish: z44.boolean().optional().default(false).describe(
           "Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission."
         )
       },
       outputSchema: {
-        success: z43.boolean(),
+        success: z44.boolean(),
         status: AgentStatusEnum,
-        lastMessage: z43.string().nullable().optional(),
+        lastMessage: z44.string().nullable().optional(),
         permission: AgentPermissionRequestPayloadSchema.nullable().optional()
       }
     },
@@ -57674,7 +58038,7 @@ async function createAgentMcpServer(options) {
       title: "Get agent status",
       description: "Return the latest snapshot for an agent, including lifecycle state, capabilities, and pending permissions.",
       inputSchema: {
-        agentId: z43.string()
+        agentId: z44.string()
       },
       outputSchema: {
         status: AgentStatusEnum,
@@ -57721,10 +58085,10 @@ async function createAgentMcpServer(options) {
       title: "List agents",
       description: "List all live agents managed by the server.",
       inputSchema: {
-        includeArchived: z43.boolean().optional().default(false)
+        includeArchived: z44.boolean().optional().default(false)
       },
       outputSchema: {
-        agents: z43.array(AgentSnapshotPayloadSchema)
+        agents: z44.array(AgentSnapshotPayloadSchema)
       }
     },
     async ({ includeArchived }) => {
@@ -57749,10 +58113,10 @@ async function createAgentMcpServer(options) {
       title: "Cancel agent run",
       description: "Abort the agent's current run but keep the agent alive for future tasks.",
       inputSchema: {
-        agentId: z43.string()
+        agentId: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ agentId }) => {
@@ -57772,10 +58136,10 @@ async function createAgentMcpServer(options) {
       title: "Archive agent",
       description: "Archive an agent (soft-delete). The agent is interrupted if running and removed from the active list.",
       inputSchema: {
-        agentId: z43.string()
+        agentId: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ agentId }) => {
@@ -57793,10 +58157,10 @@ async function createAgentMcpServer(options) {
       title: "Kill agent",
       description: "Terminate an agent session permanently.",
       inputSchema: {
-        agentId: z43.string()
+        agentId: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ agentId }) => {
@@ -57814,12 +58178,12 @@ async function createAgentMcpServer(options) {
       title: "Update agent",
       description: "Update an agent name and/or labels.",
       inputSchema: {
-        agentId: z43.string(),
-        name: z43.string().optional(),
-        labels: z43.record(z43.string(), z43.string()).optional().describe("Labels to set on the agent")
+        agentId: z44.string(),
+        name: z44.string().optional(),
+        labels: z44.record(z44.string(), z44.string()).optional().describe("Labels to set on the agent")
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ agentId, name, labels }) => {
@@ -57851,11 +58215,11 @@ async function createAgentMcpServer(options) {
       title: "List terminals",
       description: "List terminals for a working directory or across all working directories.",
       inputSchema: {
-        cwd: z43.string().optional().describe("Optional working directory. Defaults to the caller agent cwd."),
-        all: z43.boolean().optional().describe("List terminals across all working directories.")
+        cwd: z44.string().optional().describe("Optional working directory. Defaults to the caller agent cwd."),
+        all: z44.boolean().optional().describe("List terminals across all working directories.")
       },
       outputSchema: {
-        terminals: z43.array(TerminalSummarySchema)
+        terminals: z44.array(TerminalSummarySchema)
       }
     },
     async ({ cwd, all }) => {
@@ -57889,8 +58253,8 @@ async function createAgentMcpServer(options) {
       title: "Create terminal",
       description: "Create a terminal session for a working directory.",
       inputSchema: {
-        cwd: z43.string().optional().describe("Optional working directory. Defaults to the caller agent cwd."),
-        name: z43.string().optional().describe("Optional terminal name.")
+        cwd: z44.string().optional().describe("Optional working directory. Defaults to the caller agent cwd."),
+        name: z44.string().optional().describe("Optional terminal name.")
       },
       outputSchema: TerminalSummarySchema.shape
     },
@@ -57918,10 +58282,10 @@ async function createAgentMcpServer(options) {
       title: "Kill terminal",
       description: "Kill an existing terminal session.",
       inputSchema: {
-        terminalId: z43.string()
+        terminalId: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ terminalId }) => {
@@ -57945,16 +58309,16 @@ async function createAgentMcpServer(options) {
       title: "Capture terminal",
       description: "Capture plain-text terminal output lines from a terminal session.",
       inputSchema: {
-        terminalId: z43.string(),
-        start: z43.number().optional(),
-        end: z43.number().optional(),
-        scrollback: z43.boolean().optional(),
-        stripAnsi: z43.boolean().optional().default(true)
+        terminalId: z44.string(),
+        start: z44.number().optional(),
+        end: z44.number().optional(),
+        scrollback: z44.boolean().optional(),
+        stripAnsi: z44.boolean().optional().default(true)
       },
       outputSchema: {
-        terminalId: z43.string(),
-        lines: z43.array(z43.string()),
-        totalLines: z43.number().int().nonnegative()
+        terminalId: z44.string(),
+        lines: z44.array(z44.string()),
+        totalLines: z44.number().int().nonnegative()
       }
     },
     async ({ terminalId, start, end, scrollback, stripAnsi: stripAnsi3 = true }) => {
@@ -57986,12 +58350,12 @@ async function createAgentMcpServer(options) {
       title: "Send terminal keys",
       description: "Send literal text or special key tokens to a terminal session.",
       inputSchema: {
-        terminalId: z43.string(),
-        keys: z43.string(),
-        literal: z43.boolean().optional()
+        terminalId: z44.string(),
+        keys: z44.string(),
+        literal: z44.boolean().optional()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ terminalId, keys, literal = false }) => {
@@ -58018,17 +58382,17 @@ async function createAgentMcpServer(options) {
       title: "Create schedule",
       description: "Create a recurring schedule that runs on an agent or a new agent.",
       inputSchema: {
-        prompt: z43.string().trim().min(1, "prompt is required"),
-        every: z43.string().optional(),
-        cron: z43.string().optional(),
-        name: z43.string().optional(),
-        target: z43.enum(["self", "new-agent"]).optional(),
+        prompt: z44.string().trim().min(1, "prompt is required"),
+        every: z44.string().optional(),
+        cron: z44.string().optional(),
+        name: z44.string().optional(),
+        target: z44.enum(["self", "new-agent"]).optional(),
         provider: AgentProviderEnum.optional().describe(
           "Provider, or provider/model (for example: codex or codex/gpt-5.4)."
         ),
-        cwd: z43.string().optional(),
-        maxRuns: z43.number().int().positive().optional(),
-        expiresIn: z43.string().optional()
+        cwd: z44.string().optional(),
+        maxRuns: z44.number().int().positive().optional(),
+        expiresIn: z44.string().optional()
       },
       outputSchema: ScheduleSummarySchema.shape
     },
@@ -58070,7 +58434,7 @@ async function createAgentMcpServer(options) {
       description: "List all schedules managed by the daemon.",
       inputSchema: {},
       outputSchema: {
-        schedules: z43.array(ScheduleSummarySchema)
+        schedules: z44.array(ScheduleSummarySchema)
       }
     },
     async () => {
@@ -58092,7 +58456,7 @@ async function createAgentMcpServer(options) {
       title: "Inspect schedule",
       description: "Inspect a schedule and its run history.",
       inputSchema: {
-        id: z43.string()
+        id: z44.string()
       },
       outputSchema: StoredScheduleSchema.shape
     },
@@ -58113,10 +58477,10 @@ async function createAgentMcpServer(options) {
       title: "Pause schedule",
       description: "Pause an active schedule.",
       inputSchema: {
-        id: z43.string()
+        id: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ id }) => {
@@ -58136,10 +58500,10 @@ async function createAgentMcpServer(options) {
       title: "Resume schedule",
       description: "Resume a paused schedule.",
       inputSchema: {
-        id: z43.string()
+        id: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ id }) => {
@@ -58159,10 +58523,10 @@ async function createAgentMcpServer(options) {
       title: "Delete schedule",
       description: "Delete a schedule permanently.",
       inputSchema: {
-        id: z43.string()
+        id: z44.string()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ id }) => {
@@ -58183,7 +58547,7 @@ async function createAgentMcpServer(options) {
       description: "List available agent providers and their modes.",
       inputSchema: {},
       outputSchema: {
-        providers: z43.array(ProviderSummarySchema)
+        providers: z44.array(ProviderSummarySchema)
       }
     },
     async () => ({
@@ -58210,8 +58574,8 @@ async function createAgentMcpServer(options) {
         provider: AgentProviderEnum
       },
       outputSchema: {
-        provider: z43.string(),
-        models: z43.array(AgentModelSchema)
+        provider: z44.string(),
+        models: z44.array(AgentModelSchema)
       }
     },
     async ({ provider }) => {
@@ -58238,10 +58602,10 @@ async function createAgentMcpServer(options) {
       title: "List worktrees",
       description: "List Appostle-managed git worktrees for a repository.",
       inputSchema: {
-        cwd: z43.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd.")
+        cwd: z44.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd.")
       },
       outputSchema: {
-        worktrees: z43.array(WorktreeSummarySchema)
+        worktrees: z44.array(WorktreeSummarySchema)
       }
     },
     async ({ cwd }) => {
@@ -58262,16 +58626,16 @@ async function createAgentMcpServer(options) {
       title: "Create worktree",
       description: "Create a Appostle-managed git worktree.",
       inputSchema: {
-        cwd: z43.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd."),
-        branchName: z43.string().optional(),
-        baseBranch: z43.string().optional(),
-        refName: z43.string().min(1).optional(),
-        action: z43.enum(["branch-off", "checkout"]).optional(),
-        githubPrNumber: z43.number().int().positive().optional()
+        cwd: z44.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd."),
+        branchName: z44.string().optional(),
+        baseBranch: z44.string().optional(),
+        refName: z44.string().min(1).optional(),
+        action: z44.enum(["branch-off", "checkout"]).optional(),
+        githubPrNumber: z44.number().int().positive().optional()
       },
       outputSchema: {
-        branchName: z43.string(),
-        worktreePath: z43.string()
+        branchName: z44.string(),
+        worktreePath: z44.string()
       }
     },
     async ({ cwd, branchName, baseBranch, refName, action, githubPrNumber }) => {
@@ -58308,12 +58672,12 @@ async function createAgentMcpServer(options) {
       title: "Archive worktree",
       description: "Delete a Appostle-managed git worktree.",
       inputSchema: {
-        cwd: z43.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd."),
-        worktreePath: z43.string().optional(),
-        worktreeSlug: z43.string().optional()
+        cwd: z44.string().optional().describe("Optional repository cwd. Defaults to the caller agent cwd."),
+        worktreePath: z44.string().optional(),
+        worktreeSlug: z44.string().optional()
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ cwd, worktreePath, worktreeSlug }) => {
@@ -58335,14 +58699,14 @@ async function createAgentMcpServer(options) {
       title: "Get agent activity",
       description: "Return recent agent timeline entries as a curated summary.",
       inputSchema: {
-        agentId: z43.string(),
-        limit: z43.number().optional().describe("Optional limit for number of activities to include (most recent first).")
+        agentId: z44.string(),
+        limit: z44.number().optional().describe("Optional limit for number of activities to include (most recent first).")
       },
       outputSchema: {
-        agentId: z43.string(),
-        updateCount: z43.number(),
-        currentModeId: z43.string().nullable(),
-        content: z43.string()
+        agentId: z44.string(),
+        updateCount: z44.number(),
+        currentModeId: z44.string().nullable(),
+        content: z44.string()
       }
     },
     async ({ agentId, limit }) => {
@@ -58383,12 +58747,12 @@ ${curatedContent}`;
       title: "Set agent session mode",
       description: "Switch the agent's session mode (plan, bypassPermissions, read-only, auto, etc.).",
       inputSchema: {
-        agentId: z43.string(),
-        modeId: z43.string()
+        agentId: z44.string(),
+        modeId: z44.string()
       },
       outputSchema: {
-        success: z43.boolean(),
-        newMode: z43.string()
+        success: z44.boolean(),
+        newMode: z44.string()
       }
     },
     async ({ agentId, modeId }) => {
@@ -58406,9 +58770,9 @@ ${curatedContent}`;
       description: "Return all pending permission requests across all agents with the normalized payloads.",
       inputSchema: {},
       outputSchema: {
-        permissions: z43.array(
-          z43.object({
-            agentId: z43.string(),
+        permissions: z44.array(
+          z44.object({
+            agentId: z44.string(),
             status: AgentStatusEnum,
             request: AgentPermissionRequestPayloadSchema
           })
@@ -58436,12 +58800,12 @@ ${curatedContent}`;
       title: "Respond to permission",
       description: "Approve or deny a pending permission request with an AgentManager-compatible response payload.",
       inputSchema: {
-        agentId: z43.string(),
-        requestId: z43.string(),
+        agentId: z44.string(),
+        requestId: z44.string(),
         response: AgentPermissionResponseSchema
       },
       outputSchema: {
-        success: z43.boolean()
+        success: z44.boolean()
       }
     },
     async ({ agentId, requestId, response }) => {
@@ -58468,7 +58832,7 @@ async function createMcpWorktree(options) {
 }
 
 // ../server/src/server/workspace-registry-bootstrap.ts
-import path29 from "node:path";
+import path30 from "node:path";
 function minIsoDate(left, right) {
   if (!left) {
     return right;
@@ -58565,8 +58929,8 @@ async function bootstrapWorkspaceRegistries(options) {
   }
   options.logger.info(
     {
-      projectsFile: path29.join(options.appostleHome, "projects", "projects.json"),
-      workspacesFile: path29.join(options.appostleHome, "projects", "workspaces.json"),
+      projectsFile: path30.join(options.appostleHome, "projects", "projects.json"),
+      workspacesFile: path30.join(options.appostleHome, "projects", "workspaces.json"),
       materializedProjects: projectRanges.size,
       materializedWorkspaces: recordsByWorkspaceId.size
     },
@@ -58762,83 +59126,83 @@ var CheckoutDiffManager = class {
 
 // ../server/src/server/loop-service.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
-import { promises as fs17 } from "node:fs";
-import path30 from "node:path";
-import { z as z44 } from "zod";
+import { promises as fs18 } from "node:fs";
+import path31 from "node:path";
+import { z as z45 } from "zod";
 var LOOP_ID_LENGTH = 8;
 var DEFAULT_LOOP_PROVIDER = "claude";
 var MAX_VERIFY_OUTPUT_BYTES = 64 * 1024;
-var LoopVerifyPromptSchema = z44.object({
-  passed: z44.boolean(),
-  reason: z44.string().min(1)
-});
-var LoopLogEntrySchema2 = z44.object({
-  seq: z44.number().int().positive(),
-  timestamp: z44.string(),
-  iteration: z44.number().int().positive().nullable(),
-  source: z44.enum(["loop", "worker", "verifier", "verify-check"]),
-  level: z44.enum(["info", "error"]),
-  text: z44.string()
-});
-var LoopVerifyCheckResultSchema2 = z44.object({
-  command: z44.string(),
-  exitCode: z44.number().int(),
-  passed: z44.boolean(),
-  stdout: z44.string(),
-  stderr: z44.string(),
-  startedAt: z44.string(),
-  completedAt: z44.string()
-});
-var LoopVerifyPromptResultSchema2 = z44.object({
-  passed: z44.boolean(),
-  reason: z44.string(),
-  verifierAgentId: z44.string().nullable(),
-  startedAt: z44.string(),
-  completedAt: z44.string()
-});
-var LoopIterationRecordSchema2 = z44.object({
-  index: z44.number().int().positive(),
-  workerAgentId: z44.string().nullable(),
-  workerStartedAt: z44.string(),
-  workerCompletedAt: z44.string().nullable(),
-  verifierAgentId: z44.string().nullable(),
-  status: z44.enum(["running", "succeeded", "failed", "stopped"]),
-  workerOutcome: z44.enum(["completed", "failed", "canceled"]).nullable(),
-  failureReason: z44.string().nullable(),
-  verifyChecks: z44.array(LoopVerifyCheckResultSchema2),
+var LoopVerifyPromptSchema = z45.object({
+  passed: z45.boolean(),
+  reason: z45.string().min(1)
+});
+var LoopLogEntrySchema2 = z45.object({
+  seq: z45.number().int().positive(),
+  timestamp: z45.string(),
+  iteration: z45.number().int().positive().nullable(),
+  source: z45.enum(["loop", "worker", "verifier", "verify-check"]),
+  level: z45.enum(["info", "error"]),
+  text: z45.string()
+});
+var LoopVerifyCheckResultSchema2 = z45.object({
+  command: z45.string(),
+  exitCode: z45.number().int(),
+  passed: z45.boolean(),
+  stdout: z45.string(),
+  stderr: z45.string(),
+  startedAt: z45.string(),
+  completedAt: z45.string()
+});
+var LoopVerifyPromptResultSchema2 = z45.object({
+  passed: z45.boolean(),
+  reason: z45.string(),
+  verifierAgentId: z45.string().nullable(),
+  startedAt: z45.string(),
+  completedAt: z45.string()
+});
+var LoopIterationRecordSchema2 = z45.object({
+  index: z45.number().int().positive(),
+  workerAgentId: z45.string().nullable(),
+  workerStartedAt: z45.string(),
+  workerCompletedAt: z45.string().nullable(),
+  verifierAgentId: z45.string().nullable(),
+  status: z45.enum(["running", "succeeded", "failed", "stopped"]),
+  workerOutcome: z45.enum(["completed", "failed", "canceled"]).nullable(),
+  failureReason: z45.string().nullable(),
+  verifyChecks: z45.array(LoopVerifyCheckResultSchema2),
   verifyPrompt: LoopVerifyPromptResultSchema2.nullable()
 });
-var LoopRecordSchema2 = z44.object({
-  id: z44.string(),
-  name: z44.string().nullable(),
-  prompt: z44.string(),
-  cwd: z44.string(),
-  provider: z44.string(),
-  model: z44.string().nullable(),
-  workerProvider: z44.string().nullable(),
-  workerModel: z44.string().nullable(),
-  verifierProvider: z44.string().nullable(),
-  verifierModel: z44.string().nullable(),
-  verifyPrompt: z44.string().nullable(),
-  verifyChecks: z44.array(z44.string()),
-  archive: z44.boolean(),
-  sleepMs: z44.number().int().nonnegative(),
-  maxIterations: z44.number().int().positive().nullable(),
-  maxTimeMs: z44.number().int().positive().nullable(),
-  status: z44.enum(["running", "succeeded", "failed", "stopped"]),
-  createdAt: z44.string(),
-  updatedAt: z44.string(),
-  startedAt: z44.string(),
-  completedAt: z44.string().nullable(),
-  stopRequestedAt: z44.string().nullable(),
-  iterations: z44.array(LoopIterationRecordSchema2),
-  logs: z44.array(LoopLogEntrySchema2),
-  nextLogSeq: z44.number().int().positive(),
-  activeIteration: z44.number().int().positive().nullable(),
-  activeWorkerAgentId: z44.string().nullable(),
-  activeVerifierAgentId: z44.string().nullable()
-});
-var StoredLoopsSchema = z44.array(LoopRecordSchema2);
+var LoopRecordSchema2 = z45.object({
+  id: z45.string(),
+  name: z45.string().nullable(),
+  prompt: z45.string(),
+  cwd: z45.string(),
+  provider: z45.string(),
+  model: z45.string().nullable(),
+  workerProvider: z45.string().nullable(),
+  workerModel: z45.string().nullable(),
+  verifierProvider: z45.string().nullable(),
+  verifierModel: z45.string().nullable(),
+  verifyPrompt: z45.string().nullable(),
+  verifyChecks: z45.array(z45.string()),
+  archive: z45.boolean(),
+  sleepMs: z45.number().int().nonnegative(),
+  maxIterations: z45.number().int().positive().nullable(),
+  maxTimeMs: z45.number().int().positive().nullable(),
+  status: z45.enum(["running", "succeeded", "failed", "stopped"]),
+  createdAt: z45.string(),
+  updatedAt: z45.string(),
+  startedAt: z45.string(),
+  completedAt: z45.string().nullable(),
+  stopRequestedAt: z45.string().nullable(),
+  iterations: z45.array(LoopIterationRecordSchema2),
+  logs: z45.array(LoopLogEntrySchema2),
+  nextLogSeq: z45.number().int().positive(),
+  activeIteration: z45.number().int().positive().nullable(),
+  activeWorkerAgentId: z45.string().nullable(),
+  activeVerifierAgentId: z45.string().nullable()
+});
+var StoredLoopsSchema = z45.array(LoopRecordSchema2);
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -58969,7 +59333,7 @@ var LoopService = class {
     this.loops = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
     this.running = /* @__PURE__ */ new Map();
-    this.storePath = path30.join(options.appostleHome, "loops", "loops.json");
+    this.storePath = path31.join(options.appostleHome, "loops", "loops.json");
     this.logger = options.logger.child({ module: "loop-service" });
   }
   async initialize() {
@@ -58978,7 +59342,7 @@ var LoopService = class {
     }
     this.loops.clear();
     try {
-      const raw = await fs17.readFile(this.storePath, "utf8");
+      const raw = await fs18.readFile(this.storePath, "utf8");
       const parsed = StoredLoopsSchema.parse(JSON.parse(raw));
       for (const record of parsed) {
         if (record.status === "running") {
@@ -59038,7 +59402,7 @@ var LoopService = class {
       id: createLoopId(),
       name: normalizeName(input.name),
       prompt,
-      cwd: path30.resolve(input.cwd),
+      cwd: path31.resolve(input.cwd),
       provider: input.provider ?? DEFAULT_LOOP_PROVIDER,
       model: normalizePrompt(input.model, "model"),
       workerProvider: input.workerProvider ?? null,
@@ -59486,11 +59850,11 @@ ${output}` : `exit ${result.exitCode}`
   }
   async persist() {
     const nextPersist = this.persistQueue.then(async () => {
-      await fs17.mkdir(path30.dirname(this.storePath), { recursive: true });
+      await fs18.mkdir(path31.dirname(this.storePath), { recursive: true });
       const records = Array.from(this.loops.values()).sort(
         (left, right) => left.createdAt.localeCompare(right.createdAt)
       );
-      await fs17.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
+      await fs18.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
     });
     this.persistQueue = nextPersist.catch(() => {
     });
@@ -60031,20 +60395,20 @@ var ScheduleService = class {
 import { randomUUID as randomUUID15 } from "node:crypto";
 
 // ../server/src/server/quest/store.ts
-import { promises as fs18 } from "node:fs";
-import path31 from "node:path";
-import { z as z45 } from "zod";
-var StoredQuestsSchema = z45.array(QuestRecordSchema);
+import { promises as fs19 } from "node:fs";
+import path32 from "node:path";
+import { z as z46 } from "zod";
+var StoredQuestsSchema = z46.array(QuestRecordSchema);
 var QuestStore = class {
   constructor(options) {
-    this.filePath = path31.join(options.appostleHome, "quests", "quests.json");
+    this.filePath = path32.join(options.appostleHome, "quests", "quests.json");
     this.logger = options.logger;
     this.records = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
   }
   async initialize() {
     try {
-      const raw = await fs18.readFile(this.filePath, "utf8");
+      const raw = await fs19.readFile(this.filePath, "utf8");
       const parsed = StoredQuestsSchema.parse(JSON.parse(raw));
       this.records = new Map(parsed.map((r) => [r.id, r]));
     } catch (err) {
@@ -60078,9 +60442,9 @@ var QuestStore = class {
   }
   async persist() {
     this.persistQueue = this.persistQueue.then(async () => {
-      await fs18.mkdir(path31.dirname(this.filePath), { recursive: true });
+      await fs19.mkdir(path32.dirname(this.filePath), { recursive: true });
       const payload = JSON.stringify([...this.records.values()], null, 2);
-      await fs18.writeFile(this.filePath, payload, "utf8");
+      await fs19.writeFile(this.filePath, payload, "utf8");
     }).catch((err) => {
       this.logger.error(
         { err: err instanceof Error ? err.message : String(err) },
@@ -60138,7 +60502,7 @@ function getRulesForKind(kind) {
 }
 
 // ../server/src/server/quest/quest-metadata-generator.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var MAX_AUTO_QUEST_NAME_CHARS = 40;
 function hasExplicitName(name) {
   return Boolean(name && name.trim().length > 0);
@@ -60150,7 +60514,7 @@ function normalizeAutoName(name) {
   }
   return normalized.slice(0, MAX_AUTO_QUEST_NAME_CHARS).trim() || null;
 }
-function buildPrompt3(prompt) {
+function buildPrompt4(prompt) {
   return [
     "Generate a short label for a multi-agent quest based on the user prompt.",
     `Name: short descriptive label (<= ${MAX_AUTO_QUEST_NAME_CHARS} chars).`,
@@ -60168,8 +60532,8 @@ async function generateAndApplyQuestMetadata(options) {
   if (hasExplicitName(options.explicitName)) {
     return;
   }
-  const schema = z46.object({
-    name: z46.string().min(1).max(MAX_AUTO_QUEST_NAME_CHARS)
+  const schema = z47.object({
+    name: z47.string().min(1).max(MAX_AUTO_QUEST_NAME_CHARS)
   });
   const generator = options.deps?.generateStructuredAgentResponseWithFallback ?? generateStructuredAgentResponseWithFallback;
   let result;
@@ -60177,7 +60541,7 @@ async function generateAndApplyQuestMetadata(options) {
     result = await generator({
       manager: options.questService.agentManager,
       cwd: options.cwd,
-      prompt: buildPrompt3(prompt),
+      prompt: buildPrompt4(prompt),
       schema,
       schemaName: "QuestMetadata",
       maxRetries: 2,
@@ -60844,17 +61208,17 @@ ${text || "(no output)"}`).join("\n\n");
 
 // ../server/src/server/quest/runner-orchestrator.ts
 import { access, readFile as readFile5 } from "node:fs/promises";
-import path32 from "node:path";
+import path33 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../server/src/server/quest/orchestrator-mcp.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var HANDOFF_INPUT_SHAPE = {
-  rolePath: z47.string().min(1).describe(
+  rolePath: z48.string().min(1).describe(
     "Absolute filesystem path to the role .md file the worker should adopt as its system prompt. Must be one of the role file paths listed in your team roster \u2014 do not invent paths."
   ),
-  task: z47.string().min(1).describe(
+  task: z48.string().min(1).describe(
     "Concrete, self-contained instruction for the worker. The worker has its own toolbelt and reads the role at rolePath as its system prompt \u2014 write the task as a normal user message describing what to do, what inputs to read, and where to write outputs. Reference the hivemind doc by absolute path if relevant."
   )
 };
@@ -61075,16 +61439,16 @@ var FALLBACK_QUEEN_PROMPT_TEMPLATE = [
 var QUEEN_PROMPT_FILENAME = "queen-prompt.md";
 var QUEEN_PROMPT_MAX_LOOKUP_LEVELS = 10;
 async function findQueenPromptOnDisk() {
-  const start = path32.dirname(fileURLToPath5(import.meta.url));
+  const start = path33.dirname(fileURLToPath5(import.meta.url));
   let cursor = start;
   for (let i = 0; i < QUEEN_PROMPT_MAX_LOOKUP_LEVELS; i += 1) {
-    const candidate = path32.join(cursor, QUEEN_PROMPT_FILENAME);
+    const candidate = path33.join(cursor, QUEEN_PROMPT_FILENAME);
     try {
       await access(candidate);
       return candidate;
     } catch {
     }
-    const parent = path32.dirname(cursor);
+    const parent = path33.dirname(cursor);
     if (parent === cursor) break;
     cursor = parent;
   }
@@ -61130,7 +61494,7 @@ async function resolveWorkerConfigForHandoff(args) {
     title: `quest ${record.id} handoff: ${taskTitle}`,
     internal: true
   };
-  const roleName = path32.basename(rolePath, path32.extname(rolePath));
+  const roleName = path33.basename(rolePath, path33.extname(rolePath));
   try {
     const resolved = await resolveRole({
       roleName,
@@ -61309,7 +61673,7 @@ var OrchestratorRunner = class {
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
 import { appendFile, mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
-import path33 from "node:path";
+import path34 from "node:path";
 var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
 function nowIso5() {
@@ -61384,7 +61748,7 @@ function runContainsPromise(run, completionPromise) {
   return finalText.includes(completionPromise);
 }
 function resolveRalphStatePaths(cwd) {
-  const dir = path33.join(cwd, ".hiveminds", "ralph loop");
+  const dir = path34.join(cwd, ".hiveminds", "ralph loop");
   return {
     dir,
     logPath: ""
@@ -61394,7 +61758,7 @@ async function initializeRalphState(args) {
   const base = resolveRalphStatePaths(args.record.cwd);
   const paths = {
     dir: base.dir,
-    logPath: path33.join(base.dir, `ralphloop_${args.record.id}.md`)
+    logPath: path34.join(base.dir, `ralphloop_${args.record.id}.md`)
   };
   await mkdir9(paths.dir, { recursive: true });
   await writeFile8(
@@ -61629,8 +61993,8 @@ function deepMerge(current, patch) {
   }
   return next;
 }
-function getValueAtPath(config, path39) {
-  return path39.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
+function getValueAtPath(config, path40) {
+  return path40.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
 }
 function isEqualValue(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
@@ -61649,20 +62013,20 @@ var DaemonConfigStore = class {
   patch(partial) {
     const parsedPatch = MutableDaemonConfigPatchSchema.parse(partial);
     const next = MutableDaemonConfigSchema.parse(deepMerge(this.current, parsedPatch));
-    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path39) => {
-      return !isEqualValue(getValueAtPath(this.current, path39), getValueAtPath(next, path39));
+    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path40) => {
+      return !isEqualValue(getValueAtPath(this.current, path40), getValueAtPath(next, path40));
     });
     if (changedFieldPaths.length === 0 && isEqualValue(this.current, next)) {
       return this.current;
     }
     this.persistConfig(next);
     this.current = next;
-    for (const path39 of changedFieldPaths) {
-      const handlers = this.fieldChangeHandlers.get(path39);
+    for (const path40 of changedFieldPaths) {
+      const handlers = this.fieldChangeHandlers.get(path40);
       if (!handlers) {
         continue;
       }
-      const value = getValueAtPath(next, path39);
+      const value = getValueAtPath(next, path40);
       for (const handler of handlers) {
         handler(value);
       }
@@ -61672,18 +62036,18 @@ var DaemonConfigStore = class {
     }
     return next;
   }
-  onFieldChange(path39, handler) {
-    const handlers = this.fieldChangeHandlers.get(path39) ?? /* @__PURE__ */ new Set();
+  onFieldChange(path40, handler) {
+    const handlers = this.fieldChangeHandlers.get(path40) ?? /* @__PURE__ */ new Set();
     handlers.add(handler);
-    this.fieldChangeHandlers.set(path39, handlers);
+    this.fieldChangeHandlers.set(path40, handlers);
     return () => {
-      const currentHandlers = this.fieldChangeHandlers.get(path39);
+      const currentHandlers = this.fieldChangeHandlers.get(path40);
       if (!currentHandlers) {
         return;
       }
       currentHandlers.delete(handler);
       if (currentHandlers.size === 0) {
-        this.fieldChangeHandlers.delete(path39);
+        this.fieldChangeHandlers.delete(path40);
       }
     };
   }
@@ -62576,13 +62940,13 @@ function createTerminalManager() {
 }
 
 // ../server/src/shared/connection-offer.ts
-import { z as z48 } from "zod";
-var ConnectionOfferV2Schema = z48.object({
-  v: z48.literal(2),
-  serverId: z48.string().min(1),
-  daemonPublicKeyB64: z48.string().min(1),
-  relay: z48.object({
-    endpoint: z48.string().min(1)
+import { z as z49 } from "zod";
+var ConnectionOfferV2Schema = z49.object({
+  v: z49.literal(2),
+  serverId: z49.string().min(1),
+  daemonPublicKeyB64: z49.string().min(1),
+  relay: z49.object({
+    endpoint: z49.string().min(1)
   })
 });
 
@@ -63229,7 +63593,7 @@ function createAuthServerClient(options) {
 
 // ../server/src/server/package-version.ts
 import { existsSync as existsSync19, readFileSync as readFileSync10 } from "node:fs";
-import path34 from "node:path";
+import path35 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 var PackageVersionResolutionError = class extends Error {
   constructor(params) {
@@ -63239,9 +63603,9 @@ var PackageVersionResolutionError = class extends Error {
 };
 function resolvePackageVersion(params) {
   const moduleUrl = params.moduleUrl ?? import.meta.url;
-  let currentDir = path34.dirname(fileURLToPath6(moduleUrl));
+  let currentDir = path35.dirname(fileURLToPath6(moduleUrl));
   while (true) {
-    const packageJsonPath = path34.join(currentDir, "package.json");
+    const packageJsonPath = path35.join(currentDir, "package.json");
     if (existsSync19(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
@@ -63260,7 +63624,7 @@ function resolvePackageVersion(params) {
         }
       }
     }
-    const parentDir = path34.dirname(currentDir);
+    const parentDir = path35.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -63765,11 +64129,11 @@ async function createAppostleDaemon(config, rootLogger) {
     httpServer.on("upgrade", scriptProxyUpgradeHandler);
     const agentStorage = new AgentStorage(config.agentStoragePath, logger);
     const projectRegistry = new FileBackedProjectRegistry(
-      path35.join(config.appostleHome, "projects", "projects.json"),
+      path36.join(config.appostleHome, "projects", "projects.json"),
       logger
     );
     workspaceRegistry = new FileBackedWorkspaceRegistry(
-      path35.join(config.appostleHome, "projects", "workspaces.json"),
+      path36.join(config.appostleHome, "projects", "workspaces.json"),
       logger
     );
     const chatService = new FileBackedChatService({
@@ -63787,6 +64151,7 @@ async function createAppostleDaemon(config, rootLogger) {
       registry: agentStorage,
       appostleHome: config.appostleHome,
       chromeEnabled: config.chromeEnabled ?? true,
+      playwrightEnabled: config.playwrightEnabled ?? true,
       ownerUserId: ownerUserId ?? void 0,
       logger
     });
@@ -64211,22 +64576,22 @@ async function closeAllAgents(logger, agentManager) {
 }
 
 // ../server/src/server/config.ts
-import path37 from "node:path";
-import { z as z52 } from "zod";
+import path38 from "node:path";
+import { z as z53 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
-import path36 from "node:path";
-import { z as z49 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path36.join("models", "local-speech");
-var NumberLikeSchema2 = z49.union([z49.number(), z49.string().trim().min(1)]);
-var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z49.coerce.number().finite()).optional();
-var OptionalIntegerSchema = NumberLikeSchema2.pipe(z49.coerce.number().int()).optional();
-var LocalSpeechResolutionSchema = z49.object({
-  includeProviderConfig: z49.boolean(),
-  modelsDir: z49.string().trim().min(1),
+import path37 from "node:path";
+import { z as z50 } from "zod";
+var DEFAULT_LOCAL_MODELS_SUBDIR = path37.join("models", "local-speech");
+var NumberLikeSchema2 = z50.union([z50.number(), z50.string().trim().min(1)]);
+var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z50.coerce.number().finite()).optional();
+var OptionalIntegerSchema = NumberLikeSchema2.pipe(z50.coerce.number().int()).optional();
+var LocalSpeechResolutionSchema = z50.object({
+  includeProviderConfig: z50.boolean(),
+  modelsDir: z50.string().trim().min(1),
   dictationLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
   voiceLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
   voiceLocalTtsModel: LocalTtsModelIdSchema.default(DEFAULT_LOCAL_TTS_MODEL),
@@ -64247,7 +64612,7 @@ function resolveLocalSpeechConfig(params) {
   const includeProviderConfig = shouldIncludeLocalProviderConfig(params);
   const parsed = LocalSpeechResolutionSchema.parse({
     includeProviderConfig,
-    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path36.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path37.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
     dictationLocalSttModel: params.env.APPOSTLE_DICTATION_LOCAL_STT_MODEL ?? persistedLocalFeatureModel(
       params.providers.dictationStt.provider,
       params.providers.dictationStt.enabled,
@@ -64282,17 +64647,17 @@ function resolveLocalSpeechConfig(params) {
 }
 
 // ../server/src/server/speech/speech-types.ts
-import { z as z50 } from "zod";
-var SpeechProviderIdSchema2 = z50.enum(["openai", "local"]);
-var RequestedSpeechProviderSchema = z50.object({
+import { z as z51 } from "zod";
+var SpeechProviderIdSchema2 = z51.enum(["openai", "local"]);
+var RequestedSpeechProviderSchema = z51.object({
   provider: SpeechProviderIdSchema2,
-  explicit: z50.boolean(),
-  enabled: z50.boolean().optional()
+  explicit: z51.boolean(),
+  enabled: z51.boolean().optional()
 });
 
 // ../server/src/server/speech/speech-config-resolver.ts
-var OptionalSpeechProviderSchema = z51.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
-var OptionalBooleanFlagSchema = z51.union([z51.boolean(), z51.string().trim().toLowerCase()]).optional().transform((value) => {
+var OptionalSpeechProviderSchema = z52.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
+var OptionalBooleanFlagSchema = z52.union([z52.boolean(), z52.string().trim().toLowerCase()]).optional().transform((value) => {
   if (typeof value === "boolean") {
     return value;
   }
@@ -64307,7 +64672,7 @@ var OptionalBooleanFlagSchema = z51.union([z51.boolean(), z51.string().trim().to
   }
   return void 0;
 });
-var RequestedSpeechProvidersSchema = z51.object({
+var RequestedSpeechProvidersSchema = z52.object({
   dictationStt: OptionalSpeechProviderSchema.default("local"),
   voiceTurnDetection: OptionalSpeechProviderSchema.default("local"),
   voiceStt: OptionalSpeechProviderSchema.default("local"),
@@ -64416,9 +64781,9 @@ function parseBooleanEnv(value) {
   }
   return void 0;
 }
-var OptionalVoiceLlmProviderSchema = z52.union([z52.string(), z52.null(), z52.undefined()]).transform(
+var OptionalVoiceLlmProviderSchema = z53.union([z53.string(), z53.null(), z53.undefined()]).transform(
   (value) => typeof value === "string" ? value.trim().toLowerCase() : null
-).pipe(z52.union([AgentProviderSchema, z52.null()]));
+).pipe(z53.union([AgentProviderSchema, z53.null()]));
 function parseOptionalVoiceLlmProvider(value) {
   const parsed = OptionalVoiceLlmProviderSchema.safeParse(value);
   return parsed.success ? parsed.data : null;
@@ -64471,6 +64836,7 @@ function loadConfig(appostleHome, options) {
   const mcpEnabled = options?.cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true;
   const mcpInjectIntoAgents = options?.cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? false;
   const chromeEnabled = persisted.daemon?.chrome?.enabled ?? true;
+  const playwrightEnabled = persisted.daemon?.playwright?.enabled ?? true;
   const daemonIcon = persisted.daemon?.identity?.icon;
   const relayEnabled = options?.cli?.relayEnabled ?? parseBooleanEnv(env.APPOSTLE_RELAY_ENABLED) ?? persisted.daemon?.relay?.enabled ?? true;
   const relayEndpoint = env.APPOSTLE_RELAY_ENDPOINT ?? persisted.daemon?.relay?.endpoint ?? DEFAULT_RELAY_ENDPOINT;
@@ -64501,9 +64867,10 @@ function loadConfig(appostleHome, options) {
     mcpEnabled,
     mcpInjectIntoAgents,
     chromeEnabled,
+    playwrightEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
-    agentStoragePath: path37.join(appostleHome, "agents"),
+    agentStoragePath: path38.join(appostleHome, "agents"),
     staticDir: "public",
     agentClients: {},
     relayEnabled,
@@ -64522,7 +64889,7 @@ function loadConfig(appostleHome, options) {
 
 // ../server/src/server/logger.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync8, readdirSync as readdirSync3, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import path38 from "node:path";
+import path39 from "node:path";
 import pino from "pino";
 import pretty from "pino-pretty";
 import { createStream as createRotatingFileStream } from "rotating-file-stream";
@@ -64565,14 +64932,14 @@ function parsePositiveInteger(value) {
   return parsed;
 }
 function resolveFilePath(appostleHome, configuredPath) {
-  const fallback = path38.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
+  const fallback = path39.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
   if (!configuredPath) {
     return fallback;
   }
-  if (path38.isAbsolute(configuredPath)) {
+  if (path39.isAbsolute(configuredPath)) {
     return configuredPath;
   }
-  return path38.resolve(appostleHome, configuredPath);
+  return path39.resolve(appostleHome, configuredPath);
 }
 function minLogLevel(levels) {
   let minLevel = levels[0];
@@ -64609,20 +64976,20 @@ function normalizeLoggerConfigInput(config) {
 }
 function rotateOnRestart(filePath, maxFiles) {
   if (!existsSync21(filePath)) return;
-  const dir = path38.dirname(filePath);
-  const base = path38.basename(filePath);
+  const dir = path39.dirname(filePath);
+  const base = path39.basename(filePath);
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
   const ts = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
   try {
-    renameSync3(filePath, path38.join(dir, `${ts}-00-${base}`));
+    renameSync3(filePath, path39.join(dir, `${ts}-00-${base}`));
   } catch {
     return;
   }
   const rotatedFiles = readdirSync3(dir).filter((f) => f.endsWith(`-${base}`) && f !== base).sort().reverse();
   for (const file of rotatedFiles.slice(maxFiles)) {
     try {
-      unlinkSync2(path38.join(dir, file));
+      unlinkSync2(path39.join(dir, file));
     } catch {
     }
   }
@@ -64671,15 +65038,15 @@ function resolveLogConfig(configInput, options) {
 }
 function createRootLogger(configInput, options) {
   const config = resolveLogConfig(configInput, options);
-  mkdirSync8(path38.dirname(config.file.path), { recursive: true });
+  mkdirSync8(path39.dirname(config.file.path), { recursive: true });
   const consoleStream = config.console.format === "pretty" ? pretty({
     colorize: true,
     singleLine: true,
     ignore: "pid,hostname"
   }) : pino.destination({ dest: 1, sync: false });
   rotateOnRestart(config.file.path, config.file.rotate.maxFiles);
-  const fileStream = createRotatingFileStream(path38.basename(config.file.path), {
-    path: path38.dirname(config.file.path),
+  const fileStream = createRotatingFileStream(path39.basename(config.file.path), {
+    path: path39.dirname(config.file.path),
     size: toRotatingFileStreamSize(config.file.rotate.maxSize),
     maxFiles: config.file.rotate.maxFiles
   });