appostle-installer 0.0.21 → 0.0.23

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(),
@@ -3510,10 +3528,14 @@ var MutableDaemonConfigSchema = z11.object({
     icon: z11.string().optional()
   }).passthrough().optional(),
   chrome: z11.object({
-    // When false, agents on this host won't get the --chrome flag,
-    // preventing the client's Chrome browser from being controlled.
-    // Useful on headless servers where browser tools should target
-    // a local headless Chrome instead of the remote client's browser.
+    // When false, agents on this host won't have the claude-in-chrome
+    // tools injected. Set to false on hosts where the client's browser
+    // should not be controlled (e.g. headless/server-only hosts).
+    enabled: z11.boolean()
+  }).passthrough().optional(),
+  playwright: z11.object({
+    // When false, agents on this host won't have the Playwright MCP
+    // server injected.
     enabled: z11.boolean()
   }).passthrough().optional()
 }).passthrough();
@@ -3522,7 +3544,8 @@ var MutableDaemonConfigPatchSchema = z11.object({
   identity: z11.object({
     icon: z11.string().optional()
   }).partial().passthrough().optional(),
-  chrome: MutableDaemonConfigSchema.shape.chrome
+  chrome: MutableDaemonConfigSchema.shape.chrome,
+  playwright: MutableDaemonConfigSchema.shape.playwright
 }).partial().passthrough();
 var AgentStatusSchema = z11.enum(AGENT_LIFECYCLE_STATUSES);
 var AgentModeSchema = z11.object({
@@ -5532,6 +5555,7 @@ var SessionInboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutRequestSchema,
   BrandLayoutQaNextRequestSchema,
   BrandGenerateWireframeRequestSchema,
+  BrandAnalyzePhotographyRequestSchema,
   RightFontLibraryRequestSchema,
   GoogleFontsCatalogRequestSchema,
   GoogleFontsDownloadRequestSchema,
@@ -7168,6 +7192,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   BrandGenerateLayoutResponseSchema,
   BrandLayoutQaNextResponseSchema,
   BrandGenerateWireframeResponseSchema,
+  BrandAnalyzePhotographyResponseSchema,
   RightFontLibraryResponseSchema,
   GoogleFontsCatalogResponseSchema,
   GoogleFontsDownloadResponseSchema,
@@ -7377,7 +7402,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";
@@ -7674,6 +7699,9 @@ var PersistedConfigSchema = z14.object({
     }).strict().optional(),
     chrome: z14.object({
       enabled: z14.boolean().optional()
+    }).strict().optional(),
+    playwright: z14.object({
+      enabled: z14.boolean().optional()
     }).strict().optional()
   }).strict().transform(({ allowedHosts, ...daemon }) => {
     const hostnames = daemon.hostnames ?? allowedHosts;
@@ -18494,6 +18522,7 @@ var ClaudeAgentClient = class {
       runtimeSettings: this.runtimeSettings,
       launchEnv: launchContext?.env,
       chromeEnabled: launchContext?.chromeEnabled,
+      playwrightEnabled: launchContext?.playwrightEnabled,
       logger: this.logger,
       queryFactory: this.queryFactory
     });
@@ -18512,6 +18541,7 @@ var ClaudeAgentClient = class {
       handle,
       launchEnv: launchContext?.env,
       chromeEnabled: launchContext?.chromeEnabled,
+      playwrightEnabled: launchContext?.playwrightEnabled,
       logger: this.logger,
       queryFactory: this.queryFactory
     });
