appostle-installer 0.0.20 → 0.0.22

package/dist/appostle.js

@@ -3234,7 +3234,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(),
@@ -3411,6 +3413,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(),
@@ -3498,6 +3516,7 @@ var GoogleFontsDownloadResponseSchema = z10.object({
 });
 
 // ../server/src/shared/messages.ts
+var InitialAgentSnapshotPageLimit = 200;
 var MutableDaemonConfigSchema = z11.object({
   mcp: z11.object({
     injectIntoAgents: z11.boolean()
@@ -5531,6 +5550,7 @@ var SessionInboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutRequestSchema,
   BrandLayoutQaNextRequestSchema,
   BrandGenerateWireframeRequestSchema,
+  BrandAnalyzePhotographyRequestSchema,
   RightFontLibraryRequestSchema,
   GoogleFontsCatalogRequestSchema,
   GoogleFontsDownloadRequestSchema,
@@ -5990,6 +6010,17 @@ var FetchAgentsResponseMessageSchema = z11.object({
     })
   })
 });
+var InitialAgentSnapshotMessageSchema = z11.object({
+  type: z11.literal("initial_agent_snapshot"),
+  payload: z11.object({
+    entries: z11.array(
+      z11.object({
+        agent: AgentSnapshotPayloadSchema,
+        project: ProjectPlacementPayloadSchema
+      })
+    )
+  })
+});
 var FetchWorkspacesResponseMessageSchema = z11.object({
   type: z11.literal("fetch_workspaces_response"),
   payload: z11.object({
@@ -7031,6 +7062,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   AgentStreamMessageSchema,
   AgentStatusMessageSchema,
   FetchAgentsResponseMessageSchema,
+  InitialAgentSnapshotMessageSchema,
   FetchWorkspacesResponseMessageSchema,
   OpenProjectResponseMessageSchema,
   StartWorkspaceScriptResponseMessageSchema,
@@ -7155,6 +7187,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutResponseSchema,
   BrandLayoutQaNextResponseSchema,
   BrandGenerateWireframeResponseSchema,
+  BrandAnalyzePhotographyResponseSchema,
   RightFontLibraryResponseSchema,
   GoogleFontsCatalogResponseSchema,
   GoogleFontsDownloadResponseSchema,
@@ -7364,7 +7397,7 @@ import { exec } from "node:child_process";
 import { promisify as promisify3 } from "util";
 import { join as join14, resolve as resolve9, sep as sep2 } from "path";
 import { homedir as homedir5, 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";
@@ -20714,6 +20747,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 {
@@ -20755,8 +20794,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;
@@ -20929,6 +21006,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;
@@ -34959,10 +35074,12 @@ async function readBrandsFromDir(scope, dir) {
       continue;
     }
     let parsed;
+    let body = "";
     try {
       const text = await fs11.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: [] };
     }
@@ -34974,7 +35091,8 @@ async function readBrandsFromDir(scope, dir) {
       variables: parsed.variables,
       path: fullPath,
       modifiedAt: stat5.mtime.toISOString(),
-      size: stat5.size
+      size: stat5.size,
+      body
     });
   }
   results.sort((a, b) => a.name.localeCompare(b.name));
@@ -35413,11 +35531,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 fs12 } from "node:fs";
 import path20 from "node:path";
 import { fileURLToPath as fileURLToPath2 } 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;
@@ -35452,34 +35691,34 @@ async function writeRoleFile(workspaceRoot, content) {
   await fs12.mkdir(path20.dirname(filePath), { recursive: true });
   await fs12.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 = [];
@@ -37154,7 +37393,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) {
@@ -37469,9 +37708,35 @@ var Session = class _Session {
     this.emit(message);
   }
   /**
-   * Send initial state to client after connection
+   * Push the first page of the agent directory unsolicited right after
+   * `server_info` so the client can paint attention state before its own
+   * paginated `fetch_agents_request` round-trip lands. The regular fetch
+   * still runs in parallel — it establishes the live-update subscription
+   * and paginates beyond the first page. This push exists purely to shave
+   * one relay round-trip from time-to-first-paint.
+   *
+   * Errors are swallowed: a failed push degrades to "wait for the client
+   * to ask," which is still correct.
    */
   async sendInitialState() {
+    try {
+      const synthetic = {
+        type: "fetch_agents_request",
+        requestId: "internal:initial-snapshot",
+        filter: { includeArchived: true },
+        page: { limit: InitialAgentSnapshotPageLimit }
+      };
+      const { entries } = await this.listFetchAgentsEntries(synthetic);
+      this.emit({
+        type: "initial_agent_snapshot",
+        payload: { entries }
+      });
+    } catch (error) {
+      this.sessionLogger.warn(
+        { err: error },
+        "Failed to push initial agent snapshot \u2014 client will fall back to fetch_agents_request"
+      );
+    }
   }
   /**
    * Normalize a user prompt (with optional image metadata) for AgentManager
@@ -38509,6 +38774,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;
@@ -40168,8 +40436,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."
       )
     });
@@ -40214,9 +40482,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:",
@@ -45708,6 +45976,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 {
@@ -46269,7 +46569,7 @@ import webpush from "web-push";
 import webpush2 from "web-push";
 
 // ../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",
@@ -46362,7 +46662,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"
@@ -46393,20 +46693,20 @@ import { v4 as uuidv410 } from "uuid";
 import { v4 as uuidv411 } from "uuid";
 
 // ../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
   )
@@ -46451,177 +46751,177 @@ import { v4 } from "uuid";
 import OpenAI2 from "openai";
 
 // ../server/src/server/agent/agent-storage.ts
-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()
 });
 
 // ../server/src/server/agent/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z43 } from "zod";
-var TerminalSummarySchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  cwd: z43.string()
+import { z as z44 } from "zod";
+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()
 });
 
 // ../server/src/server/loop-service.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 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);
 
 // ../server/src/server/quest/store.ts
-import { z as z45 } from "zod";
-var StoredQuestsSchema = z45.array(QuestRecordSchema);
+import { z as z46 } from "zod";
+var StoredQuestsSchema = z46.array(QuestRecordSchema);
 
 // ../server/src/server/quest/quest-metadata-generator.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../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."
   )
 };
@@ -46676,13 +46976,13 @@ var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
 
 // ../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)
   })
 });
 
@@ -46716,21 +47016,21 @@ function isRelayClientWebSocketUrl(url) {
 
 // ../server/src/server/config.ts
 import path22 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 path21 from "node:path";
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 var DEFAULT_LOCAL_MODELS_SUBDIR = path21.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),
@@ -46786,17 +47086,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;
   }
@@ -46811,7 +47111,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"),
@@ -46920,9 +47220,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;
@@ -47296,6 +47596,9 @@ function createEncryptedTransport(base, daemonPublicKeyB64, logger, staticKeyPai
         throw new Error("Encrypted channel not ready");
       }
       void channel.send(normalizeTransportPayload(data)).catch((error) => {
+        if (closed) {
+          console.error("[relay-e2ee] send failed after transport close:", error);
+        }
         emitError(error);
       });
     },
@@ -50898,6 +51201,20 @@ var DaemonClient = class {
       timeout: 12e4
     });
   }
+  async brandsAnalyzePhotography(options) {
+    return this.sendCorrelatedSessionRequest({
+      requestId: options.requestId,
+      message: {
+        type: "brands/analyze-photography",
+        workspaceRoot: options.workspaceRoot,
+        brandPath: options.brandPath,
+        brief: options.brief,
+        ...options.referenceDescriptions ? { referenceDescriptions: options.referenceDescriptions } : {}
+      },
+      responseType: "brands/analyze-photography/response",
+      timeout: 12e4
+    });
+  }
   onTerminalStreamEvent(handler) {
     this.terminalStreamListeners.add(handler);
     return () => {