appostle-installer 0.0.21 → 0.0.22

package/dist/worker.js

@@ -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(),
@@ -6273,6 +6291,7 @@ var SessionInboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutRequestSchema,
   BrandLayoutQaNextRequestSchema,
   BrandGenerateWireframeRequestSchema,
+  BrandAnalyzePhotographyRequestSchema,
   RightFontLibraryRequestSchema,
   GoogleFontsCatalogRequestSchema,
   GoogleFontsDownloadRequestSchema,
@@ -7909,6 +7928,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutResponseSchema,
   BrandLayoutQaNextResponseSchema,
   BrandGenerateWireframeResponseSchema,
+  BrandAnalyzePhotographyResponseSchema,
   RightFontLibraryResponseSchema,
   GoogleFontsCatalogResponseSchema,
   GoogleFontsDownloadResponseSchema,
@@ -8157,7 +8177,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";
@@ -22192,6 +22212,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 +22259,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 +22471,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;
@@ -33722,18 +33824,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."
@@ -40159,10 +40250,12 @@ async function readBrandsFromDir(scope, dir) {
       continue;
     }
     let parsed;
+    let body = "";
     try {
       const text = await fs14.readFile(fullPath, "utf8");
-      const { rawFrontmatterLines, hadFrontmatter } = parseBrandFile(text);
+      const { rawFrontmatterLines, body: parsedBody, hadFrontmatter } = parseBrandFile(text);
       parsed = hadFrontmatter ? parseFrontmatter2(rawFrontmatterLines) : { description: "", variables: [] };
+      body = parsedBody;
     } catch {
       parsed = { description: "", variables: [] };
     }
@@ -40174,7 +40267,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));
@@ -40613,11 +40707,132 @@ 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 { 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;
@@ -40652,34 +40867,34 @@ async function writeRoleFile(workspaceRoot, content) {
   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)
+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 = [];
@@ -42364,7 +42579,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 +43960,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 +45622,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 +45668,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:",
@@ -50944,6 +51162,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 {
@@ -53808,7 +54058,7 @@ 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 +54151,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"
@@ -55533,20 +55783,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
   )
@@ -56660,70 +56910,70 @@ function createSpeechService(params) {
 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 { 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);
@@ -56967,7 +57217,7 @@ async function writeFileAtomically(targetPath, payload) {
 
 // ../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 +57350,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 +57496,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 +57545,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 +57581,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 +57780,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 +57847,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 +57924,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 +57971,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 +57999,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 +58022,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 +58043,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 +58064,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 +58101,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 +58139,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 +58168,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 +58195,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 +58236,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 +58268,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 +58320,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 +58342,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 +58363,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 +58386,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 +58409,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 +58433,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 +58460,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 +58488,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 +58512,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 +58558,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 +58585,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 +58633,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 +58656,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 +58686,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 }) => {
@@ -58764,81 +59014,81 @@ var CheckoutDiffManager = class {
 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 { 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();
 }
@@ -60033,8 +60283,8 @@ 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 { z as z46 } from "zod";
+var StoredQuestsSchema = z46.array(QuestRecordSchema);
 var QuestStore = class {
   constructor(options) {
     this.filePath = path31.join(options.appostleHome, "quests", "quests.json");
@@ -60138,7 +60388,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 +60400,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 +60418,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 +60427,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,
@@ -60849,12 +61099,12 @@ 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."
   )
 };
@@ -62576,13 +62826,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)
   })
 });
 
@@ -64212,21 +64462,21 @@ async function closeAllAgents(logger, agentManager) {
 
 // ../server/src/server/config.ts
 import path37 from "node:path";
-import { z as z52 } from "zod";
+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";
+import { z as z50 } 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),
+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),
@@ -64282,17 +64532,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 +64557,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 +64666,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;