@@ -18826,6 +18856,7 @@ var ClaudeAgentSession = class {
     this.config = config;
     this.launchEnv = options.launchEnv;
     this.chromeEnabled = options.chromeEnabled ?? true;
+    this.playwrightEnabled = options.playwrightEnabled ?? true;
     this.defaults = options.defaults;
     this.runtimeSettings = options.runtimeSettings;
     this.logger = options.logger;
@@ -19589,7 +19620,8 @@ var ClaudeAgentSession = class {
     } else {
       const homeMcps = loadHomeMcpServers(this.logger);
       if (homeMcps) {
-        base.mcpServers = this.normalizeMcpServers(homeMcps);
+        const filtered = this.playwrightEnabled ? homeMcps : Object.fromEntries(Object.entries(homeMcps).filter(([k]) => k !== "playwright"));
+        base.mcpServers = this.normalizeMcpServers(filtered);
       }
     }
     if (this.config.model) {
@@ -20727,6 +20759,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 {
@@ -20768,8 +20806,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;
@@ -20942,6 +21018,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;
@@ -31425,6 +31539,330 @@ function removeClaudeProfile(username, logger) {
 import { z as z34 } from "zod";
 import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
 
+// ../server/src/server/skills/scanner.ts
+import fs8 from "node:fs/promises";
+import os6 from "node:os";
+import path14 from "node:path";
+var NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/i;
+function homeDir() {
+  return process.env.HOME || os6.homedir();
+}
+function codexHomeDir() {
+  return process.env.CODEX_HOME || path14.join(homeDir(), ".codex");
+}
+function resolveScopeDir(provider, scope, workspaceRoot) {
+  if (scope === "codex-prompts") {
+    if (provider !== "codex") {
+      throw new Error(`Scope "codex-prompts" is only valid for provider "codex"`);
+    }
+    return path14.join(codexHomeDir(), "prompts");
+  }
+  if (scope === "project") {
+    if (!workspaceRoot) {
+      throw new Error(`workspaceRoot is required for scope "project"`);
+    }
+    const dotDir = provider === "claude" ? ".claude" : ".codex";
+    return path14.join(workspaceRoot, dotDir, "skills");
+  }
+  if (provider === "claude") {
+    return path14.join(homeDir(), ".claude", "skills");
+  }
+  return path14.join(codexHomeDir(), "skills");
+}
+function allowedRoots(workspaceRoot) {
+  const roots = [
+    path14.join(homeDir(), ".claude", "skills"),
+    path14.join(codexHomeDir(), "skills"),
+    path14.join(codexHomeDir(), "prompts")
+  ];
+  if (workspaceRoot) {
+    roots.push(path14.join(workspaceRoot, ".claude", "skills"));
+    roots.push(path14.join(workspaceRoot, ".codex", "skills"));
+  }
+  return roots.map((r) => path14.resolve(r));
+}
+function isInsideAllowedRoot(absPath, workspaceRoot) {
+  const resolved = path14.resolve(absPath);
+  for (const root of allowedRoots(workspaceRoot)) {
+    const rel = path14.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel)) {
+      return true;
+    }
+  }
+  return false;
+}
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseSkillFile(text) {
+  const match = FRONTMATTER_RE.exec(text);
+  if (!match) {
+    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
+  }
+  const yamlBlock = match[1] ?? "";
+  const body = match[2] ?? "";
+  return {
+    rawFrontmatterLines: yamlBlock.split(/\r?\n/),
+    body,
+    hadFrontmatter: true
+  };
+}
+function readDescription(text) {
+  const parsed = parseSkillFile(text);
+  if (!parsed.hadFrontmatter) return "";
+  for (const line of parsed.rawFrontmatterLines) {
+    const m = /^description\s*:\s*(.*)$/.exec(line);
+    if (m) {
+      const value = (m[1] ?? "").trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+      }
+      return value;
+    }
+  }
+  return "";
+}
+function findOwnedSpans(lines) {
+  const spans = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    const value = keyMatch[2];
+    if (key !== "description" && key !== "argument-hint" && key !== "allowed-tools") {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    if (value === "") {
+      while (end < lines.length) {
+        const next = lines[end] ?? "";
+        if (/^\s+-\s+/.test(next) || /^\s*$/.test(next)) {
+          end++;
+        } else {
+          break;
+        }
+      }
+    }
+    spans.push({ key, startLine: i, endLine: end });
+    i = end;
+  }
+  return spans;
+}
+function emitFrontmatterValue(key, value) {
+  if (key === "allowed-tools") {
+    if (!Array.isArray(value) || value.length === 0) return [];
+    return [`allowed-tools:`, ...value.map((v) => `  - ${v}`)];
+  }
+  const text = typeof value === "string" ? value : "";
+  if (text.length === 0) return [];
+  const needsQuote = /[:#\n]/.test(text) || text.startsWith(" ") || text.endsWith(" ");
+  const formatted = needsQuote ? `"${text.replace(/"/g, '\\"')}"` : text;
+  return [`${key}: ${formatted}`];
+}
+function rewriteFrontmatter(originalLines, next) {
+  const spans = findOwnedSpans(originalLines);
+  const ownedKeys = new Set(spans.map((s) => s.key));
+  const replacements = /* @__PURE__ */ new Map();
+  if (next.description !== void 0) {
+    replacements.set("description", emitFrontmatterValue("description", next.description));
+  }
+  if (next.argumentHint !== void 0) {
+    replacements.set("argument-hint", emitFrontmatterValue("argument-hint", next.argumentHint));
+  }
+  if (next.allowedTools !== void 0) {
+    replacements.set("allowed-tools", emitFrontmatterValue("allowed-tools", next.allowedTools));
+  }
+  const out = [];
+  let i = 0;
+  while (i < originalLines.length) {
+    const span = spans.find((s) => s.startLine === i);
+    if (span) {
+      if (replacements.has(span.key)) {
+        out.push(...replacements.get(span.key) ?? []);
+      } else {
+        for (let j = span.startLine; j < span.endLine; j++) {
+          out.push(originalLines[j] ?? "");
+        }
+      }
+      i = span.endLine;
+      continue;
+    }
+    out.push(originalLines[i] ?? "");
+    i++;
+  }
+  for (const key of ["description", "argument-hint", "allowed-tools"]) {
+    if (replacements.has(key) && !ownedKeys.has(key)) {
+      out.push(...replacements.get(key) ?? []);
+    }
+  }
+  return out;
+}
+async function listSkills(args) {
+  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
+  let entries;
+  try {
+    entries = await fs8.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  if (args.scope === "codex-prompts") {
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".md")) continue;
+      const name = entry.name.slice(0, -".md".length);
+      if (!name) continue;
+      const fullPath = path14.join(dir, entry.name);
+      const stat5 = await safeStat(fullPath);
+      if (!stat5) continue;
+      const description = await readDescriptionSafely(fullPath);
+      results.push({
+        id: `${args.provider}:${args.scope}:${name}`,
+        provider: args.provider,
+        scope: args.scope,
+        name,
+        path: fullPath,
+        description,
+        modifiedAt: stat5.mtime.toISOString(),
+        size: stat5.size
+      });
+    }
+  } else {
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      const skillDir = path14.join(dir, entry.name);
+      const skillPath = path14.join(skillDir, "SKILL.md");
+      const stat5 = await safeStat(skillPath);
+      if (!stat5) continue;
+      const description = await readDescriptionSafely(skillPath);
+      results.push({
+        id: `${args.provider}:${args.scope}:${entry.name}`,
+        provider: args.provider,
+        scope: args.scope,
+        name: entry.name,
+        path: skillPath,
+        description,
+        modifiedAt: stat5.mtime.toISOString(),
+        size: stat5.size
+      });
+    }
+  }
+  results.sort((a, b) => a.name.localeCompare(b.name));
+  return results;
+}
+async function safeStat(filePath) {
+  try {
+    const s = await fs8.stat(filePath);
+    return { mtime: s.mtime, size: s.size };
+  } catch {
+    return null;
+  }
+}
+async function readDescriptionSafely(filePath) {
+  try {
+    const text = await fs8.readFile(filePath, "utf8");
+    return readDescription(text);
+  } catch {
+    return "";
+  }
+}
+async function createSkill(args) {
+  if (!NAME_REGEX.test(args.name)) {
+    throw new Error(
+      `Invalid skill name "${args.name}". Use letters, digits, dot, underscore, dash.`
+    );
+  }
+  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
+    throw new Error(`Skill name must not contain path separators or "..".`);
+  }
+  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
+  await fs8.mkdir(dir, { recursive: true });
+  if (args.scope === "codex-prompts") {
+    const filePath2 = path14.join(dir, `${args.name}.md`);
+    try {
+      await fs8.access(filePath2);
+      throw new Error(`A prompt named "${args.name}" already exists at ${filePath2}`);
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+        throw err;
+      }
+      if (err instanceof Error && err.message.includes("already exists")) {
+        throw err;
+      }
+    }
+    const initial2 = buildStarterPrompt(args.name);
+    await fs8.writeFile(filePath2, initial2, "utf8");
+    return { path: filePath2 };
+  }
+  const skillDir = path14.join(dir, args.name);
+  let dirExists = false;
+  try {
+    const stat5 = await fs8.stat(skillDir);
+    dirExists = stat5.isDirectory();
+  } catch {
+    dirExists = false;
+  }
+  if (dirExists) {
+    throw new Error(`A skill named "${args.name}" already exists at ${skillDir}`);
+  }
+  await fs8.mkdir(skillDir, { recursive: true });
+  const filePath = path14.join(skillDir, "SKILL.md");
+  const initial = buildStarterSkill(args.name);
+  await fs8.writeFile(filePath, initial, "utf8");
+  return { path: filePath };
+}
+function buildStarterSkill(name) {
+  return `---
+name: ${name}
+description: ""
+---
+
+# ${name}
+
+Describe when this skill should be used and what it does. The body of this
+file is loaded into the agent's context when the skill is invoked.
+`;
+}
+function buildStarterPrompt(name) {
+  return `---
+description: ""
+argument-hint: ""
+---
+
+# ${name}
+
+Body of the prompt. Use \`$1\`, \`$2\`, ... or \`$ARGUMENTS\` for parameter expansion.
+`;
+}
+async function writeSkillFrontmatter(args, workspaceRoot) {
+  if (!path14.isAbsolute(args.path)) {
+    throw new Error(`writeSkillFrontmatter expects an absolute path; got "${args.path}"`);
+  }
+  if (!isInsideAllowedRoot(args.path, workspaceRoot)) {
+    throw new Error(`Path "${args.path}" is not inside an allowlisted skill root`);
+  }
+  let original;
+  try {
+    original = await fs8.readFile(args.path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Failed to read skill file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const parsed = parseSkillFile(original);
+  const newLines = rewriteFrontmatter(parsed.rawFrontmatterLines, args.frontmatter);
+  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
+  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
+${parsed.body}` : `${nextFrontmatter}
+
+${original}`;
+  await fs8.writeFile(args.path, nextContent, "utf8");
+}
+
 // ../server/src/server/agent/handoff-mcp.ts
 import { createSdkMcpServer, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
 import { z as z33 } from "zod";
@@ -32397,8 +32835,8 @@ function isVoicePermissionAllowed(request) {
 }
 
 // ../server/src/server/file-explorer/service.ts
-import { promises as fs8 } from "fs";
-import path14 from "path";
+import { promises as fs9 } from "fs";
+import path15 from "path";
 
 // ../server/src/server/path-utils.ts
 import { homedir as homedir2 } from "node:os";
@@ -32445,14 +32883,14 @@ async function listDirectoryEntries({
   relativePath = "."
 }) {
   const directoryPath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs8.stat(directoryPath);
+  const stats = await fs9.stat(directoryPath);
   if (!stats.isDirectory()) {
     throw new Error("Requested path is not a directory");
   }
-  const dirents = await fs8.readdir(directoryPath, { withFileTypes: true });
+  const dirents = await fs9.readdir(directoryPath, { withFileTypes: true });
   const entriesWithNulls = await Promise.all(
     dirents.map(async (dirent) => {
-      const targetPath = path14.join(directoryPath, dirent.name);
+      const targetPath = path15.join(directoryPath, dirent.name);
       const kind = dirent.isDirectory() ? "directory" : "file";
       try {
         return await buildEntryPayload({
@@ -32487,18 +32925,18 @@ async function readExplorerFile({
   relativePath
 }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs8.stat(filePath);
+  const stats = await fs9.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   const basePayload = {
     path: normalizeRelativePath({ root, targetPath: filePath }),
     size: stats.size,
     modifiedAt: stats.mtime.toISOString()
   };
   if (ext in IMAGE_MIME_TYPES) {
-    const buffer2 = await fs8.readFile(filePath);
+    const buffer2 = await fs9.readFile(filePath);
     return {
       ...basePayload,
       kind: "image",
@@ -32507,7 +32945,7 @@ async function readExplorerFile({
       mimeType: IMAGE_MIME_TYPES[ext]
     };
   }
-  const buffer = await fs8.readFile(filePath);
+  const buffer = await fs9.readFile(filePath);
   if (isLikelyBinary(buffer)) {
     return {
       ...basePayload,
@@ -32529,34 +32967,34 @@ async function writeTextFile({
   relativePath,
   content
 }) {
-  const ext = path14.extname(relativePath).toLowerCase();
+  const ext = path15.extname(relativePath).toLowerCase();
   if (ext in IMAGE_MIME_TYPES) {
     throw new Error(`Refusing to write '${relativePath}': binary/image file`);
   }
   const filePath = await resolveScopedPath({ root, relativePath });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs8.writeFile(tempPath, content, "utf8");
-  await fs8.rename(tempPath, filePath);
+  await fs9.writeFile(tempPath, content, "utf8");
+  await fs9.rename(tempPath, filePath);
 }
 async function deleteFile({ root, relativePath }) {
-  const ext = path14.extname(relativePath).toLowerCase();
+  const ext = path15.extname(relativePath).toLowerCase();
   if (ext !== ".md") {
     throw new Error(`Refusing to delete '${relativePath}': only .md files allowed`);
   }
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs8.stat(filePath);
+  const stats = await fs9.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  await fs8.unlink(filePath);
+  await fs9.unlink(filePath);
 }
 async function deleteEntry({ root, relativePath }) {
   const entryPath = await resolveScopedPath({ root, relativePath });
-  await fs8.rm(entryPath, { recursive: true, force: false });
+  await fs9.rm(entryPath, { recursive: true, force: false });
 }
 async function createDirectory({ root, relativePath }) {
   const dirPath = await resolveScopedPath({ root, relativePath });
-  await fs8.mkdir(dirPath, { recursive: true });
+  await fs9.mkdir(dirPath, { recursive: true });
 }
 async function moveEntry({
   root,
@@ -32565,22 +33003,22 @@ async function moveEntry({
 }) {
   const src = await resolveScopedPath({ root, relativePath: sourcePath });
   const dest = await resolveScopedPath({ root, relativePath: destinationPath });
-  await fs8.rename(src, dest);
+  await fs9.rename(src, dest);
 }
 async function getDownloadableFileInfo({ root, relativePath }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs8.stat(filePath);
+  const stats = await fs9.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   let mimeType = "application/octet-stream";
   if (ext in IMAGE_MIME_TYPES) {
     mimeType = IMAGE_MIME_TYPES[ext] ?? mimeType;
   } else if (ext in FONT_MIME_TYPES) {
     mimeType = FONT_MIME_TYPES[ext] ?? mimeType;
   } else {
-    const handle = await fs8.open(filePath, "r");
+    const handle = await fs9.open(filePath, "r");
     const sample = Buffer.alloc(8192);
     try {
       const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
@@ -32595,23 +33033,23 @@ async function getDownloadableFileInfo({ root, relativePath }) {
   return {
     path: normalizeRelativePath({ root, targetPath: filePath }),
     absolutePath: filePath,
-    fileName: path14.basename(filePath),
+    fileName: path15.basename(filePath),
     mimeType,
     size: stats.size
   };
 }
 async function resolveScopedPath({ root, relativePath = "." }) {
-  const normalizedRoot = path14.resolve(root);
+  const normalizedRoot = path15.resolve(root);
   const requestedPath = resolvePathFromBase(normalizedRoot, relativePath);
-  const relative = path14.relative(normalizedRoot, requestedPath);
-  if (relative !== "" && (relative.startsWith("..") || path14.isAbsolute(relative))) {
+  const relative = path15.relative(normalizedRoot, requestedPath);
+  if (relative !== "" && (relative.startsWith("..") || path15.isAbsolute(relative))) {
     throw new Error("Access outside of workspace is not allowed");
   }
-  const realRoot = await fs8.realpath(normalizedRoot);
+  const realRoot = await fs9.realpath(normalizedRoot);
   try {
-    const realPath = await fs8.realpath(requestedPath);
-    const realRelative = path14.relative(realRoot, realPath);
-    if (realRelative !== "" && (realRelative.startsWith("..") || path14.isAbsolute(realRelative))) {
+    const realPath = await fs9.realpath(requestedPath);
+    const realRelative = path15.relative(realRoot, realPath);
+    if (realRelative !== "" && (realRelative.startsWith("..") || path15.isAbsolute(realRelative))) {
       throw new Error("Access outside of workspace is not allowed");
     }
     return requestedPath;
@@ -32628,7 +33066,7 @@ async function buildEntryPayload({
   name,
   kind
 }) {
-  const stats = await fs8.stat(targetPath);
+  const stats = await fs9.stat(targetPath);
   return {
     name,
     path: normalizeRelativePath({ root, targetPath }),
@@ -32642,10 +33080,10 @@ function isMissingEntryError(error) {
   return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
 }
 function normalizeRelativePath({ root, targetPath }) {
-  const normalizedRoot = path14.resolve(root);
-  const normalizedTarget = path14.resolve(targetPath);
-  const relative = path14.relative(normalizedRoot, normalizedTarget);
-  return relative === "" ? "." : relative.split(path14.sep).join("/");
+  const normalizedRoot = path15.resolve(root);
+  const normalizedTarget = path15.resolve(targetPath);
+  const relative = path15.relative(normalizedRoot, normalizedTarget);
+  return relative === "" ? "." : relative.split(path15.sep).join("/");
 }
 function textMimeTypeForExtension(ext) {
   return TEXT_MIME_TYPES[ext] ?? DEFAULT_TEXT_MIME_TYPE;
@@ -32998,342 +33436,18 @@ async function getProjectIcon(projectDir) {
 }
 
 // ../server/src/utils/path.ts
-import os6 from "os";
+import os7 from "os";
 function expandTilde(path29) {
   if (path29.startsWith("~/")) {
-    const homeDir3 = process.env.HOME || os6.homedir();
+    const homeDir3 = process.env.HOME || os7.homedir();
     return path29.replace("~", homeDir3);
   }
   if (path29 === "~") {
-    return process.env.HOME || os6.homedir();
+    return process.env.HOME || os7.homedir();
   }
   return path29;
 }
 
-// ../server/src/server/skills/scanner.ts
-import fs9 from "node:fs/promises";
-import os7 from "node:os";
-import path15 from "node:path";
-var NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/i;
-function homeDir() {
-  return process.env.HOME || os7.homedir();
-}
-function codexHomeDir() {
-  return process.env.CODEX_HOME || path15.join(homeDir(), ".codex");
-}
-function resolveScopeDir(provider, scope, workspaceRoot) {
-  if (scope === "codex-prompts") {
-    if (provider !== "codex") {
-      throw new Error(`Scope "codex-prompts" is only valid for provider "codex"`);
-    }
-    return path15.join(codexHomeDir(), "prompts");
-  }
-  if (scope === "project") {
-    if (!workspaceRoot) {
-      throw new Error(`workspaceRoot is required for scope "project"`);
-    }
-    const dotDir = provider === "claude" ? ".claude" : ".codex";
-    return path15.join(workspaceRoot, dotDir, "skills");
-  }
-  if (provider === "claude") {
-    return path15.join(homeDir(), ".claude", "skills");
-  }
-  return path15.join(codexHomeDir(), "skills");
-}
-function allowedRoots(workspaceRoot) {
-  const roots = [
-    path15.join(homeDir(), ".claude", "skills"),
-    path15.join(codexHomeDir(), "skills"),
-    path15.join(codexHomeDir(), "prompts")
-  ];
-  if (workspaceRoot) {
-    roots.push(path15.join(workspaceRoot, ".claude", "skills"));
-    roots.push(path15.join(workspaceRoot, ".codex", "skills"));
-  }
-  return roots.map((r) => path15.resolve(r));
-}
-function isInsideAllowedRoot(absPath, workspaceRoot) {
-  const resolved = path15.resolve(absPath);
-  for (const root of allowedRoots(workspaceRoot)) {
-    const rel = path15.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel)) {
-      return true;
-    }
-  }
-  return false;
-}
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-function parseSkillFile(text) {
-  const match = FRONTMATTER_RE.exec(text);
-  if (!match) {
-    return { rawFrontmatterLines: [], body: text, hadFrontmatter: false };
-  }
-  const yamlBlock = match[1] ?? "";
-  const body = match[2] ?? "";
-  return {
-    rawFrontmatterLines: yamlBlock.split(/\r?\n/),
-    body,
-    hadFrontmatter: true
-  };
-}
-function readDescription(text) {
-  const parsed = parseSkillFile(text);
-  if (!parsed.hadFrontmatter) return "";
-  for (const line of parsed.rawFrontmatterLines) {
-    const m = /^description\s*:\s*(.*)$/.exec(line);
-    if (m) {
-      const value = (m[1] ?? "").trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        return value.slice(1, -1);
-      }
-      return value;
-    }
-  }
-  return "";
-}
-function findOwnedSpans(lines) {
-  const spans = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const keyMatch = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
-    if (!keyMatch) {
-      i++;
-      continue;
-    }
-    const key = keyMatch[1];
-    const value = keyMatch[2];
-    if (key !== "description" && key !== "argument-hint" && key !== "allowed-tools") {
-      i++;
-      continue;
-    }
-    let end = i + 1;
-    if (value === "") {
-      while (end < lines.length) {
-        const next = lines[end] ?? "";
-        if (/^\s+-\s+/.test(next) || /^\s*$/.test(next)) {
-          end++;
-        } else {
-          break;
-        }
-      }
-    }
-    spans.push({ key, startLine: i, endLine: end });
-    i = end;
-  }
-  return spans;
-}
-function emitFrontmatterValue(key, value) {
-  if (key === "allowed-tools") {
-    if (!Array.isArray(value) || value.length === 0) return [];
-    return [`allowed-tools:`, ...value.map((v) => `  - ${v}`)];
-  }
-  const text = typeof value === "string" ? value : "";
-  if (text.length === 0) return [];
-  const needsQuote = /[:#\n]/.test(text) || text.startsWith(" ") || text.endsWith(" ");
-  const formatted = needsQuote ? `"${text.replace(/"/g, '\\"')}"` : text;
-  return [`${key}: ${formatted}`];
-}
-function rewriteFrontmatter(originalLines, next) {
-  const spans = findOwnedSpans(originalLines);
-  const ownedKeys = new Set(spans.map((s) => s.key));
-  const replacements = /* @__PURE__ */ new Map();
-  if (next.description !== void 0) {
-    replacements.set("description", emitFrontmatterValue("description", next.description));
-  }
-  if (next.argumentHint !== void 0) {
-    replacements.set("argument-hint", emitFrontmatterValue("argument-hint", next.argumentHint));
-  }
-  if (next.allowedTools !== void 0) {
-    replacements.set("allowed-tools", emitFrontmatterValue("allowed-tools", next.allowedTools));
-  }
-  const out = [];
-  let i = 0;
-  while (i < originalLines.length) {
-    const span = spans.find((s) => s.startLine === i);
-    if (span) {
-      if (replacements.has(span.key)) {
-        out.push(...replacements.get(span.key) ?? []);
-      } else {
-        for (let j = span.startLine; j < span.endLine; j++) {
-          out.push(originalLines[j] ?? "");
-        }
-      }
-      i = span.endLine;
-      continue;
-    }
-    out.push(originalLines[i] ?? "");
-    i++;
-  }
-  for (const key of ["description", "argument-hint", "allowed-tools"]) {
-    if (replacements.has(key) && !ownedKeys.has(key)) {
-      out.push(...replacements.get(key) ?? []);
-    }
-  }
-  return out;
-}
-async function listSkills(args) {
-  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
-  let entries;
-  try {
-    entries = await fs9.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const results = [];
-  if (args.scope === "codex-prompts") {
-    for (const entry of entries) {
-      if (!entry.isFile()) continue;
-      if (!entry.name.endsWith(".md")) continue;
-      const name = entry.name.slice(0, -".md".length);
-      if (!name) continue;
-      const fullPath = path15.join(dir, entry.name);
-      const stat5 = await safeStat(fullPath);
-      if (!stat5) continue;
-      const description = await readDescriptionSafely(fullPath);
-      results.push({
-        id: `${args.provider}:${args.scope}:${name}`,
-        provider: args.provider,
-        scope: args.scope,
-        name,
-        path: fullPath,
-        description,
-        modifiedAt: stat5.mtime.toISOString(),
-        size: stat5.size
-      });
-    }
-  } else {
-    for (const entry of entries) {
-      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-      const skillDir = path15.join(dir, entry.name);
-      const skillPath = path15.join(skillDir, "SKILL.md");
-      const stat5 = await safeStat(skillPath);
-      if (!stat5) continue;
-      const description = await readDescriptionSafely(skillPath);
-      results.push({
-        id: `${args.provider}:${args.scope}:${entry.name}`,
-        provider: args.provider,
-        scope: args.scope,
-        name: entry.name,
-        path: skillPath,
-        description,
-        modifiedAt: stat5.mtime.toISOString(),
-        size: stat5.size
-      });
-    }
-  }
-  results.sort((a, b) => a.name.localeCompare(b.name));
-  return results;
-}
-async function safeStat(filePath) {
-  try {
-    const s = await fs9.stat(filePath);
-    return { mtime: s.mtime, size: s.size };
-  } catch {
-    return null;
-  }
-}
-async function readDescriptionSafely(filePath) {
-  try {
-    const text = await fs9.readFile(filePath, "utf8");
-    return readDescription(text);
-  } catch {
-    return "";
-  }
-}
-async function createSkill(args) {
-  if (!NAME_REGEX.test(args.name)) {
-    throw new Error(
-      `Invalid skill name "${args.name}". Use letters, digits, dot, underscore, dash.`
-    );
-  }
-  if (args.name.includes("/") || args.name.includes("\\") || args.name.includes("..")) {
-    throw new Error(`Skill name must not contain path separators or "..".`);
-  }
-  const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
-  await fs9.mkdir(dir, { recursive: true });
-  if (args.scope === "codex-prompts") {
-    const filePath2 = path15.join(dir, `${args.name}.md`);
-    try {
-      await fs9.access(filePath2);
-      throw new Error(`A prompt named "${args.name}" already exists at ${filePath2}`);
-    } catch (err) {
-      if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
-        throw err;
-      }
-      if (err instanceof Error && err.message.includes("already exists")) {
-        throw err;
-      }
-    }
-    const initial2 = buildStarterPrompt(args.name);
-    await fs9.writeFile(filePath2, initial2, "utf8");
-    return { path: filePath2 };
-  }
-  const skillDir = path15.join(dir, args.name);
-  let dirExists = false;
-  try {
-    const stat5 = await fs9.stat(skillDir);
-    dirExists = stat5.isDirectory();
-  } catch {
-    dirExists = false;
-  }
-  if (dirExists) {
-    throw new Error(`A skill named "${args.name}" already exists at ${skillDir}`);
-  }
-  await fs9.mkdir(skillDir, { recursive: true });
-  const filePath = path15.join(skillDir, "SKILL.md");
-  const initial = buildStarterSkill(args.name);
-  await fs9.writeFile(filePath, initial, "utf8");
-  return { path: filePath };
-}
-function buildStarterSkill(name) {
-  return `---
-name: ${name}
-description: ""
----
-
-# ${name}
-
-Describe when this skill should be used and what it does. The body of this
-file is loaded into the agent's context when the skill is invoked.
-`;
-}
-function buildStarterPrompt(name) {
-  return `---
-description: ""
-argument-hint: ""
----
-
-# ${name}
-
-Body of the prompt. Use \`$1\`, \`$2\`, ... or \`$ARGUMENTS\` for parameter expansion.
-`;
-}
-async function writeSkillFrontmatter(args, workspaceRoot) {
-  if (!path15.isAbsolute(args.path)) {
-    throw new Error(`writeSkillFrontmatter expects an absolute path; got "${args.path}"`);
-  }
-  if (!isInsideAllowedRoot(args.path, workspaceRoot)) {
-    throw new Error(`Path "${args.path}" is not inside an allowlisted skill root`);
-  }
-  let original;
-  try {
-    original = await fs9.readFile(args.path, "utf8");
-  } catch (err) {
-    throw new Error(
-      `Failed to read skill file: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const parsed = parseSkillFile(original);
-  const newLines = rewriteFrontmatter(parsed.rawFrontmatterLines, args.frontmatter);
-  const nextFrontmatter = ["---", ...newLines, "---"].join("\n");
-  const nextContent = parsed.hadFrontmatter ? `${nextFrontmatter}
-${parsed.body}` : `${nextFrontmatter}
-
-${original}`;
-  await fs9.writeFile(args.path, nextContent, "utf8");
-}
-
 // ../server/src/utils/directory-suggestions.ts
 import { readdir as readdir2, realpath, stat as stat3 } from "node:fs/promises";
 import path16 from "node:path";
@@ -34972,10 +35086,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: [] };
     }
@@ -34987,7 +35103,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));
@@ -35426,11 +35543,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;
@@ -35465,34 +35703,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 = [];
@@ -37167,7 +37405,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) {
@@ -38548,6 +38786,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;
@@ -40207,8 +40448,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."
       )
     });
@@ -40253,9 +40494,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:",
@@ -45747,6 +45988,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 {
@@ -46308,7 +46581,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",
@@ -46401,7 +46674,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"
@@ -46432,20 +46705,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
   )
@@ -46490,177 +46763,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."
   )
 };
@@ -46715,13 +46988,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)
   })
 });
 
@@ -46755,21 +47028,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),
@@ -46825,17 +47098,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;
   }
@@ -46850,7 +47123,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"),
@@ -46959,9 +47232,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;
@@ -47014,6 +47287,7 @@ function loadConfig(appostleHome, options) {
   const mcpEnabled = options?.cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true;
   const mcpInjectIntoAgents = options?.cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? false;
   const chromeEnabled = persisted.daemon?.chrome?.enabled ?? true;
+  const playwrightEnabled = persisted.daemon?.playwright?.enabled ?? true;
   const daemonIcon = persisted.daemon?.identity?.icon;
   const relayEnabled = options?.cli?.relayEnabled ?? parseBooleanEnv(env.APPOSTLE_RELAY_ENABLED) ?? persisted.daemon?.relay?.enabled ?? true;
   const relayEndpoint = env.APPOSTLE_RELAY_ENDPOINT ?? persisted.daemon?.relay?.endpoint ?? DEFAULT_RELAY_ENDPOINT;
@@ -47044,6 +47318,7 @@ function loadConfig(appostleHome, options) {
     mcpEnabled,
     mcpInjectIntoAgents,
     chromeEnabled,
+    playwrightEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
     agentStoragePath: path22.join(appostleHome, "agents"),
@@ -47335,6 +47610,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);
       });
     },
@@ -50937,6 +51215,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 () => {