appostle-installer 0.0.8 → 0.0.10

package/dist/appostle.js

@@ -454,18 +454,18 @@ function resolveNodePtyPackageRoot() {
     return null;
   }
 }
-function ensureExecutableBit(path24) {
-  if (!existsSync2(path24)) {
+function ensureExecutableBit(path26) {
+  if (!existsSync2(path26)) {
     return;
   }
-  const stat5 = statSync(path24);
+  const stat5 = statSync(path26);
   if (!stat5.isFile()) {
     return;
   }
   if ((stat5.mode & 73) === 73) {
     return;
   }
-  chmodSync(path24, stat5.mode | 73);
+  chmodSync(path26, stat5.mode | 73);
 }
 function ensureNodePtySpawnHelperExecutableForCurrentPlatform(options = {}) {
   const platform2 = options.platform ?? process.platform;
@@ -547,11 +547,11 @@ function parseGitRevParsePath(stdout) {
   if (lines.length !== 1) {
     return null;
   }
-  const path24 = lines[0]?.trim() ?? "";
-  if (!path24 || path24.startsWith("--")) {
+  const path26 = lines[0]?.trim() ?? "";
+  if (!path26 || path26.startsWith("--")) {
     return null;
   }
-  return path24;
+  return path26;
 }
 function resolveGitRevParsePath(cwd, stdout) {
   const parsed = parseGitRevParsePath(stdout);
@@ -1324,9 +1324,9 @@ async function deleteAppostleWorktree({
     }
   }
 }
-async function pathExists(path24) {
+async function pathExists(path26) {
   try {
-    await stat(path24);
+    await stat(path26);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1335,8 +1335,8 @@ async function pathExists(path24) {
     throw error;
   }
 }
-async function removeDirectoryWithRetries(path24) {
-  if (!await pathExists(path24)) {
+async function removeDirectoryWithRetries(path26) {
+  if (!await pathExists(path26)) {
     return;
   }
   const delaysMs = [0, 100, 300, 700, 1500];
@@ -1346,17 +1346,17 @@ async function removeDirectoryWithRetries(path24) {
       await new Promise((resolve12) => setTimeout(resolve12, delay));
     }
     try {
-      await rm(path24, { recursive: true, force: true });
-      if (!await pathExists(path24)) {
+      await rm(path26, { recursive: true, force: true });
+      if (!await pathExists(path26)) {
         return;
       }
-      lastError = new Error(`Directory still present after rm: ${path24}`);
+      lastError = new Error(`Directory still present after rm: ${path26}`);
     } catch (error) {
       lastError = error;
     }
   }
-  if (await pathExists(path24)) {
-    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path24}`);
+  if (await pathExists(path26)) {
+    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path26}`);
   }
 }
 var createWorktree = async ({
@@ -1664,7 +1664,8 @@ function toAgentPayload(agent, options) {
     pendingPermissions: sanitizePendingPermissions(agent.pendingPermissions),
     persistence: sanitizePersistenceHandle(agent.persistence),
     title: options?.title ?? null,
-    labels: agent.labels
+    labels: agent.labels,
+    internal: agent.internal
   };
   const usage = sanitizeUsage(agent.lastUsage);
   if (usage !== void 0) {
@@ -1734,7 +1735,8 @@ function buildStoredAgentPayload(record, providerRegistry, logger) {
     attentionReason: record.attentionReason ?? null,
     attentionTimestamp: record.attentionTimestamp ?? null,
     archivedAt: record.archivedAt ?? null,
-    labels: record.labels
+    labels: record.labels,
+    internal: record.internal
   };
 }
 function resolveStoredAgentPayloadUpdatedAt(record) {
@@ -1783,34 +1785,42 @@ function cloneAvailableModes(modes) {
 function normalizeFeatures(features) {
   return Array.isArray(features) ? features.map((feature) => ({ ...feature })) : [];
 }
-function sanitizeOptionalJson(value) {
+var SANITIZE_MAX_DEPTH = 32;
+function sanitizeOptionalJson(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
   if (value === void 0) {
     return void 0;
   }
   if (value === null) {
     return null;
   }
-  if (Array.isArray(value)) {
-    const sanitized = value.map((item) => sanitizeOptionalJson(item)).filter((item) => item !== void 0);
-    return sanitized;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
   if (value instanceof Date) {
     return value.toISOString();
   }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      const sanitized = sanitizeOptionalJson(val);
-      if (sanitized !== void 0) {
-        result[key] = sanitized;
-      }
-    }
-    return Object.keys(result).length ? result : void 0;
+  if (typeof value !== "object") {
+    return void 0;
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
+  if (depth >= SANITIZE_MAX_DEPTH) {
+    return void 0;
   }
-  return void 0;
+  if (seen.has(value)) {
+    return void 0;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const sanitized = value.map((item) => sanitizeOptionalJson(item, seen, depth + 1)).filter((item) => item !== void 0);
+    return sanitized;
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    const sanitized = sanitizeOptionalJson(val, seen, depth + 1);
+    if (sanitized !== void 0) {
+      result[key] = sanitized;
+    }
+  }
+  return Object.keys(result).length ? result : void 0;
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1871,6 +1881,34 @@ function sanitizeUsage(value) {
   } else if (contextWindowUsedTokens !== void 0 && contextWindowUsedTokens !== null) {
     return void 0;
   }
+  const rateLimits = sanitized.rateLimits;
+  if (Array.isArray(rateLimits)) {
+    const VALID_RATE_LIMIT_TYPES = /* @__PURE__ */ new Set([
+      "five_hour",
+      "seven_day",
+      "seven_day_opus",
+      "seven_day_sonnet",
+      "overage"
+    ]);
+    const sanitizedRateLimits = [];
+    for (const entry of rateLimits) {
+      if (!entry || typeof entry !== "object") continue;
+      const { rateLimitType, utilization, resetsAt } = entry;
+      if (typeof rateLimitType !== "string" || !VALID_RATE_LIMIT_TYPES.has(rateLimitType)) continue;
+      if (typeof utilization !== "number" || !Number.isFinite(utilization)) continue;
+      const limit = {
+        rateLimitType,
+        utilization
+      };
+      if (typeof resetsAt === "number" && Number.isFinite(resetsAt)) {
+        limit.resetsAt = resetsAt;
+      }
+      sanitizedRateLimits.push(limit);
+    }
+    if (sanitizedRateLimits.length > 0) {
+      result.rateLimits = sanitizedRateLimits;
+    }
+  }
   return Object.keys(result).length ? result : void 0;
 }
 function sanitizeRuntimeInfo(runtimeInfo) {
@@ -2647,6 +2685,13 @@ var QuestRecordSchema = z8.object({
   cwd: z8.string(),
   /** User's task prompt — fed to every card unless overridden per-card. */
   prompt: z8.string(),
+  /**
+   * Short auto-generated label for the quest, derived from the user prompt by a
+   * small internal metadata agent (mirrors how single-agent sessions get a
+   * title). Empty string until generation finishes (or if it fails). Optional +
+   * default so old persisted records remain valid.
+   */
+  name: z8.string().optional().default(""),
   defaultProvider: AgentProviderSchema,
   defaultModel: z8.string().nullable(),
   termination: QuestTerminationSchema,
@@ -2717,6 +2762,8 @@ var QuestListItemSchema = z9.object({
   status: QuestStatusSchema,
   cwd: z9.string(),
   prompt: z9.string(),
+  /** Auto-generated short label. Optional for backward compat with old daemons. */
+  name: z9.string().optional().default(""),
   createdAt: z9.string(),
   updatedAt: z9.string()
 });
@@ -3068,13 +3115,25 @@ var AgentCapabilityFlagsSchema = z10.object({
   supportsReasoningStream: z10.boolean(),
   supportsToolInvocations: z10.boolean()
 });
+var AgentRateLimitSchema = z10.object({
+  rateLimitType: z10.enum([
+    "five_hour",
+    "seven_day",
+    "seven_day_opus",
+    "seven_day_sonnet",
+    "overage"
+  ]),
+  utilization: z10.number(),
+  resetsAt: z10.number().optional()
+});
 var AgentUsageSchema = z10.object({
   inputTokens: z10.number().optional(),
   cachedInputTokens: z10.number().optional(),
   outputTokens: z10.number().optional(),
   totalCostUsd: z10.number().optional(),
   contextWindowMaxTokens: z10.number().optional(),
-  contextWindowUsedTokens: z10.number().optional()
+  contextWindowUsedTokens: z10.number().optional(),
+  rateLimits: z10.array(AgentRateLimitSchema).optional()
 });
 var McpStdioServerConfigSchema = z10.object({
   type: z10.literal("stdio"),
@@ -3314,7 +3373,46 @@ var AgentTimelineItemPayloadSchema = z10.union([
   z10.object({
     type: z10.literal("user_message"),
     text: z10.string(),
-    messageId: z10.string().optional()
+    messageId: z10.string().optional(),
+    // Bytes-stripped attachment metadata so a reload re-renders the chip
+    // without round-tripping image/file bytes through the timeline. Both
+    // optional → backward-compatible with old daemons (silently strip) and
+    // old clients (silently ignore). Inlined (not factored to a const)
+    // because they're only used in this one place and forward-declaring
+    // them would force a top-level reorder.
+    images: z10.array(
+      z10.object({
+        id: z10.string(),
+        mimeType: z10.string(),
+        fileName: z10.string().optional(),
+        byteSize: z10.number().int().nonnegative().optional(),
+        // Daemon-side pointer for fetch-by-id. Optional → old daemons
+        // (which only emit local-cache-friendly metadata) keep working;
+        // old clients see the field and ignore it.
+        daemonRef: z10.object({
+          kind: z10.enum(["image", "file"]),
+          attachmentId: z10.string(),
+          relativePath: z10.string()
+        }).optional()
+      })
+    ).optional(),
+    files: z10.array(
+      z10.object({
+        id: z10.string(),
+        fileName: z10.string(),
+        mimeType: z10.string(),
+        size: z10.number().int().nonnegative(),
+        daemonRef: z10.object({
+          kind: z10.enum(["image", "file"]),
+          attachmentId: z10.string(),
+          relativePath: z10.string()
+        }).optional()
+      })
+    ).optional(),
+    // Marker for daemon-synthesized text (e.g. "Sent 1 image" when the
+    // user typed nothing). The chat bubble hides the text when this is
+    // true; the LLM still sees it for cache_control compliance.
+    textIsSynthesized: z10.boolean().optional()
   }),
   z10.object({
     type: z10.literal("assistant_message"),
@@ -3460,7 +3558,15 @@ var AgentSnapshotPayloadSchema = z10.object({
   archivedAt: z10.string().nullable().optional(),
   // Fork lineage — optional for backward compat with pre-fork agents.
   parentAgentId: z10.string().optional(),
-  forkedFromMessageUuid: z10.string().optional()
+  forkedFromMessageUuid: z10.string().optional(),
+  /**
+   * True when the agent is a system-spawned helper (orchestrator queens,
+   * handoff workers). Optional for backward compat — older clients ignore
+   * the field. Newer clients filter these out of workspace tab lists / agent
+   * lists at display time. The agent itself is a real, full-featured session
+   * in every other respect; `internal` is a UI visibility hint, nothing more.
+   */
+  internal: z10.boolean().optional()
 });
 var VoiceAudioChunkMessageSchema = z10.object({
   type: z10.literal("voice_audio_chunk"),
@@ -3586,8 +3692,34 @@ var AgentAttachmentsSchema = z10.unknown().transform(normalizeAgentAttachments).
 var ImageAttachmentSchema = z10.object({
   data: z10.string(),
   // base64 encoded image
-  mimeType: z10.string()
+  mimeType: z10.string(),
   // e.g., "image/jpeg", "image/png"
+  // Optional client-side identity. When provided, the daemon echoes these
+  // (without bytes) on the `user_message` timeline event so a reload can
+  // re-render the chip. All optional → backward-compatible: old clients
+  // omit them, old daemons strip them.
+  id: z10.string().optional(),
+  fileName: z10.string().optional(),
+  byteSize: z10.number().int().nonnegative().optional()
+});
+var FileAttachmentSchema = z10.object({
+  fileName: z10.string().min(1).max(255),
+  mimeType: z10.string().min(1).max(255),
+  size: z10.number().int().nonnegative(),
+  data: z10.string()
+  // base64-encoded bytes
+});
+var SessionUploadSchema = z10.object({
+  id: z10.string(),
+  fileName: z10.string(),
+  mimeType: z10.string(),
+  size: z10.number().int().nonnegative(),
+  createdAt: z10.string(),
+  // ISO-8601 UTC timestamp
+  messageId: z10.string().nullable(),
+  // Path relative to the agent's workspace root, e.g.
+  // ".appostle/uploaded_files/<id>__report.sql". Always uses POSIX separators.
+  relativePath: z10.string()
 });
 var SendAgentMessageSchema = z10.object({
   type: z10.literal("send_agent_message"),
@@ -3596,6 +3728,7 @@ var SendAgentMessageSchema = z10.object({
   messageId: z10.string().optional(),
   // Client-provided ID for deduplication
   images: z10.array(ImageAttachmentSchema).optional(),
+  files: z10.array(FileAttachmentSchema).optional(),
   attachments: AgentAttachmentsSchema
 });
 var FetchAgentsRequestMessageSchema = z10.object({
@@ -3660,6 +3793,7 @@ var SendAgentMessageRequestSchema = z10.object({
   messageId: z10.string().optional(),
   // Client-provided ID for deduplication
   images: z10.array(ImageAttachmentSchema).optional(),
+  files: z10.array(FileAttachmentSchema).optional(),
   attachments: AgentAttachmentsSchema
 });
 var WaitForFinishRequestSchema = z10.object({
@@ -3721,6 +3855,7 @@ var CreateAgentRequestMessageSchema = z10.object({
   clientMessageId: z10.string().optional(),
   outputSchema: z10.record(z10.unknown()).optional(),
   images: z10.array(ImageAttachmentSchema).optional(),
+  files: z10.array(FileAttachmentSchema).optional(),
   attachments: AgentAttachmentsSchema,
   git: GitSetupOptionsSchema.optional(),
   labels: z10.record(z10.string()).default({}),
@@ -4517,6 +4652,131 @@ var LinkAccountResponseMessageSchema = z10.object({
     })
   ])
 });
+var ListSessionUploadsRequestSchema = z10.object({
+  type: z10.literal("list_session_uploads_request"),
+  requestId: z10.string(),
+  /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+  agentId: z10.string()
+});
+var ListSessionUploadsResponseSchema = z10.object({
+  type: z10.literal("list_session_uploads_response"),
+  payload: z10.discriminatedUnion("ok", [
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(true),
+      uploads: z10.array(SessionUploadSchema)
+    }),
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(false),
+      error: z10.string()
+    })
+  ])
+});
+var DeleteSessionUploadRequestSchema = z10.object({
+  type: z10.literal("delete_session_upload_request"),
+  requestId: z10.string(),
+  /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+  agentId: z10.string(),
+  uploadId: z10.string()
+});
+var DeleteSessionUploadResponseSchema = z10.object({
+  type: z10.literal("delete_session_upload_response"),
+  payload: z10.discriminatedUnion("ok", [
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(true)
+    }),
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(false),
+      error: z10.string()
+    })
+  ])
+});
+var SessionImageSchema = z10.object({
+  id: z10.string(),
+  fileName: z10.string(),
+  mimeType: z10.string(),
+  size: z10.number().int().nonnegative(),
+  createdAt: z10.string(),
+  // ISO-8601 UTC timestamp
+  relativePath: z10.string()
+});
+var ListSessionImagesRequestSchema = z10.object({
+  type: z10.literal("list_session_images_request"),
+  requestId: z10.string(),
+  /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+  agentId: z10.string()
+});
+var ListSessionImagesResponseSchema = z10.object({
+  type: z10.literal("list_session_images_response"),
+  payload: z10.discriminatedUnion("ok", [
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(true),
+      images: z10.array(SessionImageSchema)
+    }),
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(false),
+      error: z10.string()
+    })
+  ])
+});
+var DeleteSessionImageRequestSchema = z10.object({
+  type: z10.literal("delete_session_image_request"),
+  requestId: z10.string(),
+  /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+  agentId: z10.string(),
+  /** Workspace-relative POSIX path; traversal-guarded by the daemon. */
+  relativePath: z10.string()
+});
+var DeleteSessionImageResponseSchema = z10.object({
+  type: z10.literal("delete_session_image_response"),
+  payload: z10.discriminatedUnion("ok", [
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(true)
+    }),
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(false),
+      error: z10.string()
+    })
+  ])
+});
+var FetchAttachmentBytesRequestSchema = z10.object({
+  type: z10.literal("fetch_attachment_bytes_request"),
+  requestId: z10.string(),
+  /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+  agentId: z10.string(),
+  kind: z10.enum(["image", "file"]),
+  attachmentId: z10.string(),
+  /** Workspace-relative POSIX path to the byte source on the daemon's disk. */
+  relativePath: z10.string()
+});
+var FetchAttachmentBytesResponseSchema = z10.object({
+  type: z10.literal("fetch_attachment_bytes_response"),
+  payload: z10.discriminatedUnion("ok", [
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(true),
+      attachmentId: z10.string(),
+      kind: z10.enum(["image", "file"]),
+      data: z10.string(),
+      // base64
+      mimeType: z10.string(),
+      byteSize: z10.number().int().nonnegative(),
+      fileName: z10.string().optional()
+    }),
+    z10.object({
+      requestId: z10.string(),
+      ok: z10.literal(false),
+      error: z10.string()
+    })
+  ])
+});
 var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   VoiceAudioChunkMessageSchema,
   AbortRequestMessageSchema,
@@ -4658,7 +4918,12 @@ var SessionInboundMessageSchema = z10.discriminatedUnion("type", [
   QuestListRequestSchema,
   QuestInspectRequestSchema,
   QuestStopRequestSchema,
-  RolesListRequestSchema
+  RolesListRequestSchema,
+  ListSessionUploadsRequestSchema,
+  DeleteSessionUploadRequestSchema,
+  ListSessionImagesRequestSchema,
+  DeleteSessionImageRequestSchema,
+  FetchAttachmentBytesRequestSchema
 ]);
 var ActivityLogPayloadSchema = z10.object({
   id: z10.string(),
@@ -6202,7 +6467,12 @@ var SessionOutboundMessageSchema = z10.discriminatedUnion("type", [
   BrandAssetCopyResponseSchema,
   BrandAssetUploadResponseSchema,
   GetVapidPublicKeyResponseSchema,
-  LinkAccountResponseMessageSchema
+  LinkAccountResponseMessageSchema,
+  ListSessionUploadsResponseSchema,
+  DeleteSessionUploadResponseSchema,
+  ListSessionImagesResponseSchema,
+  DeleteSessionImageResponseSchema,
+  FetchAttachmentBytesResponseSchema
 ]);
 var WSPingMessageSchema = z10.object({
   type: z10.literal("ping")
@@ -8604,14 +8874,14 @@ var DictationStreamManager = class {
       PCM_CHANNELS,
       PCM_BITS_PER_SAMPLE
     );
-    const path24 = await maybePersistDictationDebugAudio(
+    const path26 = await maybePersistDictationDebugAudio(
       wavBuffer,
       { sessionId: state.sessionId, dictationId: state.dictationId, format: "audio/wav" },
       this.logger,
       state.debugChunkWriter?.folder
     );
-    state.debugRecordingPath = path24;
-    return path24;
+    state.debugRecordingPath = path26;
+    return path26;
   }
   failDictationStream(dictationId, error, retryable) {
     this.emit({
@@ -9640,6 +9910,9 @@ async function sendPromptToAgent(params) {
     messageId,
     runOptions,
     sessionMode,
+    userMessageImages,
+    userMessageFiles,
+    userMessageTextIsSynthesized,
     logger
   } = params;
   await unarchiveAgentState(agentStorage, agentManager, agentId);
@@ -9654,7 +9927,10 @@ async function sendPromptToAgent(params) {
   try {
     agentManager.recordUserMessage(agentId, userMessageText, {
       messageId,
-      emitState: false
+      emitState: false,
+      ...userMessageImages && userMessageImages.length > 0 ? { images: userMessageImages } : {},
+      ...userMessageFiles && userMessageFiles.length > 0 ? { files: userMessageFiles } : {},
+      ...userMessageTextIsSynthesized ? { textIsSynthesized: true } : {}
     });
   } catch (error) {
     logger.error({ err: error, agentId }, "Failed to record user message");
@@ -9665,6 +9941,544 @@ async function sendPromptToAgent(params) {
   });
 }
 
+// ../server/src/server/agent/prompt-attachments.ts
+function renderPromptAttachmentAsText(attachment) {
+  switch (attachment.type) {
+    case "github_pr": {
+      const lines = [`GitHub PR #${attachment.number}: ${attachment.title}`, attachment.url];
+      if (attachment.baseRefName) {
+        lines.push(`Base: ${attachment.baseRefName}`);
+      }
+      if (attachment.headRefName) {
+        lines.push(`Head: ${attachment.headRefName}`);
+      }
+      if (attachment.body) {
+        lines.push("", attachment.body);
+      }
+      return lines.join("\n");
+    }
+    case "github_issue": {
+      const lines = [`GitHub Issue #${attachment.number}: ${attachment.title}`, attachment.url];
+      if (attachment.body) {
+        lines.push("", attachment.body);
+      }
+      return lines.join("\n");
+    }
+    case "gitlab_mr": {
+      const lines = [`GitLab MR !${attachment.iid}: ${attachment.title}`, attachment.url];
+      if (attachment.targetBranch) {
+        lines.push(`Target: ${attachment.targetBranch}`);
+      }
+      if (attachment.sourceBranch) {
+        lines.push(`Source: ${attachment.sourceBranch}`);
+      }
+      if (attachment.body) {
+        lines.push("", attachment.body);
+      }
+      return lines.join("\n");
+    }
+    case "gitlab_issue": {
+      const lines = [`GitLab Issue #${attachment.iid}: ${attachment.title}`, attachment.url];
+      if (attachment.body) {
+        lines.push("", attachment.body);
+      }
+      return lines.join("\n");
+    }
+  }
+}
+function renderFileAttachmentFooter(uploads) {
+  if (uploads.length === 0) {
+    return "";
+  }
+  const lines = [
+    "",
+    "The user attached the following file(s) to this message. Read them with your file-read tool when relevant; the paths are relative to the workspace root:"
+  ];
+  for (const upload of uploads) {
+    const size = formatBytes(upload.size);
+    lines.push(`- ${upload.relativePath} (${upload.mimeType}, ${size})`);
+  }
+  return lines.join("\n");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function findGitHubPrAttachment(attachments) {
+  if (!attachments) {
+    return null;
+  }
+  return attachments.find(
+    (attachment) => attachment.type === "github_pr"
+  ) ?? null;
+}
+
+// ../server/src/server/uploads/session-upload-store.ts
+import { promises as fs } from "node:fs";
+import * as path5 from "node:path";
+var MAX_UPLOAD_BYTES_PER_MESSAGE = 50 * 1024 * 1024;
+var MAX_UPLOAD_BYTES_PER_FILE = 50 * 1024 * 1024;
+var UPLOADS_DIR_REL = path5.posix.join(".appostle", "uploaded_files");
+var MANIFEST_BASENAME = "uploads.json";
+function originalUploadFileName(relativePath) {
+  const safe = path5.posix.normalize(relativePath);
+  if (!safe.startsWith(`${UPLOADS_DIR_REL}/`)) return null;
+  const baseName = path5.posix.basename(safe);
+  const sep4 = baseName.indexOf("__");
+  if (sep4 < 0) return null;
+  return baseName.slice(sep4 + 2);
+}
+var GITIGNORE_MARKER_LINE = "# Added by Appostle: uploaded chat attachments";
+var GITIGNORE_BLOCK = `${GITIGNORE_MARKER_LINE}
+.appostle/
+`;
+function emptyManifest() {
+  return { version: 1, uploads: [] };
+}
+function sanitizeFileName(input) {
+  const stripped = input.replace(/[\\/\x00-\x1F\x7F]/g, "_").trim();
+  const noTraversal = stripped.replace(/\.{2,}/g, ".");
+  const trimmed = noTraversal.replace(/^[.\s]+|[\s.]+$/g, "");
+  if (trimmed.length === 0) {
+    return "upload.bin";
+  }
+  return trimmed.slice(0, 200);
+}
+function manifestDirFor(cwd) {
+  return path5.join(cwd, UPLOADS_DIR_REL);
+}
+function manifestPathFor(cwd) {
+  return path5.join(manifestDirFor(cwd), MANIFEST_BASENAME);
+}
+function relativeUploadPath(id, sanitizedName) {
+  return path5.posix.join(UPLOADS_DIR_REL, `${id}__${sanitizedName}`);
+}
+var UploadSizeError = class extends Error {
+  constructor(totalBytes, cap) {
+    super(`Upload payload exceeds ${cap} bytes (got ${totalBytes})`);
+    this.totalBytes = totalBytes;
+    this.cap = cap;
+    this.name = "UploadSizeError";
+  }
+};
+var SessionUploadStore = class {
+  constructor(opts = {}) {
+    this.logger = opts.logger;
+  }
+  /**
+   * Decode and write each file. Throws `UploadSizeError` if either a single
+   * file exceeds the per-file cap or the message total exceeds the per-message
+   * cap. On success, returns the manifest entries (in the same order as input).
+   */
+  async persistFiles(params) {
+    const { cwd, agentId, files, messageId } = params;
+    if (files.length === 0) {
+      return [];
+    }
+    const decoded = [];
+    let totalBytes = 0;
+    for (const file of files) {
+      let bytes;
+      try {
+        bytes = Buffer.from(file.data, "base64");
+      } catch (error) {
+        throw new Error(
+          `Failed to decode base64 payload for "${file.fileName}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (bytes.length > MAX_UPLOAD_BYTES_PER_FILE) {
+        throw new UploadSizeError(bytes.length, MAX_UPLOAD_BYTES_PER_FILE);
+      }
+      totalBytes += bytes.length;
+      if (totalBytes > MAX_UPLOAD_BYTES_PER_MESSAGE) {
+        throw new UploadSizeError(totalBytes, MAX_UPLOAD_BYTES_PER_MESSAGE);
+      }
+      decoded.push({ file, bytes });
+    }
+    await fs.mkdir(manifestDirFor(cwd), { recursive: true });
+    await this.ensureGitignoreEntry(cwd);
+    const manifest = await this.readManifest(cwd);
+    const created = [];
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const { file, bytes } of decoded) {
+      const id = crypto.randomUUID();
+      const sanitizedName = sanitizeFileName(file.fileName);
+      const relPath = relativeUploadPath(id, sanitizedName);
+      const absPath = path5.join(cwd, relPath);
+      await fs.writeFile(absPath, bytes);
+      const entry = {
+        id,
+        fileName: sanitizedName,
+        mimeType: file.mimeType,
+        size: bytes.length,
+        createdAt,
+        messageId,
+        relativePath: relPath
+      };
+      manifest.uploads.push({ ...entry, agentId });
+      created.push(entry);
+    }
+    await this.writeManifest(cwd, manifest);
+    this.logger?.info(
+      { agentId, count: created.length, totalBytes },
+      "Persisted chat file uploads"
+    );
+    return created;
+  }
+  /**
+   * Read bytes back from disk by workspace-relative path. Symmetric with
+   * `SessionImageStore.readImageBytes` so the fetch-bytes RPC handler can
+   * route uniformly. Traversal-guarded: refuses anything that escapes
+   * `.appostle/uploaded_files/` or contains `..`.
+   */
+  async readUploadBytes(params) {
+    const safe = path5.posix.normalize(params.relativePath);
+    if (!safe.startsWith(`${UPLOADS_DIR_REL}/`) || safe.includes("..")) {
+      throw new Error(`Refused to read upload outside ${UPLOADS_DIR_REL}: ${params.relativePath}`);
+    }
+    const abs = path5.join(params.cwd, safe);
+    const data = await fs.readFile(abs);
+    const baseName = path5.posix.basename(safe);
+    const sep4 = baseName.indexOf("__");
+    const fileName = sep4 >= 0 ? baseName.slice(sep4 + 2) : baseName;
+    let mimeType = "application/octet-stream";
+    try {
+      const manifest = await this.readManifest(params.cwd);
+      const match = manifest.uploads.find((entry) => entry.relativePath === safe);
+      if (match) {
+        mimeType = match.mimeType;
+      }
+    } catch {
+    }
+    return { data, mimeType, byteSize: data.length, fileName };
+  }
+  /**
+   * List every file stored for this workspace. Workspace-scoped, NOT
+   * agent-scoped — uploads live under `<workspace>/.appostle/uploaded_files/`
+   * and persist across agent lifecycles, so filtering by `agentId` would hide
+   * files attached by older or sibling agents in the same workspace. (Mirrors
+   * the image store's directory-scan behaviour.) The `agentId` parameter is
+   * preserved on the API for backward-compat but ignored.
+   *
+   * Newest first.
+   */
+  async listUploads(params) {
+    const manifest = await this.readManifest(params.cwd);
+    return manifest.uploads.map(({ agentId: _agentId, ...rest }) => rest).sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
+  }
+  /**
+   * Delete a file by upload id. Workspace-scoped to match `listUploads` — any
+   * agent in the workspace can delete any file. The `agentId` parameter is
+   * preserved on the API for backward-compat but ignored.
+   */
+  async deleteUpload(params) {
+    const manifest = await this.readManifest(params.cwd);
+    const idx = manifest.uploads.findIndex((entry) => entry.id === params.uploadId);
+    if (idx === -1) {
+      return { deleted: false };
+    }
+    const [removed] = manifest.uploads.splice(idx, 1);
+    if (removed) {
+      const absPath = path5.join(params.cwd, removed.relativePath);
+      try {
+        await fs.unlink(absPath);
+      } catch (error) {
+        this.logger?.warn(
+          { uploadId: params.uploadId, error: error.message },
+          "deleteUpload: file already missing, removing manifest entry"
+        );
+      }
+    }
+    await this.writeManifest(params.cwd, manifest);
+    return { deleted: true };
+  }
+  async readManifest(cwd) {
+    const file = manifestPathFor(cwd);
+    let raw;
+    try {
+      raw = await fs.readFile(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return emptyManifest();
+      }
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.logger?.warn({ file }, "Manifest is not valid JSON; treating as empty");
+      return emptyManifest();
+    }
+    if (typeof parsed === "object" && parsed !== null && "version" in parsed && parsed.version === 1 && Array.isArray(parsed.uploads)) {
+      return parsed;
+    }
+    return emptyManifest();
+  }
+  async writeManifest(cwd, manifest) {
+    const file = manifestPathFor(cwd);
+    const tmp = `${file}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(manifest, null, 2), "utf8");
+    await fs.rename(tmp, file);
+  }
+  /** Append a `.appostle/` ignore line to the workspace `.gitignore`, idempotently. */
+  async ensureGitignoreEntry(cwd) {
+    const file = path5.join(cwd, ".gitignore");
+    let existing = "";
+    try {
+      existing = await fs.readFile(file, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    if (existing.includes(GITIGNORE_MARKER_LINE)) {
+      return;
+    }
+    const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+    await fs.writeFile(file, `${existing}${separator}${GITIGNORE_BLOCK}`, "utf8");
+  }
+};
+
+// ../server/src/server/uploads/session-image-store.ts
+import { promises as fs2 } from "node:fs";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import * as path6 from "node:path";
+var IMAGES_DIR_REL = path6.posix.join(".appostle", "uploaded_images");
+var GITIGNORE_MARKER_LINE2 = "# Added by Appostle: uploaded chat attachments";
+var GITIGNORE_BLOCK2 = `${GITIGNORE_MARKER_LINE2}
+.appostle/
+`;
+var EXTENSION_BY_MIME = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/avif": "avif",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "image/tiff": "tiff",
+  "image/bmp": "bmp",
+  "image/svg+xml": "svg"
+};
+function extensionForImage(input) {
+  if (input.fileName) {
+    const dot = input.fileName.lastIndexOf(".");
+    if (dot >= 0 && dot < input.fileName.length - 1) {
+      const ext = input.fileName.slice(dot + 1).toLowerCase();
+      if (/^[a-z0-9]{1,8}$/.test(ext)) {
+        return ext;
+      }
+    }
+  }
+  return EXTENSION_BY_MIME[input.mimeType] ?? "img";
+}
+function mimeTypeForExtension(ext) {
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    case "avif":
+      return "image/avif";
+    case "heic":
+      return "image/heic";
+    case "heif":
+      return "image/heif";
+    case "tiff":
+      return "image/tiff";
+    case "bmp":
+      return "image/bmp";
+    case "svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+}
+var SessionImageStore = class {
+  constructor(opts = {}) {
+    this.logger = opts.logger;
+  }
+  /**
+   * Decode and write each image. Throws `UploadSizeError` on cap violations.
+   * On success returns one entry per input image (in order).
+   */
+  async persistImages(params) {
+    const { cwd, agentId, messageId, images } = params;
+    if (images.length === 0) {
+      return [];
+    }
+    const decoded = [];
+    let totalBytes = 0;
+    for (const image of images) {
+      let bytes;
+      try {
+        bytes = Buffer.from(image.data, "base64");
+      } catch (error) {
+        throw new Error(
+          `Failed to decode base64 image: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (bytes.length > MAX_UPLOAD_BYTES_PER_FILE) {
+        throw new UploadSizeError(bytes.length, MAX_UPLOAD_BYTES_PER_FILE);
+      }
+      totalBytes += bytes.length;
+      if (totalBytes > MAX_UPLOAD_BYTES_PER_MESSAGE) {
+        throw new UploadSizeError(totalBytes, MAX_UPLOAD_BYTES_PER_MESSAGE);
+      }
+      const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 16);
+      decoded.push({ image, bytes, hash });
+    }
+    const dir = path6.join(cwd, IMAGES_DIR_REL);
+    await fs2.mkdir(dir, { recursive: true });
+    await this.ensureGitignoreEntry(cwd);
+    const created = [];
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const timestampMs = Date.now();
+    for (const entry of decoded) {
+      const ext = extensionForImage({
+        mimeType: entry.image.mimeType,
+        fileName: entry.image.fileName
+      });
+      const baseName = `${timestampMs}-${entry.hash}.${ext}`;
+      const relPath = path6.posix.join(IMAGES_DIR_REL, baseName);
+      const absPath = path6.join(cwd, relPath);
+      await fs2.writeFile(absPath, entry.bytes);
+      created.push({
+        id: entry.image.id ?? randomUUID(),
+        fileName: entry.image.fileName ?? null,
+        mimeType: entry.image.mimeType,
+        size: entry.bytes.length,
+        createdAt,
+        messageId,
+        relativePath: relPath,
+        hash: entry.hash
+      });
+    }
+    this.logger?.info(
+      { agentId, count: created.length, totalBytes },
+      "Persisted chat image uploads"
+    );
+    return created;
+  }
+  /**
+   * Read bytes back from disk by workspace-relative path. Used by the (future
+   * Phase 4) fetch-bytes RPC and by Phase 3's prompt-build path.
+   *
+   * Defense in depth: refuses anything outside `.appostle/uploaded_images/`
+   * or anything containing `..`. The caller is the trust boundary, but
+   * costing nothing to double-check at the I/O edge.
+   */
+  async readImageBytes(params) {
+    const safe = path6.posix.normalize(params.relativePath);
+    if (!safe.startsWith(`${IMAGES_DIR_REL}/`) || safe.includes("..")) {
+      throw new Error(`Refused to read image outside ${IMAGES_DIR_REL}: ${params.relativePath}`);
+    }
+    const abs = path6.join(params.cwd, safe);
+    const data = await fs2.readFile(abs);
+    const ext = path6.extname(safe).slice(1).toLowerCase();
+    return { data, mimeType: mimeTypeForExtension(ext), byteSize: data.length };
+  }
+  /**
+   * List every image stored for this workspace. There is no manifest — the
+   * directory listing IS the source of truth. Filenames carry the timestamp
+   * (`<unix_ms>-<hash>.<ext>`); we parse that for `createdAt` and fall back to
+   * file mtime if the prefix is missing.
+   *
+   * Returns newest-first to match the upload-store ordering expected by the UI.
+   */
+  async listImages(params) {
+    const dir = path6.join(params.cwd, IMAGES_DIR_REL);
+    let names;
+    try {
+      names = await fs2.readdir(dir);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    const entries = [];
+    for (const name of names) {
+      if (name.startsWith(".")) continue;
+      const abs = path6.join(dir, name);
+      let stat5;
+      try {
+        stat5 = await fs2.stat(abs);
+      } catch {
+        continue;
+      }
+      if (!stat5.isFile()) continue;
+      const ext = path6.extname(name).slice(1).toLowerCase();
+      const mimeType = mimeTypeForExtension(ext);
+      let createdAt;
+      const dash = name.indexOf("-");
+      const msCandidate = dash > 0 ? Number(name.slice(0, dash)) : Number.NaN;
+      if (Number.isFinite(msCandidate) && msCandidate > 0) {
+        createdAt = new Date(msCandidate).toISOString();
+      } else {
+        createdAt = stat5.mtime.toISOString();
+      }
+      const relPath = path6.posix.join(IMAGES_DIR_REL, name);
+      entries.push({
+        id: relPath,
+        fileName: name,
+        mimeType,
+        size: stat5.size,
+        createdAt,
+        relativePath: relPath
+      });
+    }
+    entries.sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
+    return entries;
+  }
+  /**
+   * Delete a single stored image by workspace-relative path. Same traversal
+   * guard as `readImageBytes`. Idempotent: returns `{ deleted: false }` if
+   * the file is already gone (so the caller can refresh its listing).
+   */
+  async deleteImage(params) {
+    const safe = path6.posix.normalize(params.relativePath);
+    if (!safe.startsWith(`${IMAGES_DIR_REL}/`) || safe.includes("..")) {
+      throw new Error(`Refused to delete image outside ${IMAGES_DIR_REL}: ${params.relativePath}`);
+    }
+    const abs = path6.join(params.cwd, safe);
+    try {
+      await fs2.unlink(abs);
+      return { deleted: true };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { deleted: false };
+      }
+      throw error;
+    }
+  }
+  async ensureGitignoreEntry(cwd) {
+    const file = path6.join(cwd, ".gitignore");
+    let existing = "";
+    try {
+      existing = await fs2.readFile(file, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    if (existing.includes(GITIGNORE_MARKER_LINE2)) {
+      return;
+    }
+    const sep4 = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+    await fs2.writeFile(file, `${existing}${sep4}${GITIGNORE_BLOCK2}`, "utf8");
+  }
+};
+
 // ../server/src/server/session.ts
 import { experimental_createMCPClient } from "ai";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -9857,14 +10671,14 @@ function parseDiff(diffText) {
     const firstLine = lines[0];
     const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
     const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
-    let path24 = "unknown";
+    let path26 = "unknown";
     const pathMatch = firstLine.match(/a\/(.*?) b\//);
     if (pathMatch) {
-      path24 = pathMatch[1];
+      path26 = pathMatch[1];
     } else {
       const newFileMatch = firstLine.match(/b\/(.+)$/);
       if (newFileMatch) {
-        path24 = newFileMatch[1];
+        path26 = newFileMatch[1];
       }
     }
     const hunks = [];
@@ -9908,7 +10722,7 @@ function parseDiff(diffText) {
     if (currentHunk) {
       hunks.push(currentHunk);
     }
-    files.push({ path: path24, isNew, isDeleted, additions, deletions, hunks });
+    files.push({ path: path26, isNew, isDeleted, additions, deletions, hunks });
   }
   return files;
 }
@@ -9964,9 +10778,9 @@ function buildTokenLookup(lineMap, highlighted) {
   }
   return lookup2;
 }
-function buildFullFileTokenLookup(fileContent, path24) {
+function buildFullFileTokenLookup(fileContent, path26) {
   const lookup2 = /* @__PURE__ */ new Map();
-  const highlighted = highlightCode(fileContent, path24);
+  const highlighted = highlightCode(fileContent, path26);
   for (let i = 0; i < highlighted.length; i++) {
     lookup2.set(i + 1, highlighted[i]);
   }
@@ -11667,11 +12481,11 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
       }
       continue;
     }
-    const path24 = tabParts[1];
-    if (!path24) continue;
+    const path26 = tabParts[1];
+    if (!path26) continue;
     const code = rawStatus[0];
     changes.push({
-      path: path24,
+      path: path26,
       status: rawStatus,
       isNew: code === "A",
       isDeleted: code === "D"
@@ -11706,9 +12520,9 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
   }
   return Array.from(byPath.values());
 }
-async function readGitFileContentAtRef(cwd, ref, path24) {
+async function readGitFileContentAtRef(cwd, ref, path26) {
   try {
-    const { stdout } = await runGitCommand(["show", `${ref}:${path24}`], {
+    const { stdout } = await runGitCommand(["show", `${ref}:${path26}`], {
       cwd,
       env: READ_ONLY_GIT_ENV2
     });
@@ -11769,21 +12583,21 @@ async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
     const additionsField = parts[0] ?? "";
     const deletionsField = parts[1] ?? "";
     const rawPath = parts.slice(2).join("	");
-    const path24 = normalizeNumstatPath(rawPath);
-    if (!path24) {
+    const path26 = normalizeNumstatPath(rawPath);
+    if (!path26) {
       continue;
     }
     if (additionsField === "-" || deletionsField === "-") {
-      stats.set(path24, { additions: 0, deletions: 0, isBinary: true });
+      stats.set(path26, { additions: 0, deletions: 0, isBinary: true });
       continue;
     }
     const additions = Number.parseInt(additionsField, 10);
     const deletions = Number.parseInt(deletionsField, 10);
     if (Number.isNaN(additions) || Number.isNaN(deletions)) {
-      stats.set(path24, null);
+      stats.set(path26, null);
       continue;
     }
-    stats.set(path24, { additions, deletions, isBinary: false });
+    stats.set(path26, { additions, deletions, isBinary: false });
   }
   return stats;
 }
@@ -12368,10 +13182,10 @@ async function listUncommittedFiles(cwd) {
         if (dest) results.push({ path: dest, changeType: code });
         continue;
       }
-      const path24 = parts[1];
-      if (!path24) continue;
+      const path26 = parts[1];
+      if (!path26) continue;
       if (code === "A" || code === "M" || code === "D") {
-        results.push({ path: path24, changeType: code });
+        results.push({ path: path26, changeType: code });
       }
     }
   } catch {
@@ -14069,11 +14883,11 @@ async function spawnWorktreeScripts(options) {
 }
 
 // ../server/src/server/agent/providers/claude-agent.ts
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs3 from "node:fs";
 import { promises } from "node:fs";
 import os2 from "node:os";
-import path6 from "node:path";
+import path8 from "node:path";
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
@@ -15148,7 +15962,7 @@ function mapClaudeCanceledToolCall(params) {
 }
 
 // ../server/src/server/agent/providers/claude/task-notification-tool-call.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { z as z21 } from "zod";
 var TASK_NOTIFICATION_MARKER = "<task-notification>";
 var TAG_NAME_PATTERN = /[.*+?^${}()|[\]\\]/g;
@@ -15285,7 +16099,7 @@ function buildTaskNotificationCallId(envelope) {
     return `task_notification_${taskSegment}`;
   }
   const seed = [envelope.status, envelope.summary, envelope.outputFile, envelope.rawText].filter((value) => typeof value === "string").join("|") || "task_notification";
-  const digest = createHash2("sha1").update(seed).digest("hex").slice(0, 12);
+  const digest = createHash3("sha1").update(seed).digest("hex").slice(0, 12);
   return `task_notification_${digest}`;
 }
 function buildTaskNotificationLabel(envelope) {
@@ -15464,6 +16278,40 @@ function normalizeClaudeRuntimeModelId(value) {
   return `claude-${family}-${major}-${minor}${suffix}`;
 }
 
+// ../server/src/server/agent/providers/claude-feature-definitions.ts
+var CLAUDE_FAST_MODE_SUPPORTED_MODEL_PREFIXES = ["claude-opus-"];
+var CLAUDE_FAST_MODE_FEATURE = {
+  type: "toggle",
+  id: "fast_mode",
+  label: "Fast",
+  description: "Priority inference for faster responses",
+  tooltip: "Toggle fast mode",
+  icon: "zap"
+};
+function normalizeClaudeModelId(modelId) {
+  const normalized = typeof modelId === "string" ? modelId.trim() : "";
+  return normalized.length > 0 ? normalized : null;
+}
+function claudeModelSupportsFastMode(modelId) {
+  const normalizedModelId = normalizeClaudeModelId(modelId);
+  if (!normalizedModelId) {
+    return false;
+  }
+  return CLAUDE_FAST_MODE_SUPPORTED_MODEL_PREFIXES.some(
+    (prefix) => normalizedModelId.startsWith(prefix)
+  );
+}
+function buildClaudeFeatures(input) {
+  const features = [];
+  if (claudeModelSupportsFastMode(input.modelId)) {
+    features.push({
+      ...CLAUDE_FAST_MODE_FEATURE,
+      value: input.fastModeEnabled
+    });
+  }
+  return features;
+}
+
 // ../server/src/server/agent/providers/claude/partial-json.ts
 function skipWhitespace(input, index) {
   let currentIndex = index;
@@ -16031,62 +16879,8 @@ async function resolveBinaryVersion(binaryPath) {
   }
 }
 
-// ../server/src/server/agent/prompt-attachments.ts
-function renderPromptAttachmentAsText(attachment) {
-  switch (attachment.type) {
-    case "github_pr": {
-      const lines = [`GitHub PR #${attachment.number}: ${attachment.title}`, attachment.url];
-      if (attachment.baseRefName) {
-        lines.push(`Base: ${attachment.baseRefName}`);
-      }
-      if (attachment.headRefName) {
-        lines.push(`Head: ${attachment.headRefName}`);
-      }
-      if (attachment.body) {
-        lines.push("", attachment.body);
-      }
-      return lines.join("\n");
-    }
-    case "github_issue": {
-      const lines = [`GitHub Issue #${attachment.number}: ${attachment.title}`, attachment.url];
-      if (attachment.body) {
-        lines.push("", attachment.body);
-      }
-      return lines.join("\n");
-    }
-    case "gitlab_mr": {
-      const lines = [`GitLab MR !${attachment.iid}: ${attachment.title}`, attachment.url];
-      if (attachment.targetBranch) {
-        lines.push(`Target: ${attachment.targetBranch}`);
-      }
-      if (attachment.sourceBranch) {
-        lines.push(`Source: ${attachment.sourceBranch}`);
-      }
-      if (attachment.body) {
-        lines.push("", attachment.body);
-      }
-      return lines.join("\n");
-    }
-    case "gitlab_issue": {
-      const lines = [`GitLab Issue #${attachment.iid}: ${attachment.title}`, attachment.url];
-      if (attachment.body) {
-        lines.push("", attachment.body);
-      }
-      return lines.join("\n");
-    }
-  }
-}
-function findGitHubPrAttachment(attachments) {
-  if (!attachments) {
-    return null;
-  }
-  return attachments.find(
-    (attachment) => attachment.type === "github_pr"
-  ) ?? null;
-}
-
 // ../server/src/server/agent/plan-filename.ts
-import path5 from "node:path";
+import path7 from "node:path";
 var MAX_SLUG_LENGTH2 = 40;
 function slugifyPlanName(name) {
   if (typeof name !== "string") {
@@ -16135,12 +16929,12 @@ function extractPlanNameFromFrontmatter(content) {
 }
 function resolvePlanFilename(options) {
   const { originalPath, newSlug, existsSync: existsSync14 } = options;
-  const dir = path5.dirname(originalPath);
+  const dir = path7.dirname(originalPath);
   const base = `${newSlug}.md`;
-  let candidate = path5.join(dir, base);
+  let candidate = path7.join(dir, base);
   let counter = 2;
   while (candidate !== originalPath && existsSync14(candidate)) {
-    candidate = path5.join(dir, `${newSlug}-${counter}.md`);
+    candidate = path7.join(dir, `${newSlug}-${counter}.md`);
     counter += 1;
   }
   return candidate;
@@ -16691,18 +17485,20 @@ function toClaudeSdkMcpConfig(config) {
         url: config.url,
         headers: config.headers
       };
+    case "sdk":
+      return config.config;
   }
 }
 var homeMcpServersCache = null;
 function loadHomeMcpServers(logger) {
   try {
     const home = process.env.HOME ?? os2.homedir();
-    const filePath = path6.join(home, ".claude.json");
-    const stat5 = fs.statSync(filePath);
+    const filePath = path8.join(home, ".claude.json");
+    const stat5 = fs3.statSync(filePath);
     if (homeMcpServersCache && homeMcpServersCache.mtimeMs === stat5.mtimeMs) {
       return homeMcpServersCache.servers;
     }
-    const raw = fs.readFileSync(filePath, "utf8");
+    const raw = fs3.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isMetadata(parsed)) return null;
     const rawServers = parsed.mcpServers;
@@ -17049,8 +17845,8 @@ var ClaudeAgentClient = class {
     return getClaudeModels();
   }
   async listPersistedAgents(options) {
-    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path6.join(os2.homedir(), ".claude");
-    const projectsRoot = path6.join(configDir, "projects");
+    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path8.join(os2.homedir(), ".claude");
+    const projectsRoot = path8.join(configDir, "projects");
     if (!await pathExists2(projectsRoot)) {
       return [];
     }
@@ -17271,9 +18067,10 @@ var ClaudeAgentSession = class {
     this.userMessageIds = [];
     this.recentStderr = "";
     this.closed = false;
+    this.fastModeEnabled = false;
     this.handlePermissionRequest = async (toolName, input, options) => {
       this.maybeRewritePlanFilename(toolName, input);
-      const requestId = `permission-${randomUUID()}`;
+      const requestId = `permission-${randomUUID2()}`;
       const kind = resolvePermissionKind(toolName, input);
       if (kind === "tool") {
         if (this.currentMode === "bypassPermissions") {
@@ -17369,10 +18166,17 @@ var ClaudeAgentSession = class {
     if (this.currentMode !== "plan") {
       this.planResumeMode = this.currentMode;
     }
+    this.fastModeEnabled = Boolean(config.featureValues?.fast_mode);
   }
   get id() {
     return this.claudeSessionId;
   }
+  get features() {
+    return buildClaudeFeatures({
+      modelId: this.config.model,
+      fastModeEnabled: this.fastModeEnabled
+    });
+  }
   async getRuntimeInfo() {
     if (this.cachedRuntimeInfo) {
       return { ...this.cachedRuntimeInfo };
@@ -17611,6 +18415,41 @@ var ClaudeAgentSession = class {
     }
     this.queryRestartNeeded = true;
   }
+  async setFeature(featureId, value) {
+    if (featureId === "fast_mode") {
+      const next = Boolean(value);
+      if (next === this.fastModeEnabled) {
+        return;
+      }
+      this.fastModeEnabled = next;
+      this.config.featureValues = {
+        ...this.config.featureValues ?? {},
+        fast_mode: next
+      };
+      this.cachedRuntimeInfo = null;
+      if (this.query?.applyFlagSettings) {
+        await this.query.applyFlagSettings({ fastMode: next });
+        const queryWithGetSettings = this.query;
+        if (typeof queryWithGetSettings.getSettings === "function") {
+          try {
+            const effective = await queryWithGetSettings.getSettings();
+            const observedFastMode = effective && typeof effective === "object" && "fastMode" in effective && typeof effective.fastMode === "boolean" ? effective.fastMode : null;
+            this.logger.info(
+              { featureId, requested: next, observed: observedFastMode },
+              "claude: fast_mode read-back from SDK"
+            );
+          } catch (error) {
+            this.logger.warn(
+              { err: error, featureId },
+              "claude: fast_mode getSettings read-back failed"
+            );
+          }
+        }
+      }
+      return;
+    }
+    throw new Error(`Unknown feature: ${featureId}`);
+  }
   getPendingPermissions() {
     return Array.from(this.pendingPermissions.values()).map((entry) => entry.request);
   }
@@ -17862,12 +18701,12 @@ var ClaudeAgentSession = class {
       return [];
     }
     const historyPath = this.resolveHistoryPath(this.claudeSessionId);
-    if (!historyPath || !fs.existsSync(historyPath)) {
+    if (!historyPath || !fs3.existsSync(historyPath)) {
       return [];
     }
     try {
       const ids = [];
-      const content = fs.readFileSync(historyPath, "utf8");
+      const content = fs3.readFileSync(historyPath, "utf8");
       for (const line of content.split(/\n+/)) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -18013,6 +18852,10 @@ var ClaudeAgentSession = class {
       ...this.claudeSessionId ? { resume: this.claudeSessionId } : {},
       ...thinking ? { thinking } : {},
       ...effort ? { effort } : {},
+      // Initial-spawn path for fast mode: bake the flag into the new
+      // process's flag-settings layer. Mid-session toggles go through
+      // setFeature → query.applyFlagSettings instead (no restart needed).
+      ...this.fastModeEnabled ? { settings: { fastMode: true } } : {},
       ...this.config.extra?.claude
     };
     if (this.config.mcpServers) {
@@ -18060,7 +18903,9 @@ var ClaudeAgentSession = class {
     if (Array.isArray(prompt)) {
       for (const chunk of prompt) {
         if (chunk.type === "text") {
-          content.push({ type: "text", text: chunk.text });
+          if (chunk.text.length > 0) {
+            content.push({ type: "text", text: chunk.text });
+          }
         } else if (chunk.type === "image") {
           content.push({
             type: "image",
@@ -18071,13 +18916,19 @@ var ClaudeAgentSession = class {
             }
           });
         } else if (chunk.type === "github_pr" || chunk.type === "github_issue" || chunk.type === "gitlab_mr" || chunk.type === "gitlab_issue") {
-          content.push({ type: "text", text: renderPromptAttachmentAsText(chunk) });
+          const rendered = renderPromptAttachmentAsText(chunk);
+          if (rendered.length > 0) {
+            content.push({ type: "text", text: rendered });
+          }
         }
       }
-    } else {
+    } else if (prompt.length > 0) {
       content.push({ type: "text", text: prompt });
     }
-    const messageId = randomUUID();
+    if (content.length === 0) {
+      content.push({ type: "text", text: "(empty message)" });
+    }
+    const messageId = randomUUID2();
     this.rememberUserMessageId(messageId);
     return {
       type: "user",
@@ -18610,6 +19461,43 @@ ${error.stack ?? ""}` : JSON.stringify(error);
         }
         break;
       }
+      case "rate_limit_event": {
+        const info = message.rate_limit_info;
+        if (info && typeof info === "object") {
+          const { rateLimitType, utilization, resetsAt } = info;
+          const VALID_TYPES = /* @__PURE__ */ new Set([
+            "five_hour",
+            "seven_day",
+            "seven_day_opus",
+            "seven_day_sonnet",
+            "overage"
+          ]);
+          if (typeof rateLimitType === "string" && VALID_TYPES.has(rateLimitType) && typeof utilization === "number") {
+            const rateLimit = {
+              rateLimitType,
+              utilization
+            };
+            if (typeof resetsAt === "number") {
+              rateLimit.resetsAt = resetsAt;
+            }
+            const existingLimits = this.lastRateLimits ?? [];
+            const updated = existingLimits.filter((l) => l.rateLimitType !== rateLimitType);
+            updated.push(rateLimit);
+            this.lastRateLimits = updated;
+            const usage = {
+              rateLimits: updated
+            };
+            if (this.lastContextWindowMaxTokens !== void 0) {
+              usage.contextWindowMaxTokens = this.lastContextWindowMaxTokens;
+            }
+            if (this.lastContextWindowUsedTokens !== void 0) {
+              usage.contextWindowUsedTokens = this.lastContextWindowUsedTokens;
+            }
+            events.push({ type: "usage_updated", provider: "claude", usage });
+          }
+        }
+        break;
+      }
       default:
         break;
     }
@@ -18718,6 +19606,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       outputTokens: message.usage.output_tokens,
       totalCostUsd: message.total_cost_usd
     };
+    if (this.lastRateLimits !== void 0) {
+      usage.rateLimits = this.lastRateLimits;
+    }
     const contextWindowMaxTokens = extractContextWindowSize(modelUsage ?? message.modelUsage);
     if (contextWindowMaxTokens !== void 0) {
       this.lastContextWindowMaxTokens = contextWindowMaxTokens;
@@ -18790,9 +19681,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       if (typeof filePath !== "string" || typeof content !== "string") {
         return;
       }
-      const dir = path6.dirname(filePath);
-      const dirName = path6.basename(dir);
-      const baseName = path6.basename(filePath);
+      const dir = path8.dirname(filePath);
+      const dirName = path8.basename(dir);
+      const baseName = path8.basename(filePath);
       if (dirName !== ".plans" || !baseName.endsWith(".md")) {
         return;
       }
@@ -18811,7 +19702,7 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       const newPath = resolvePlanFilename({
         originalPath: filePath,
         newSlug: slug,
-        existsSync: fs.existsSync
+        existsSync: fs3.existsSync
       });
       if (newPath === filePath) {
         return;
@@ -18899,10 +19790,10 @@ ${error.stack ?? ""}` : JSON.stringify(error);
   loadPersistedHistory(sessionId) {
     try {
       const historyPath = this.resolveHistoryPath(sessionId);
-      if (!historyPath || !fs.existsSync(historyPath)) {
+      if (!historyPath || !fs3.existsSync(historyPath)) {
         return;
       }
-      this.ingestPersistedHistory(fs.readFileSync(historyPath, "utf8"));
+      this.ingestPersistedHistory(fs3.readFileSync(historyPath, "utf8"));
     } catch (error) {
     }
   }
@@ -18945,9 +19836,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
     const cwd = this.config.cwd;
     if (!cwd) return null;
     const sanitized = sanitizeClaudeProjectPath(cwd);
-    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path6.join(os2.homedir(), ".claude");
-    const dir = path6.join(configDir, "projects", sanitized);
-    return path6.join(dir, `${sessionId}.jsonl`);
+    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path8.join(os2.homedir(), ".claude");
+    const dir = path8.join(configDir, "projects", sanitized);
+    return path8.join(dir, `${sessionId}.jsonl`);
   }
   convertHistoryEntry(entry) {
     return convertClaudeHistoryEntry(entry, (content) => this.mapBlocksToTimeline(content));
@@ -19087,10 +19978,10 @@ ${error.stack ?? ""}` : JSON.stringify(error);
       return void 0;
     }
     const server = entry?.server ?? block.server ?? "tool";
-    const tool = entry?.name ?? block.tool_name ?? "tool";
+    const tool2 = entry?.name ?? block.tool_name ?? "tool";
     const content = coerceToolResultContentToString(block.content);
     const input = entry?.input;
-    const structured = this.buildStructuredToolResult(server, tool, content, input);
+    const structured = this.buildStructuredToolResult(server, tool2, content, input);
     if (structured) {
       return structured;
     }
@@ -19107,9 +19998,9 @@ ${error.stack ?? ""}` : JSON.stringify(error);
     }
     return Object.keys(result).length > 0 ? result : void 0;
   }
-  buildStructuredToolResult(server, tool, output, input) {
+  buildStructuredToolResult(server, tool2, output, input) {
     const normalizedServer = server.toLowerCase();
-    const normalizedTool = tool.toLowerCase();
+    const normalizedTool = tool2.toLowerCase();
     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 {
@@ -19409,7 +20300,7 @@ ${error.stack ?? ""}` : JSON.stringify(error);
   }
   detectFileKind(filePath) {
     try {
-      return fs.existsSync(filePath) ? "update" : "add";
+      return fs3.existsSync(filePath) ? "update" : "add";
     } catch {
       return "update";
     }
@@ -19420,8 +20311,8 @@ ${error.stack ?? ""}` : JSON.stringify(error);
     }
     const cwd = this.config.cwd;
     if (cwd && target.startsWith(cwd)) {
-      const relative = path6.relative(cwd, target);
-      return relative.length > 0 ? relative : path6.basename(target);
+      const relative = path8.relative(cwd, target);
+      return relative.length > 0 ? relative : path8.basename(target);
     }
     return target;
   }
@@ -19610,7 +20501,7 @@ async function collectRecentClaudeSessions(root, limit) {
   }
   const candidates = [];
   for (const dirName of projectDirs) {
-    const projectPath = path6.join(root, dirName);
+    const projectPath = path8.join(root, dirName);
     let stats;
     try {
       stats = await fsPromises.stat(projectPath);
@@ -19630,7 +20521,7 @@ async function collectRecentClaudeSessions(root, limit) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const fullPath = path6.join(projectPath, file);
+      const fullPath = path8.join(projectPath, file);
       try {
         const fileStats = await fsPromises.stat(fullPath);
         candidates.push({ path: fullPath, mtime: fileStats.mtime });
@@ -19805,17 +20696,17 @@ function unescapePartialJsonString(buffer, start) {
 
 // ../server/src/server/agent/providers/codex-app-server-agent.ts
 import { execSync as execSync2 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import fs3 from "node:fs/promises";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import fs5 from "node:fs/promises";
 import os4 from "node:os";
-import path8 from "node:path";
+import path10 from "node:path";
 import readline from "node:readline";
 import { z as z25 } from "zod";
 
 // ../server/src/server/agent/providers/codex-rollout-timeline.ts
-import { promises as fs2 } from "node:fs";
+import { promises as fs4 } from "node:fs";
 import os3 from "node:os";
-import path7 from "node:path";
+import path9 from "node:path";
 import { z as z24 } from "zod";
 
 // ../server/src/server/agent/providers/codex/tool-call-mapper.ts
@@ -20267,14 +21158,14 @@ function codexApplyPatchToUnifiedDiff(text) {
   for (const line of lines) {
     const directive = parseCodexApplyPatchDirective(line);
     if (directive) {
-      const path24 = normalizeDiffHeaderPath(directive.path);
-      if (path24.length > 0) {
+      const path26 = normalizeDiffHeaderPath(directive.path);
+      if (path26.length > 0) {
         if (output.length > 0 && output[output.length - 1] !== "") {
           output.push("");
         }
-        const left = directive.kind === "add" ? "/dev/null" : `a/${path24}`;
-        const right = directive.kind === "delete" ? "/dev/null" : `b/${path24}`;
-        output.push(`diff --git a/${path24} b/${path24}`);
+        const left = directive.kind === "add" ? "/dev/null" : `a/${path26}`;
+        const right = directive.kind === "delete" ? "/dev/null" : `b/${path26}`;
+        output.push(`diff --git a/${path26} b/${path26}`);
         output.push(`--- ${left}`);
         output.push(`+++ ${right}`);
         sawDiffContent = true;
@@ -20344,9 +21235,9 @@ function asEditTextFields(text) {
 function normalizeRolloutEditInput(input) {
   if (typeof input === "string") {
     const textFields2 = asEditTextFields(input);
-    const path24 = extractPatchPrimaryFilePath(input);
+    const path26 = extractPatchPrimaryFilePath(input);
     return {
-      ...path24 ? { path: path24 } : {},
+      ...path26 ? { path: path26 } : {},
       ...textFields2.unifiedDiff ? { patch: textFields2.unifiedDiff } : {},
       ...textFields2.newString ? { content: textFields2.newString } : {}
     };
@@ -20423,8 +21314,8 @@ function resolveStatus(rawStatus, error, output) {
   }
   return output !== null && output !== void 0 ? "completed" : "running";
 }
-function buildMcpToolName(server, tool) {
-  const trimmedTool = tool.trim();
+function buildMcpToolName(server, tool2) {
+  const trimmedTool = tool2.trim();
   if (!trimmedTool) {
     return "tool";
   }
@@ -20494,12 +21385,12 @@ function parseFileChangeDiff(entry) {
   ]);
 }
 function toFileChangeEntry(entry, options, fallbackPath) {
-  const path24 = parseFileChangePath(entry, options, fallbackPath);
-  if (!path24) {
+  const path26 = parseFileChangePath(entry, options, fallbackPath);
+  if (!path26) {
     return null;
   }
   return {
-    path: path24,
+    path: path26,
     kind: parseFileChangeKind(entry),
     diff: parseFileChangeDiff(entry)
   };
@@ -20521,12 +21412,12 @@ function parseFileChangeEntries(changes, options) {
   if (singleEntry) {
     return [singleEntry];
   }
-  return Object.entries(changes).map(([path24, value]) => {
+  return Object.entries(changes).map(([path26, value]) => {
     if (isRecord2(value)) {
-      return toFileChangeEntry(value, options, path24);
+      return toFileChangeEntry(value, options, path26);
     }
     if (typeof value === "string") {
-      const normalizedPath = normalizeCodexFilePath(path24.trim(), options?.cwd);
+      const normalizedPath = normalizeCodexFilePath(path26.trim(), options?.cwd);
       if (!normalizedPath) {
         return null;
       }
@@ -20594,11 +21485,11 @@ function mapFileChangeItem(item, options) {
   };
 }
 function mapMcpToolCallItem(item, options) {
-  const tool = item.tool.trim();
-  if (!tool) {
+  const tool2 = item.tool.trim();
+  if (!tool2) {
     return null;
   }
-  const name = buildMcpToolName(item.server, tool);
+  const name = buildMcpToolName(item.server, tool2);
   const input = item.arguments ?? null;
   const output = item.result ?? null;
   const error = item.error ?? null;
@@ -20688,8 +21579,8 @@ function resolveCodexSessionRoot() {
   if (process.env.CODEX_SESSION_DIR) {
     return process.env.CODEX_SESSION_DIR;
   }
-  const codexHome = process.env.CODEX_HOME ?? path7.join(os3.homedir(), ".codex");
-  return path7.join(codexHome, "sessions");
+  const codexHome = process.env.CODEX_HOME ?? path9.join(os3.homedir(), ".codex");
+  return path9.join(codexHome, "sessions");
 }
 async function findRolloutFile(threadId, root) {
   const stack = [{ dir: root, depth: 0 }];
@@ -20697,12 +21588,12 @@ async function findRolloutFile(threadId, root) {
     const { dir, depth } = stack.pop();
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs4.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path7.join(dir, entry.name);
+      const entryPath = path9.join(dir, entry.name);
       if (entry.isFile()) {
         const matchesThread = entry.name.includes(threadId);
         const matchesPrefix = entry.name.startsWith("rollout-");
@@ -21062,7 +21953,7 @@ function dedupeMirroredTextTimelineItems(timeline) {
   return deduped;
 }
 async function parseRolloutFile(filePath) {
-  const content = await fs2.readFile(filePath, "utf8");
+  const content = await fs4.readFile(filePath, "utf8");
   const trimmed = content.trim();
   if (!trimmed) {
     return [];
@@ -21115,7 +22006,7 @@ async function loadCodexPersistedTimeline(sessionId, options, logger) {
   const rolloutPath = options?.rolloutPath ?? null;
   if (rolloutPath) {
     try {
-      const stat5 = await fs2.stat(rolloutPath);
+      const stat5 = await fs4.stat(rolloutPath);
       if (stat5.isFile()) {
         const timeline = await parseRolloutFile(rolloutPath);
         if (timeline.length > 0) {
@@ -21271,16 +22162,16 @@ function isObjectSchemaNode(schema) {
   const type = schema.type;
   return isSchemaRecord(schema.properties) || type === "object" || Array.isArray(type) && type.includes("object");
 }
-function normalizeCodexOutputSchemaNode(schema, path24) {
+function normalizeCodexOutputSchemaNode(schema, path26) {
   if (Array.isArray(schema)) {
-    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path24}[${index}]`));
+    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path26}[${index}]`));
   }
   if (!isSchemaRecord(schema)) {
     return schema;
   }
   const normalized = {};
   for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path24}.${key}`);
+    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path26}.${key}`);
   }
   if (!isObjectSchemaNode(normalized)) {
     return normalized;
@@ -21289,7 +22180,7 @@ function normalizeCodexOutputSchemaNode(schema, path24) {
     normalized.additionalProperties = false;
   } else if (normalized.additionalProperties !== false) {
     throw new Error(
-      `Codex structured outputs require ${path24} to set additionalProperties to false for object schemas.`
+      `Codex structured outputs require ${path26} to set additionalProperties to false for object schemas.`
     );
   }
   const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
@@ -21330,7 +22221,7 @@ async function resolveCodexLaunchPrefix(runtimeSettings) {
   return resolveProviderCommandPrefix(runtimeSettings?.command, resolveCodexBinary);
 }
 function resolveCodexHomeDir() {
-  return process.env.CODEX_HOME ?? path8.join(os4.homedir(), ".codex");
+  return process.env.CODEX_HOME ?? path10.join(os4.homedir(), ".codex");
 }
 function tokenizeCommandArgs(args) {
   const tokens = [];
@@ -21410,10 +22301,10 @@ function parseFrontMatter(markdown) {
 }
 async function listCodexCustomPrompts() {
   const codexHome = resolveCodexHomeDir();
-  const promptsDir = path8.join(codexHome, "prompts");
+  const promptsDir = path10.join(codexHome, "prompts");
   let entries;
   try {
-    entries = await fs3.readdir(promptsDir, { withFileTypes: true });
+    entries = await fs5.readdir(promptsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -21429,10 +22320,10 @@ async function listCodexCustomPrompts() {
     if (!name) {
       continue;
     }
-    const fullPath = path8.join(promptsDir, entry.name);
+    const fullPath = path10.join(promptsDir, entry.name);
     let content;
     try {
-      content = await fs3.readFile(fullPath, "utf8");
+      content = await fs5.readFile(fullPath, "utf8");
     } catch {
       continue;
     }
@@ -21449,7 +22340,7 @@ async function listCodexCustomPrompts() {
 }
 async function listCodexSkills(cwd) {
   const candidates = [];
-  candidates.push(path8.join(cwd, ".codex", "skills"));
+  candidates.push(path10.join(cwd, ".codex", "skills"));
   const repoRoot = (() => {
     try {
       const output = execSync2("git rev-parse --show-toplevel", {
@@ -21464,15 +22355,15 @@ async function listCodexSkills(cwd) {
     }
   })();
   if (repoRoot) {
-    candidates.push(path8.join(path8.dirname(cwd), ".codex", "skills"));
-    candidates.push(path8.join(repoRoot, ".codex", "skills"));
+    candidates.push(path10.join(path10.dirname(cwd), ".codex", "skills"));
+    candidates.push(path10.join(repoRoot, ".codex", "skills"));
   }
-  candidates.push(path8.join(resolveCodexHomeDir(), "skills"));
+  candidates.push(path10.join(resolveCodexHomeDir(), "skills"));
   const commandsByName = /* @__PURE__ */ new Map();
   for (const dir of candidates) {
     let entries;
     try {
-      entries = await fs3.readdir(dir, { withFileTypes: true });
+      entries = await fs5.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -21480,11 +22371,11 @@ async function listCodexSkills(cwd) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) {
         continue;
       }
-      const skillDir = path8.join(dir, entry.name);
-      const skillPath = path8.join(skillDir, "SKILL.md");
+      const skillDir = path10.join(dir, entry.name);
+      const skillPath = path10.join(skillDir, "SKILL.md");
       let content;
       try {
-        content = await fs3.readFile(skillPath, "utf8");
+        content = await fs5.readFile(skillPath, "utf8");
       } catch {
         continue;
       }
@@ -21559,6 +22450,8 @@ function toCodexMcpConfig(config) {
         url: config.url,
         http_headers: config.headers
       };
+    case "sdk":
+      return null;
   }
 }
 var CodexAppServerClient = class {
@@ -22051,8 +22944,8 @@ function parseCodexPatchChanges(changes) {
       }
     ];
   }
-  return Object.entries(recordChanges).map(([path24, value]) => {
-    const normalizedPath = path24.trim();
+  return Object.entries(recordChanges).map(([path26, value]) => {
+    const normalizedPath = path26.trim();
     if (!normalizedPath) {
       return null;
     }
@@ -22790,13 +23683,13 @@ var CodexNotificationSchema = z25.union([
   )
 ]);
 async function writeImageAttachment(mimeType, data) {
-  const attachmentsDir = path8.join(os4.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-  await fs3.mkdir(attachmentsDir, { recursive: true });
+  const attachmentsDir = path10.join(os4.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
+  await fs5.mkdir(attachmentsDir, { recursive: true });
   const normalized = normalizeImageData(mimeType, data);
   const extension = getImageExtension(normalized.mimeType);
-  const filename = `${randomUUID2()}.${extension}`;
-  const filePath = path8.join(attachmentsDir, filename);
-  await fs3.writeFile(filePath, Buffer.from(normalized.data, "base64"));
+  const filename = `${randomUUID3()}.${extension}`;
+  const filePath = path10.join(attachmentsDir, filename);
+  await fs5.writeFile(filePath, Buffer.from(normalized.data, "base64"));
   return filePath;
 }
 async function readCodexConfiguredDefaults(client, logger) {
@@ -23076,7 +23969,7 @@ var CodexAppServerAgentSession = class {
     };
   }
   emitSyntheticPlanApprovalRequest(planText) {
-    const requestId = `permission-${randomUUID2()}`;
+    const requestId = `permission-${randomUUID3()}`;
     const request = {
       id: requestId,
       provider: CODEX_PROVIDER,
@@ -23233,8 +24126,8 @@ var CodexAppServerAgentSession = class {
     if (commandName.startsWith("prompts:")) {
       const promptName = commandName.slice("prompts:".length);
       const codexHome = resolveCodexHomeDir();
-      const promptPath = path8.join(codexHome, "prompts", `${promptName}.md`);
-      const raw = await fs3.readFile(promptPath, "utf8");
+      const promptPath = path10.join(codexHome, "prompts", `${promptName}.md`);
+      const raw = await fs5.readFile(promptPath, "utf8");
       const parsed = parseFrontMatter(raw);
       return expandCodexCustomPrompt(parsed.body, args);
     }
@@ -23701,7 +24594,8 @@ var CodexAppServerAgentSession = class {
     if (this.config.mcpServers) {
       const mcpServers = {};
       for (const [name, serverConfig] of Object.entries(this.config.mcpServers)) {
-        mcpServers[name] = toCodexMcpConfig(serverConfig);
+        const codexConfig = toCodexMcpConfig(serverConfig);
+        if (codexConfig) mcpServers[name] = codexConfig;
       }
       innerConfig.mcp_servers = mcpServers;
     }
@@ -24465,9 +25359,9 @@ var CodexAppServerAgentClient = class {
 };
 
 // ../server/src/server/agent/providers/acp-agent.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import fs4 from "node:fs/promises";
-import path9 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import fs6 from "node:fs/promises";
+import path11 from "node:path";
 import { Readable, Writable } from "node:stream";
 import {
   ClientSideConnection,
@@ -24764,12 +25658,12 @@ ${stderr}` : String(error)));
       async sessionUpdate() {
       },
       async readTextFile(params) {
-        const content = await fs4.readFile(params.path, "utf8");
+        const content = await fs6.readFile(params.path, "utf8");
         return { content };
       },
       async writeTextFile(params) {
-        await fs4.mkdir(path9.dirname(params.path), { recursive: true });
-        await fs4.writeFile(params.path, params.content, "utf8");
+        await fs6.mkdir(path11.dirname(params.path), { recursive: true });
+        await fs6.writeFile(params.path, params.content, "utf8");
         return {};
       },
       async createTerminal() {
@@ -24991,8 +25885,8 @@ var ACPAgentSession = class {
     if (this.activeForegroundTurnId) {
       throw new Error("A foreground turn is already active");
     }
-    const turnId = randomUUID3();
-    const messageId = randomUUID3();
+    const turnId = randomUUID4();
+    const messageId = randomUUID4();
     this.activeForegroundTurnId = turnId;
     this.suppressUserEchoMessageId = messageId;
     this.suppressUserEchoText = extractPromptText(prompt);
@@ -25293,7 +26187,7 @@ var ACPAgentSession = class {
         }
       } : { outcome: { outcome: "cancelled" } };
     }
-    const requestId = randomUUID3();
+    const requestId = randomUUID4();
     let toolSnapshot = this.toolCalls.get(params.toolCall.toolCallId) ?? mergeToolSnapshot(params.toolCall.toolCallId, params.toolCall);
     if (this.toolSnapshotTransformer) {
       toolSnapshot = this.toolSnapshotTransformer(toolSnapshot);
@@ -25334,7 +26228,7 @@ var ACPAgentSession = class {
     }
   }
   async readTextFile(params) {
-    const raw = await fs4.readFile(params.path, "utf8");
+    const raw = await fs6.readFile(params.path, "utf8");
     if (!params.line && !params.limit) {
       return { content: raw };
     }
@@ -25344,12 +26238,12 @@ var ACPAgentSession = class {
     return { content: lines.slice(start, end).join("\n") };
   }
   async writeTextFile(params) {
-    await fs4.mkdir(path9.dirname(params.path), { recursive: true });
-    await fs4.writeFile(params.path, params.content, "utf8");
+    await fs6.mkdir(path11.dirname(params.path), { recursive: true });
+    await fs6.writeFile(params.path, params.content, "utf8");
     return {};
   }
   async createTerminal(params) {
-    const terminalId = randomUUID3();
+    const terminalId = randomUUID4();
     const env = Object.fromEntries(
       (params.env ?? []).map((entry2) => [entry2.name, entry2.value])
     );
@@ -25747,9 +26641,10 @@ function normalizeMcpServers(servers) {
   if (!servers) {
     return [];
   }
-  return Object.entries(servers).map(([name, config]) => {
+  const out = [];
+  for (const [name, config] of Object.entries(servers)) {
     if (config.type === "stdio") {
-      return {
+      out.push({
         name,
         command: config.command,
         args: config.args ?? [],
@@ -25757,29 +26652,35 @@ function normalizeMcpServers(servers) {
           name: envName,
           value
         }))
-      };
+      });
+      continue;
     }
     if (config.type === "http") {
-      return {
+      out.push({
         type: "http",
         name,
         url: config.url,
         headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
           name: headerName,
-          value
+          value: String(value)
         }))
-      };
+      });
+      continue;
     }
-    return {
-      type: "sse",
-      name,
-      url: config.url,
-      headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
-        name: headerName,
-        value
-      }))
-    };
-  });
+    if (config.type === "sse") {
+      out.push({
+        type: "sse",
+        name,
+        url: config.url,
+        headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+          name: headerName,
+          value: String(value)
+        }))
+      });
+      continue;
+    }
+  }
+  return out;
 }
 function toACPContentBlocks(prompt) {
   if (typeof prompt === "string") {
@@ -26610,12 +27511,15 @@ function toOpenCodeMcpConfig(config) {
       enabled: true
     };
   }
-  return {
-    type: "remote",
-    url: config.url,
-    ...config.headers ? { headers: config.headers } : {},
-    enabled: true
-  };
+  if (config.type === "http" || config.type === "sse") {
+    return {
+      type: "remote",
+      url: config.url,
+      ...config.headers ? { headers: config.headers } : {},
+      enabled: true
+    };
+  }
+  return null;
 }
 function stringifyUnknownError(error) {
   if (typeof error === "string") {
@@ -27558,7 +28462,7 @@ function translateOpenCodeEvent(event, state) {
         break;
       }
       const metadata = readOpenCodeRecord(event.properties.metadata);
-      const tool = readOpenCodeRecord(event.properties.tool);
+      const tool2 = readOpenCodeRecord(event.properties.tool);
       const patterns = Array.isArray(event.properties.patterns) ? event.properties.patterns.filter((value) => typeof value === "string") : [];
       const command = readPermissionField(metadata, PERMISSION_COMMAND_KEYS);
       const cwd = readPermissionField(metadata, PERMISSION_CWD_KEYS);
@@ -27566,7 +28470,7 @@ function translateOpenCodeEvent(event, state) {
       const input = buildOpenCodePermissionInput({
         patterns,
         metadata,
-        tool,
+        tool: tool2,
         command
       });
       const detail = buildOpenCodePermissionDetail({
@@ -28314,6 +29218,7 @@ var OpenCodeAgentSession = class {
   async configureMcpServers(mcpServers) {
     for (const [name, serverConfig] of Object.entries(mcpServers)) {
       const mappedConfig = toOpenCodeMcpConfig(serverConfig);
+      if (!mappedConfig) continue;
       await this.registerMcpServer(name, mappedConfig);
     }
   }
@@ -28392,9 +29297,9 @@ var OpenCodeAgentSession = class {
 };
 
 // ../server/src/server/agent/providers/pi-direct-agent.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 import { homedir } from "node:os";
 import {
   AuthStorage,
@@ -29165,7 +30070,7 @@ var PiDirectAgentSession = class {
       throw new Error("A Pi turn is already active");
     }
     const payload = convertPromptInput(prompt);
-    const turnId = randomUUID4();
+    const turnId = randomUUID5();
     this.activeTurnId = turnId;
     void this.session.prompt(payload.text, payload.images ? { images: payload.images } : void 0).catch((error) => {
       const failedTurnId = this.activeTurnId ?? turnId;
@@ -29400,7 +30305,7 @@ var PiDirectAgentClient = class {
     } else if (!await isCommandAvailable(PI_BINARY_COMMAND)) {
       return false;
     }
-    return Boolean(process.env.OPENAI_API_KEY) || Boolean(process.env.ANTHROPIC_API_KEY) || Boolean(process.env.OPENROUTER_API_KEY) || existsSync9(join7(homedir(), ".pi", "agent", "auth.json"));
+    return Boolean(process.env.OPENAI_API_KEY) || Boolean(process.env.ANTHROPIC_API_KEY) || Boolean(process.env.OPENROUTER_API_KEY) || existsSync9(join9(homedir(), ".pi", "agent", "auth.json"));
   }
   async getDiagnostic() {
     try {
@@ -29408,7 +30313,7 @@ var PiDirectAgentClient = class {
       const binaryOverride = this.runtimeSettings?.command;
       const binary = binaryOverride?.mode === "replace" && binaryOverride.argv[0] ? binaryOverride.argv[0] : await findExecutable(PI_BINARY_COMMAND);
       const version = binary ? await resolveBinaryVersion(binary) : "unknown";
-      const authConfigPath = join7(homedir(), ".pi", "agent", "auth.json");
+      const authConfigPath = join9(homedir(), ".pi", "agent", "auth.json");
       let modelsValue = "Not checked";
       let status = formatDiagnosticStatus(available);
       if (available) {
@@ -29801,8 +30706,8 @@ function buildZodValidator(schema, schemaName) {
         return { ok: true, value: result.data };
       }
       const errors = result.error.issues.map((issue) => {
-        const path24 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `${path24}: ${issue.message}`;
+        const path26 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path26}: ${issue.message}`;
       });
       return { ok: false, errors };
     }
@@ -29820,9 +30725,9 @@ function buildJsonSchemaValidator(schema) {
         return { ok: true, value };
       }
       const errors = (validate.errors ?? []).map((error) => {
-        const path24 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
+        const path26 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
         const message = error.message ?? "is invalid";
-        return `${path24}: ${message}`;
+        return `${path26}: ${message}`;
       });
       return { ok: false, errors };
     }
@@ -30707,8 +31612,8 @@ function isVoicePermissionAllowed(request) {
 }
 
 // ../server/src/server/file-explorer/service.ts
-import { promises as fs5 } from "fs";
-import path10 from "path";
+import { promises as fs7 } from "fs";
+import path12 from "path";
 
 // ../server/src/server/path-utils.ts
 import { homedir as homedir2 } from "node:os";
@@ -30755,14 +31660,14 @@ async function listDirectoryEntries({
   relativePath = "."
 }) {
   const directoryPath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs5.stat(directoryPath);
+  const stats = await fs7.stat(directoryPath);
   if (!stats.isDirectory()) {
     throw new Error("Requested path is not a directory");
   }
-  const dirents = await fs5.readdir(directoryPath, { withFileTypes: true });
+  const dirents = await fs7.readdir(directoryPath, { withFileTypes: true });
   const entriesWithNulls = await Promise.all(
     dirents.map(async (dirent) => {
-      const targetPath = path10.join(directoryPath, dirent.name);
+      const targetPath = path12.join(directoryPath, dirent.name);
       const kind = dirent.isDirectory() ? "directory" : "file";
       try {
         return await buildEntryPayload({
@@ -30797,18 +31702,18 @@ async function readExplorerFile({
   relativePath
 }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs5.stat(filePath);
+  const stats = await fs7.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path10.extname(filePath).toLowerCase();
+  const ext = path12.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 fs5.readFile(filePath);
+    const buffer2 = await fs7.readFile(filePath);
     return {
       ...basePayload,
       kind: "image",
@@ -30817,7 +31722,7 @@ async function readExplorerFile({
       mimeType: IMAGE_MIME_TYPES[ext]
     };
   }
-  const buffer = await fs5.readFile(filePath);
+  const buffer = await fs7.readFile(filePath);
   if (isLikelyBinary(buffer)) {
     return {
       ...basePayload,
@@ -30839,34 +31744,34 @@ async function writeTextFile({
   relativePath,
   content
 }) {
-  const ext = path10.extname(relativePath).toLowerCase();
+  const ext = path12.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 fs5.writeFile(tempPath, content, "utf8");
-  await fs5.rename(tempPath, filePath);
+  await fs7.writeFile(tempPath, content, "utf8");
+  await fs7.rename(tempPath, filePath);
 }
 async function deleteFile({ root, relativePath }) {
-  const ext = path10.extname(relativePath).toLowerCase();
+  const ext = path12.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 fs5.stat(filePath);
+  const stats = await fs7.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  await fs5.unlink(filePath);
+  await fs7.unlink(filePath);
 }
 async function deleteEntry({ root, relativePath }) {
   const entryPath = await resolveScopedPath({ root, relativePath });
-  await fs5.rm(entryPath, { recursive: true, force: false });
+  await fs7.rm(entryPath, { recursive: true, force: false });
 }
 async function createDirectory({ root, relativePath }) {
   const dirPath = await resolveScopedPath({ root, relativePath });
-  await fs5.mkdir(dirPath, { recursive: true });
+  await fs7.mkdir(dirPath, { recursive: true });
 }
 async function moveEntry({
   root,
@@ -30875,22 +31780,22 @@ async function moveEntry({
 }) {
   const src = await resolveScopedPath({ root, relativePath: sourcePath });
   const dest = await resolveScopedPath({ root, relativePath: destinationPath });
-  await fs5.rename(src, dest);
+  await fs7.rename(src, dest);
 }
 async function getDownloadableFileInfo({ root, relativePath }) {
   const filePath = await resolveScopedPath({ root, relativePath });
-  const stats = await fs5.stat(filePath);
+  const stats = await fs7.stat(filePath);
   if (!stats.isFile()) {
     throw new Error("Requested path is not a file");
   }
-  const ext = path10.extname(filePath).toLowerCase();
+  const ext = path12.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 fs5.open(filePath, "r");
+    const handle = await fs7.open(filePath, "r");
     const sample = Buffer.alloc(8192);
     try {
       const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
@@ -30905,23 +31810,23 @@ async function getDownloadableFileInfo({ root, relativePath }) {
   return {
     path: normalizeRelativePath({ root, targetPath: filePath }),
     absolutePath: filePath,
-    fileName: path10.basename(filePath),
+    fileName: path12.basename(filePath),
     mimeType,
     size: stats.size
   };
 }
 async function resolveScopedPath({ root, relativePath = "." }) {
-  const normalizedRoot = path10.resolve(root);
+  const normalizedRoot = path12.resolve(root);
   const requestedPath = resolvePathFromBase(normalizedRoot, relativePath);
-  const relative = path10.relative(normalizedRoot, requestedPath);
-  if (relative !== "" && (relative.startsWith("..") || path10.isAbsolute(relative))) {
+  const relative = path12.relative(normalizedRoot, requestedPath);
+  if (relative !== "" && (relative.startsWith("..") || path12.isAbsolute(relative))) {
     throw new Error("Access outside of workspace is not allowed");
   }
-  const realRoot = await fs5.realpath(normalizedRoot);
+  const realRoot = await fs7.realpath(normalizedRoot);
   try {
-    const realPath = await fs5.realpath(requestedPath);
-    const realRelative = path10.relative(realRoot, realPath);
-    if (realRelative !== "" && (realRelative.startsWith("..") || path10.isAbsolute(realRelative))) {
+    const realPath = await fs7.realpath(requestedPath);
+    const realRelative = path12.relative(realRoot, realPath);
+    if (realRelative !== "" && (realRelative.startsWith("..") || path12.isAbsolute(realRelative))) {
       throw new Error("Access outside of workspace is not allowed");
     }
     return requestedPath;
@@ -30938,7 +31843,7 @@ async function buildEntryPayload({
   name,
   kind
 }) {
-  const stats = await fs5.stat(targetPath);
+  const stats = await fs7.stat(targetPath);
   return {
     name,
     path: normalizeRelativePath({ root, targetPath }),
@@ -30952,10 +31857,10 @@ function isMissingEntryError(error) {
   return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
 }
 function normalizeRelativePath({ root, targetPath }) {
-  const normalizedRoot = path10.resolve(root);
-  const normalizedTarget = path10.resolve(targetPath);
-  const relative = path10.relative(normalizedRoot, normalizedTarget);
-  return relative === "" ? "." : relative.split(path10.sep).join("/");
+  const normalizedRoot = path12.resolve(root);
+  const normalizedTarget = path12.resolve(targetPath);
+  const relative = path12.relative(normalizedRoot, normalizedTarget);
+  return relative === "" ? "." : relative.split(path12.sep).join("/");
 }
 function textMimeTypeForExtension(ext) {
   return TEXT_MIME_TYPES[ext] ?? DEFAULT_TEXT_MIME_TYPE;
@@ -30982,7 +31887,7 @@ function isLikelyBinary(buffer) {
 
 // ../server/src/utils/project-icon.ts
 import { readdir, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { extname as extname2, join as join8 } from "path";
+import { extname as extname3, join as join10 } from "path";
 var ICON_PATTERNS = [
   "favicon.ico",
   "favicon.png",
@@ -31096,7 +32001,7 @@ function isSquareImage(buffer, mimeType) {
   return dimensions.width === dimensions.height;
 }
 function getMimeType(filename) {
-  const ext = extname2(filename).toLowerCase();
+  const ext = extname3(filename).toLowerCase();
   switch (ext) {
     case ".ico":
       return "image/x-icon";
@@ -31132,7 +32037,7 @@ async function findIconInDir(dir, patterns) {
   for (const pattern of patterns) {
     for (const entry of entries) {
       if (matchesPattern(entry, pattern)) {
-        const fullPath = join8(dir, entry);
+        const fullPath = join10(dir, entry);
         try {
           const stats = await stat2(fullPath);
           if (stats.isFile()) {
@@ -31163,7 +32068,7 @@ async function searchDirRecursively(dir, patterns, ignoredDirs, maxDepth, curren
     if (ignoredDirs.has(entry)) {
       continue;
     }
-    const fullPath = join8(dir, entry);
+    const fullPath = join10(dir, entry);
     try {
       const stats = await stat2(fullPath);
       if (stats.isDirectory()) {
@@ -31186,7 +32091,7 @@ async function searchDirRecursively(dir, patterns, ignoredDirs, maxDepth, curren
 async function findProjectIcon(projectDir, maxDepth = 3) {
   const ignoredDirsSet = new Set(IGNORED_DIRS);
   for (const priorityDir of PRIORITY_DIRS) {
-    const priorityPath = join8(projectDir, priorityDir);
+    const priorityPath = join10(projectDir, priorityDir);
     try {
       const stats = await stat2(priorityPath);
       if (stats.isDirectory()) {
@@ -31204,7 +32109,7 @@ async function findProjectIcon(projectDir, maxDepth = 3) {
     }
   }
   for (const monoDir of MONOREPO_PACKAGE_DIRS) {
-    const monoPath = join8(projectDir, monoDir);
+    const monoPath = join10(projectDir, monoDir);
     let packageEntries;
     try {
       packageEntries = await readdir(monoPath);
@@ -31212,7 +32117,7 @@ async function findProjectIcon(projectDir, maxDepth = 3) {
       continue;
     }
     for (const packageName of packageEntries) {
-      const packagePath = join8(monoPath, packageName);
+      const packagePath = join10(monoPath, packageName);
       try {
         const packageStats = await stat2(packagePath);
         if (!packageStats.isDirectory()) continue;
@@ -31220,7 +32125,7 @@ async function findProjectIcon(projectDir, maxDepth = 3) {
         continue;
       }
       for (const priorityDir of PRIORITY_DIRS) {
-        const priorityPath = join8(packagePath, priorityDir);
+        const priorityPath = join10(packagePath, priorityDir);
         try {
           const priorityStats = await stat2(priorityPath);
           if (priorityStats.isDirectory()) {
@@ -31270,7 +32175,7 @@ async function findDirRecursively(dir, maxDepth = 2, currentDepth = 0) {
       if (ignoredDirsSet.has(entry) || priorityDirsSet.has(entry)) {
         continue;
       }
-      const fullPath = join8(dir, entry);
+      const fullPath = join10(dir, entry);
       try {
         const stats = await stat2(fullPath);
         if (stats.isDirectory()) {
@@ -31309,64 +32214,64 @@ async function getProjectIcon(projectDir) {
 
 // ../server/src/utils/path.ts
 import os5 from "os";
-function expandTilde(path24) {
-  if (path24.startsWith("~/")) {
+function expandTilde(path26) {
+  if (path26.startsWith("~/")) {
     const homeDir3 = process.env.HOME || os5.homedir();
-    return path24.replace("~", homeDir3);
+    return path26.replace("~", homeDir3);
   }
-  if (path24 === "~") {
+  if (path26 === "~") {
     return process.env.HOME || os5.homedir();
   }
-  return path24;
+  return path26;
 }
 
 // ../server/src/server/skills/scanner.ts
-import fs6 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import os6 from "node:os";
-import path11 from "node:path";
+import path13 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 || path11.join(homeDir(), ".codex");
+  return process.env.CODEX_HOME || path13.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 path11.join(codexHomeDir(), "prompts");
+    return path13.join(codexHomeDir(), "prompts");
   }
   if (scope === "project") {
     if (!workspaceRoot) {
       throw new Error(`workspaceRoot is required for scope "project"`);
     }
     const dotDir = provider === "claude" ? ".claude" : ".codex";
-    return path11.join(workspaceRoot, dotDir, "skills");
+    return path13.join(workspaceRoot, dotDir, "skills");
   }
   if (provider === "claude") {
-    return path11.join(homeDir(), ".claude", "skills");
+    return path13.join(homeDir(), ".claude", "skills");
   }
-  return path11.join(codexHomeDir(), "skills");
+  return path13.join(codexHomeDir(), "skills");
 }
 function allowedRoots(workspaceRoot) {
   const roots = [
-    path11.join(homeDir(), ".claude", "skills"),
-    path11.join(codexHomeDir(), "skills"),
-    path11.join(codexHomeDir(), "prompts")
+    path13.join(homeDir(), ".claude", "skills"),
+    path13.join(codexHomeDir(), "skills"),
+    path13.join(codexHomeDir(), "prompts")
   ];
   if (workspaceRoot) {
-    roots.push(path11.join(workspaceRoot, ".claude", "skills"));
-    roots.push(path11.join(workspaceRoot, ".codex", "skills"));
+    roots.push(path13.join(workspaceRoot, ".claude", "skills"));
+    roots.push(path13.join(workspaceRoot, ".codex", "skills"));
   }
-  return roots.map((r) => path11.resolve(r));
+  return roots.map((r) => path13.resolve(r));
 }
 function isInsideAllowedRoot(absPath, workspaceRoot) {
-  const resolved = path11.resolve(absPath);
+  const resolved = path13.resolve(absPath);
   for (const root of allowedRoots(workspaceRoot)) {
-    const rel = path11.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path11.isAbsolute(rel)) {
+    const rel = path13.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel)) {
       return true;
     }
   }
@@ -31486,7 +32391,7 @@ async function listSkills(args) {
   const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
   let entries;
   try {
-    entries = await fs6.readdir(dir, { withFileTypes: true });
+    entries = await fs8.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -31497,7 +32402,7 @@ async function listSkills(args) {
       if (!entry.name.endsWith(".md")) continue;
       const name = entry.name.slice(0, -".md".length);
       if (!name) continue;
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       const stat5 = await safeStat(fullPath);
       if (!stat5) continue;
       const description = await readDescriptionSafely(fullPath);
@@ -31515,8 +32420,8 @@ async function listSkills(args) {
   } else {
     for (const entry of entries) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-      const skillDir = path11.join(dir, entry.name);
-      const skillPath = path11.join(skillDir, "SKILL.md");
+      const skillDir = path13.join(dir, entry.name);
+      const skillPath = path13.join(skillDir, "SKILL.md");
       const stat5 = await safeStat(skillPath);
       if (!stat5) continue;
       const description = await readDescriptionSafely(skillPath);
@@ -31537,7 +32442,7 @@ async function listSkills(args) {
 }
 async function safeStat(filePath) {
   try {
-    const s = await fs6.stat(filePath);
+    const s = await fs8.stat(filePath);
     return { mtime: s.mtime, size: s.size };
   } catch {
     return null;
@@ -31545,7 +32450,7 @@ async function safeStat(filePath) {
 }
 async function readDescriptionSafely(filePath) {
   try {
-    const text = await fs6.readFile(filePath, "utf8");
+    const text = await fs8.readFile(filePath, "utf8");
     return readDescription(text);
   } catch {
     return "";
@@ -31561,11 +32466,11 @@ async function createSkill(args) {
     throw new Error(`Skill name must not contain path separators or "..".`);
   }
   const dir = resolveScopeDir(args.provider, args.scope, args.workspaceRoot);
-  await fs6.mkdir(dir, { recursive: true });
+  await fs8.mkdir(dir, { recursive: true });
   if (args.scope === "codex-prompts") {
-    const filePath2 = path11.join(dir, `${args.name}.md`);
+    const filePath2 = path13.join(dir, `${args.name}.md`);
     try {
-      await fs6.access(filePath2);
+      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") {
@@ -31576,13 +32481,13 @@ async function createSkill(args) {
       }
     }
     const initial2 = buildStarterPrompt(args.name);
-    await fs6.writeFile(filePath2, initial2, "utf8");
+    await fs8.writeFile(filePath2, initial2, "utf8");
     return { path: filePath2 };
   }
-  const skillDir = path11.join(dir, args.name);
+  const skillDir = path13.join(dir, args.name);
   let dirExists = false;
   try {
-    const stat5 = await fs6.stat(skillDir);
+    const stat5 = await fs8.stat(skillDir);
     dirExists = stat5.isDirectory();
   } catch {
     dirExists = false;
@@ -31590,10 +32495,10 @@ async function createSkill(args) {
   if (dirExists) {
     throw new Error(`A skill named "${args.name}" already exists at ${skillDir}`);
   }
-  await fs6.mkdir(skillDir, { recursive: true });
-  const filePath = path11.join(skillDir, "SKILL.md");
+  await fs8.mkdir(skillDir, { recursive: true });
+  const filePath = path13.join(skillDir, "SKILL.md");
   const initial = buildStarterSkill(args.name);
-  await fs6.writeFile(filePath, initial, "utf8");
+  await fs8.writeFile(filePath, initial, "utf8");
   return { path: filePath };
 }
 function buildStarterSkill(name) {
@@ -31620,7 +32525,7 @@ Body of the prompt. Use \`$1\`, \`$2\`, ... or \`$ARGUMENTS\` for parameter expa
 `;
 }
 async function writeSkillFrontmatter(args, workspaceRoot) {
-  if (!path11.isAbsolute(args.path)) {
+  if (!path13.isAbsolute(args.path)) {
     throw new Error(`writeSkillFrontmatter expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot(args.path, workspaceRoot)) {
@@ -31628,7 +32533,7 @@ async function writeSkillFrontmatter(args, workspaceRoot) {
   }
   let original;
   try {
-    original = await fs6.readFile(args.path, "utf8");
+    original = await fs8.readFile(args.path, "utf8");
   } catch (err) {
     throw new Error(
       `Failed to read skill file: ${err instanceof Error ? err.message : String(err)}`
@@ -31641,12 +32546,12 @@ async function writeSkillFrontmatter(args, workspaceRoot) {
 ${parsed.body}` : `${nextFrontmatter}
 
 ${original}`;
-  await fs6.writeFile(args.path, nextContent, "utf8");
+  await fs8.writeFile(args.path, nextContent, "utf8");
 }
 
 // ../server/src/utils/directory-suggestions.ts
 import { readdir as readdir2, realpath, stat as stat3 } from "node:fs/promises";
-import path12 from "node:path";
+import path14 from "node:path";
 var DEFAULT_LIMIT = 30;
 var MAX_LIMIT = 100;
 var DEFAULT_MAX_DEPTH = 6;
@@ -31732,7 +32637,7 @@ function normalizeLimit(limit) {
   return Math.max(1, Math.min(MAX_LIMIT, bounded));
 }
 async function searchWithinParentDirectory(input) {
-  const parentPath = path12.resolve(input.homeRoot, input.parentPart || ".");
+  const parentPath = path14.resolve(input.homeRoot, input.parentPart || ".");
   const parentRoot = await resolveDirectory(parentPath);
   if (!parentRoot || !isPathInsideRoot(input.homeRoot, parentRoot)) {
     return [];
@@ -31797,7 +32702,7 @@ async function searchAcrossHomeTree(input) {
   return dedupeAndSort(ranked).slice(0, input.limit);
 }
 async function searchWorkspaceWithinParentDirectory(input) {
-  const parentPath = path12.resolve(input.workspaceRoot, input.parentPart || ".");
+  const parentPath = path14.resolve(input.workspaceRoot, input.parentPart || ".");
   const parentRoot = await resolveDirectory(parentPath);
   if (!parentRoot || !isPathInsideRoot(input.workspaceRoot, parentRoot)) {
     return [];
@@ -32043,15 +32948,15 @@ function findSegmentMatchIndex(segments, predicate) {
   return -1;
 }
 function normalizeRelativePath2(homeRoot, absolutePath) {
-  const relative = path12.relative(homeRoot, absolutePath);
+  const relative = path14.relative(homeRoot, absolutePath);
   if (!relative) {
     return ".";
   }
-  return relative.split(path12.sep).join("/");
+  return relative.split(path14.sep).join("/");
 }
 function isPathInsideRoot(root, target) {
-  const relative = path12.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative);
+  const relative = path14.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path14.isAbsolute(relative);
 }
 function normalizeQueryParts(query2, homeRoot) {
   const typedQuery = query2.trim().replace(/\\/g, "/");
@@ -32067,9 +32972,9 @@ function normalizeQueryParts(query2, homeRoot) {
       normalized = normalized.slice(1);
     }
   }
-  if (path12.isAbsolute(normalized)) {
+  if (path14.isAbsolute(normalized)) {
     isRooted = true;
-    const absolute = path12.resolve(normalized);
+    const absolute = path14.resolve(normalized);
     if (!isPathInsideRoot(homeRoot, absolute)) {
       return null;
     }
@@ -32108,8 +33013,8 @@ function normalizeQueryParts(query2, homeRoot) {
 }
 function normalizeWorkspaceQueryParts(query2, workspaceRoot) {
   let normalized = query2.trim().replace(/\\/g, "/");
-  if (path12.isAbsolute(normalized)) {
-    const absolute = path12.resolve(normalized);
+  if (path14.isAbsolute(normalized)) {
+    const absolute = path14.resolve(normalized);
     if (!isPathInsideRoot(workspaceRoot, absolute)) {
       return null;
     }
@@ -32135,7 +33040,7 @@ function normalizeWorkspaceQueryParts(query2, workspaceRoot) {
 }
 async function resolveDirectory(inputPath) {
   try {
-    const resolved = await realpath(path12.resolve(inputPath));
+    const resolved = await realpath(path14.resolve(inputPath));
     const stats = await stat3(resolved);
     if (!stats.isDirectory()) {
       return null;
@@ -32162,7 +33067,7 @@ async function listChildDirectories(input) {
     if (!dirent.isDirectory() && !dirent.isSymbolicLink()) {
       continue;
     }
-    const candidatePath = path12.join(input.directory, dirent.name);
+    const candidatePath = path14.join(input.directory, dirent.name);
     const absolutePath = await resolveDirectoryCandidate({
       candidatePath,
       dirent,
@@ -32199,7 +33104,7 @@ async function listWorkspaceChildEntries(input) {
     if (isIgnoredWorkspaceDirectoryName(dirent.name)) {
       continue;
     }
-    const candidatePath = path12.join(input.directory, dirent.name);
+    const candidatePath = path14.join(input.directory, dirent.name);
     const entry = await resolveWorkspaceCandidate({
       candidatePath,
       dirent,
@@ -32222,7 +33127,7 @@ async function listWorkspaceChildEntries(input) {
 }
 async function resolveDirectoryCandidate(input) {
   if (input.dirent.isDirectory()) {
-    const resolved2 = path12.resolve(input.candidatePath);
+    const resolved2 = path14.resolve(input.candidatePath);
     return isPathInsideRoot(input.homeRoot, resolved2) ? resolved2 : null;
   }
   const resolved = await resolveDirectory(input.candidatePath);
@@ -32233,14 +33138,14 @@ async function resolveDirectoryCandidate(input) {
 }
 async function resolveWorkspaceCandidate(input) {
   if (input.dirent.isDirectory()) {
-    const resolved = path12.resolve(input.candidatePath);
+    const resolved = path14.resolve(input.candidatePath);
     if (!isPathInsideRoot(input.workspaceRoot, resolved)) {
       return null;
     }
     return { absolutePath: resolved, kind: "directory" };
   }
   if (input.dirent.isFile()) {
-    const resolved = path12.resolve(input.candidatePath);
+    const resolved = path14.resolve(input.candidatePath);
     if (!isPathInsideRoot(input.workspaceRoot, resolved)) {
       return null;
     }
@@ -32320,7 +33225,7 @@ function pruneWorkspaceEntryListCache() {
 // ../server/src/utils/directory-listing.ts
 import { readdir as readdir3, stat as stat4, realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path13 from "node:path";
+import path15 from "node:path";
 var DEFAULT_LIMIT2 = 500;
 async function listDirectoryContents(options) {
   const includeFiles = options.includeFiles ?? false;
@@ -32331,7 +33236,7 @@ async function listDirectoryContents(options) {
   const collected = [];
   for (const dirent of dirents) {
     if (!includeHidden && dirent.name.startsWith(".")) continue;
-    const childPath = path13.join(resolvedPath, dirent.name);
+    const childPath = path15.join(resolvedPath, dirent.name);
     const kind = await classifyEntry(dirent, childPath);
     if (!kind) continue;
     if (kind === "file" && !includeFiles) continue;
@@ -32339,7 +33244,7 @@ async function listDirectoryContents(options) {
     if (collected.length >= limit) break;
   }
   collected.sort(compareEntries);
-  const parent = path13.dirname(resolvedPath);
+  const parent = path15.dirname(resolvedPath);
   return {
     path: resolvedPath,
     parent: parent === resolvedPath ? null : parent,
@@ -32350,12 +33255,12 @@ async function resolveAbsolutePath(rawPath) {
   const home = process.env.HOME ?? homedir3();
   const trimmed = rawPath.trim();
   if (trimmed === "" || trimmed === "~") {
-    return path13.resolve(home);
+    return path15.resolve(home);
   }
   if (trimmed.startsWith("~/")) {
-    return path13.resolve(home, trimmed.slice(2));
+    return path15.resolve(home, trimmed.slice(2));
   }
-  if (!path13.isAbsolute(trimmed)) {
+  if (!path15.isAbsolute(trimmed)) {
     throw new Error(
       `list_directory requires an absolute path, an empty string, or a "~"-prefixed path; got ${JSON.stringify(rawPath)}`
     );
@@ -32363,7 +33268,7 @@ async function resolveAbsolutePath(rawPath) {
   try {
     return await realpath2(trimmed);
   } catch {
-    return path13.resolve(trimmed);
+    return path15.resolve(trimmed);
   }
 }
 async function classifyEntry(dirent, fullPath) {
@@ -32496,9 +33401,9 @@ function buildChatMentionNotification(input) {
 }
 
 // ../server/src/server/roles/scanner.ts
-import fs7 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import os7 from "node:os";
-import path14 from "node:path";
+import path16 from "node:path";
 var NAME_REGEX2 = /^[a-z0-9][a-z0-9._-]*$/i;
 function homeDir2() {
   return process.env.HOME || os7.homedir();
@@ -32508,22 +33413,22 @@ function resolveScopeDir2(scope, workspaceRoot) {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path14.join(workspaceRoot, ".roles");
+    return path16.join(workspaceRoot, ".roles");
   }
-  return path14.join(homeDir2(), ".appostle", ".roles");
+  return path16.join(homeDir2(), ".appostle", ".roles");
 }
 function allowedRoots2(workspaceRoot) {
-  const roots = [path14.join(homeDir2(), ".appostle", ".roles")];
+  const roots = [path16.join(homeDir2(), ".appostle", ".roles")];
   if (workspaceRoot) {
-    roots.push(path14.join(workspaceRoot, ".roles"));
+    roots.push(path16.join(workspaceRoot, ".roles"));
   }
-  return roots.map((r) => path14.resolve(r));
+  return roots.map((r) => path16.resolve(r));
 }
 function isInsideAllowedRoot2(absPath, workspaceRoot) {
-  const resolved = path14.resolve(absPath);
+  const resolved = path16.resolve(absPath);
   for (const root of allowedRoots2(workspaceRoot)) {
-    const rel = path14.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel)) {
+    const rel = path16.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel)) {
       return true;
     }
   }
@@ -32711,7 +33616,7 @@ function rewriteFrontmatter2(originalLines, next) {
 async function readRolesFromDir(scope, dir, category) {
   let entries;
   try {
-    entries = await fs7.readdir(dir, { withFileTypes: true });
+    entries = await fs9.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -32721,17 +33626,17 @@ async function readRolesFromDir(scope, dir, category) {
     if (!entry.name.endsWith(".md")) continue;
     const name = entry.name.slice(0, -".md".length);
     if (!name || !NAME_REGEX2.test(name)) continue;
-    const fullPath = path14.join(dir, entry.name);
+    const fullPath = path16.join(dir, entry.name);
     let stat5;
     try {
-      const s = await fs7.stat(fullPath);
+      const s = await fs9.stat(fullPath);
       stat5 = { mtime: s.mtime, size: s.size };
     } catch {
       continue;
     }
     let parsed;
     try {
-      const text = await fs7.readFile(fullPath, "utf8");
+      const text = await fs9.readFile(fullPath, "utf8");
       parsed = parseFrontmatter(text);
     } catch {
       parsed = {
@@ -32765,13 +33670,13 @@ async function readRolesFromDir(scope, dir, category) {
 async function readRolesFromScopeDir(scope, scopeDir) {
   let topEntries;
   try {
-    topEntries = await fs7.readdir(scopeDir, { withFileTypes: true });
+    topEntries = await fs9.readdir(scopeDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const flat = await readRolesFromDir(scope, scopeDir, null);
   const categoryResults = await Promise.all(
-    topEntries.filter((e) => e.isDirectory() && NAME_REGEX2.test(e.name)).map((e) => readRolesFromDir(scope, path14.join(scopeDir, e.name), e.name))
+    topEntries.filter((e) => e.isDirectory() && NAME_REGEX2.test(e.name)).map((e) => readRolesFromDir(scope, path16.join(scopeDir, e.name), e.name))
   );
   const all = [...flat, ...categoryResults.flat()];
   all.sort((a, b) => {
@@ -32811,11 +33716,11 @@ async function createRole(args) {
     throw new Error(`Role name must not contain path separators or "..".`);
   }
   const scopeDir = resolveScopeDir2(args.scope, args.workspaceRoot);
-  const dir = args.category ? path14.join(scopeDir, args.category) : scopeDir;
-  await fs7.mkdir(dir, { recursive: true });
-  const filePath = path14.join(dir, `${args.name}.md`);
+  const dir = args.category ? path16.join(scopeDir, args.category) : scopeDir;
+  await fs9.mkdir(dir, { recursive: true });
+  const filePath = path16.join(dir, `${args.name}.md`);
   try {
-    await fs7.access(filePath);
+    await fs9.access(filePath);
     throw new Error(`A role named "${args.name}" already exists at ${filePath}`);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
@@ -32826,7 +33731,7 @@ async function createRole(args) {
     }
   }
   const initial = buildStarterRole(args.name);
-  await fs7.writeFile(filePath, initial, "utf8");
+  await fs9.writeFile(filePath, initial, "utf8");
   return { path: filePath };
 }
 function buildStarterRole(name) {
@@ -32847,7 +33752,7 @@ the role is invoked.
 `;
 }
 async function writeRoleFrontmatter(args, workspaceRoot) {
-  if (!path14.isAbsolute(args.path)) {
+  if (!path16.isAbsolute(args.path)) {
     throw new Error(`writeRoleFrontmatter expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
@@ -32855,7 +33760,7 @@ async function writeRoleFrontmatter(args, workspaceRoot) {
   }
   let original;
   try {
-    original = await fs7.readFile(args.path, "utf8");
+    original = await fs9.readFile(args.path, "utf8");
   } catch (err) {
     throw new Error(
       `Failed to read role file: ${err instanceof Error ? err.message : String(err)}`
@@ -32868,23 +33773,23 @@ async function writeRoleFrontmatter(args, workspaceRoot) {
 ${parsed.body}` : `${nextFrontmatter}
 
 ${original}`;
-  await fs7.writeFile(args.path, nextContent, "utf8");
+  await fs9.writeFile(args.path, nextContent, "utf8");
 }
 async function moveRole(args, workspaceRoot) {
-  if (!path14.isAbsolute(args.path)) {
+  if (!path16.isAbsolute(args.path)) {
     throw new Error(`moveRole expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot2(args.path, workspaceRoot)) {
     throw new Error(`Path "${args.path}" is not inside an allowlisted role root`);
   }
-  const oldDir = path14.dirname(args.path);
-  const oldFilename = path14.basename(args.path, ".md");
+  const oldDir = path16.dirname(args.path);
+  const oldFilename = path16.basename(args.path, ".md");
   const roots = allowedRoots2(workspaceRoot);
-  const rolesRoot = roots.find((r) => path14.resolve(args.path).startsWith(r));
+  const rolesRoot = roots.find((r) => path16.resolve(args.path).startsWith(r));
   if (!rolesRoot) {
     throw new Error(`Cannot determine roles root for "${args.path}"`);
   }
-  const relFromRoot = path14.relative(rolesRoot, path14.dirname(args.path));
+  const relFromRoot = path16.relative(rolesRoot, path16.dirname(args.path));
   const currentCategory = relFromRoot && relFromRoot !== "." ? relFromRoot : "";
   const newName = args.newName ?? oldFilename;
   const newCategory = args.newCategory !== void 0 ? args.newCategory : currentCategory;
@@ -32894,19 +33799,19 @@ async function moveRole(args, workspaceRoot) {
   if (newCategory && !NAME_REGEX2.test(newCategory)) {
     throw new Error(`Invalid category name: "${newCategory}"`);
   }
-  const newDir = newCategory ? path14.join(rolesRoot, newCategory) : rolesRoot;
-  const newPath = path14.join(newDir, `${newName}.md`);
-  if (path14.resolve(newPath) === path14.resolve(args.path)) {
+  const newDir = newCategory ? path16.join(rolesRoot, newCategory) : rolesRoot;
+  const newPath = path16.join(newDir, `${newName}.md`);
+  if (path16.resolve(newPath) === path16.resolve(args.path)) {
     return { path: args.path };
   }
-  await fs7.mkdir(newDir, { recursive: true });
+  await fs9.mkdir(newDir, { recursive: true });
   try {
-    await fs7.access(newPath);
+    await fs9.access(newPath);
     throw new Error(`A role already exists at "${newPath}"`);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  await fs7.rename(args.path, newPath);
+  await fs9.rename(args.path, newPath);
   const frontmatterPatch = {};
   if (newName !== oldFilename) {
     frontmatterPatch.description = void 0;
@@ -32922,9 +33827,9 @@ async function moveRole(args, workspaceRoot) {
   );
   if (oldDir !== rolesRoot) {
     try {
-      const remaining = await fs7.readdir(oldDir);
+      const remaining = await fs9.readdir(oldDir);
       if (remaining.length === 0) {
-        await fs7.rmdir(oldDir);
+        await fs9.rmdir(oldDir);
       }
     } catch {
     }
@@ -32933,30 +33838,30 @@ async function moveRole(args, workspaceRoot) {
 }
 
 // ../server/src/server/brands/scanner.ts
-import fs8 from "node:fs/promises";
-import path15 from "node:path";
+import fs10 from "node:fs/promises";
+import path17 from "node:path";
 var NAME_REGEX3 = /^[a-z0-9][a-z0-9._-]*$/i;
 function resolveScopeDir3(scope, workspaceRoot) {
   if (scope === "project") {
     if (!workspaceRoot) {
       throw new Error('workspaceRoot is required for scope "project"');
     }
-    return path15.join(workspaceRoot, ".brand");
+    return path17.join(workspaceRoot, ".brand");
   }
   throw new Error(`Unknown scope: ${scope}`);
 }
 function allowedRoots3(workspaceRoot) {
   const roots = [];
   if (workspaceRoot) {
-    roots.push(path15.join(workspaceRoot, ".brand"));
+    roots.push(path17.join(workspaceRoot, ".brand"));
   }
-  return roots.map((r) => path15.resolve(r));
+  return roots.map((r) => path17.resolve(r));
 }
 function isInsideAllowedRoot3(absPath, workspaceRoot) {
-  const resolved = path15.resolve(absPath);
+  const resolved = path17.resolve(absPath);
   for (const root of allowedRoots3(workspaceRoot)) {
-    const rel = path15.relative(root, resolved);
-    if (rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel)) {
+    const rel = path17.relative(root, resolved);
+    if (rel === "" || !rel.startsWith("..") && !path17.isAbsolute(rel)) {
       return true;
     }
   }
@@ -33173,7 +34078,7 @@ function rewriteFrontmatter3(originalLines, next) {
 async function readBrandsFromDir(scope, dir) {
   let entries;
   try {
-    entries = await fs8.readdir(dir, { withFileTypes: true });
+    entries = await fs10.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -33183,17 +34088,17 @@ async function readBrandsFromDir(scope, dir) {
     if (!entry.name.endsWith(".md")) continue;
     const name = entry.name.slice(0, -".md".length);
     if (!name || !NAME_REGEX3.test(name)) continue;
-    const fullPath = path15.join(dir, entry.name);
+    const fullPath = path17.join(dir, entry.name);
     let stat5;
     try {
-      const s = await fs8.stat(fullPath);
+      const s = await fs10.stat(fullPath);
       stat5 = { mtime: s.mtime, size: s.size };
     } catch {
       continue;
     }
     let parsed;
     try {
-      const text = await fs8.readFile(fullPath, "utf8");
+      const text = await fs10.readFile(fullPath, "utf8");
       const { rawFrontmatterLines, hadFrontmatter } = parseBrandFile(text);
       parsed = hadFrontmatter ? parseFrontmatter2(rawFrontmatterLines) : { description: "", tags: [], variables: [] };
     } catch {
@@ -33227,10 +34132,10 @@ async function createBrand(args) {
     throw new Error(`Brand name must not contain path separators or "..".`);
   }
   const dir = resolveScopeDir3("project", args.workspaceRoot);
-  await fs8.mkdir(dir, { recursive: true });
-  const filePath = path15.join(dir, `${args.name}.md`);
+  await fs10.mkdir(dir, { recursive: true });
+  const filePath = path17.join(dir, `${args.name}.md`);
   try {
-    await fs8.access(filePath);
+    await fs10.access(filePath);
     throw new Error(`A brand named "${args.name}" already exists at ${filePath}`);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
@@ -33240,7 +34145,7 @@ async function createBrand(args) {
       throw err;
     }
   }
-  await fs8.writeFile(filePath, buildStarterBrand(args.name), "utf8");
+  await fs10.writeFile(filePath, buildStarterBrand(args.name), "utf8");
   return { path: filePath };
 }
 function buildStarterBrand(name) {
@@ -33285,7 +34190,7 @@ async function copyBrandAsset(args) {
   if (!args.workspaceRoot) {
     throw new Error("workspaceRoot is required to copy a brand asset");
   }
-  if (!args.sourcePath || !path15.isAbsolute(args.sourcePath)) {
+  if (!args.sourcePath || !path17.isAbsolute(args.sourcePath)) {
     throw new Error(`copyBrandAsset expects an absolute sourcePath; got "${args.sourcePath}"`);
   }
   if (!TARGET_NAME_REGEX.test(args.targetName) || args.targetName.includes("..")) {
@@ -33293,20 +34198,20 @@ async function copyBrandAsset(args) {
       `Invalid targetName "${args.targetName}". Use letters, digits, dot, underscore, dash.`
     );
   }
-  const stats = await fs8.stat(args.sourcePath);
+  const stats = await fs10.stat(args.sourcePath);
   if (!stats.isFile()) {
     throw new Error(`Source path is not a regular file: ${args.sourcePath}`);
   }
-  const ext = path15.extname(args.sourcePath).toLowerCase();
+  const ext = path17.extname(args.sourcePath).toLowerCase();
   const fileName = `${args.targetName}${ext}`;
-  const assetsDir = path15.join(args.workspaceRoot, ".brand", "assets");
-  const destAbs = path15.resolve(assetsDir, fileName);
-  const rel = path15.relative(path15.resolve(assetsDir), destAbs);
-  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
+  const assetsDir = path17.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path17.resolve(assetsDir, fileName);
+  const rel = path17.relative(path17.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path17.isAbsolute(rel)) {
     throw new Error(`Refusing to write outside of .brand/assets: ${destAbs}`);
   }
-  await fs8.mkdir(assetsDir, { recursive: true });
-  await fs8.copyFile(args.sourcePath, destAbs);
+  await fs10.mkdir(assetsDir, { recursive: true });
+  await fs10.copyFile(args.sourcePath, destAbs);
   return {
     relativePath: `assets/${fileName}`,
     absolutePath: destAbs
@@ -33324,13 +34229,13 @@ async function uploadBrandAsset(args) {
   if (!args.dataBase64 || args.dataBase64.trim().length === 0) {
     throw new Error("No file data provided for brand asset upload");
   }
-  const extFromSource = args.sourceName ? path15.extname(args.sourceName).toLowerCase() : "";
+  const extFromSource = args.sourceName ? path17.extname(args.sourceName).toLowerCase() : "";
   const ext = extFromSource || ".png";
   const fileName = `${args.targetName}${ext}`;
-  const assetsDir = path15.join(args.workspaceRoot, ".brand", "assets");
-  const destAbs = path15.resolve(assetsDir, fileName);
-  const rel = path15.relative(path15.resolve(assetsDir), destAbs);
-  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
+  const assetsDir = path17.join(args.workspaceRoot, ".brand", "assets");
+  const destAbs = path17.resolve(assetsDir, fileName);
+  const rel = path17.relative(path17.resolve(assetsDir), destAbs);
+  if (rel.startsWith("..") || path17.isAbsolute(rel)) {
     throw new Error(`Refusing to write outside of .brand/assets: ${destAbs}`);
   }
   let data;
@@ -33342,15 +34247,15 @@ async function uploadBrandAsset(args) {
   if (data.length === 0) {
     throw new Error("Uploaded brand asset is empty");
   }
-  await fs8.mkdir(assetsDir, { recursive: true });
-  await fs8.writeFile(destAbs, data);
+  await fs10.mkdir(assetsDir, { recursive: true });
+  await fs10.writeFile(destAbs, data);
   return {
     relativePath: `assets/${fileName}`,
     absolutePath: destAbs
   };
 }
 async function writeBrandFrontmatter(args, workspaceRoot) {
-  if (!path15.isAbsolute(args.path)) {
+  if (!path17.isAbsolute(args.path)) {
     throw new Error(`writeBrandFrontmatter expects an absolute path; got "${args.path}"`);
   }
   if (!isInsideAllowedRoot3(args.path, workspaceRoot)) {
@@ -33358,7 +34263,7 @@ async function writeBrandFrontmatter(args, workspaceRoot) {
   }
   let original;
   try {
-    original = await fs8.readFile(args.path, "utf8");
+    original = await fs10.readFile(args.path, "utf8");
   } catch (err) {
     throw new Error(
       `Failed to read brand file: ${err instanceof Error ? err.message : String(err)}`
@@ -33371,14 +34276,14 @@ async function writeBrandFrontmatter(args, workspaceRoot) {
 ${parsed.body}` : `${nextFrontmatter}
 
 ${original}`;
-  await fs8.writeFile(args.path, nextContent, "utf8");
+  await fs10.writeFile(args.path, nextContent, "utf8");
 }
 
 // ../server/src/services/oauth-service.ts
-import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile3, rename, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname4, join as join11 } from "node:path";
 import * as YAML from "yaml";
 var GITLAB_CLIENT_ID = "7783dfb277ccf3dbce35a9d54c3c0aec24ed2006cb2d171e0749fd8444ed4f7c";
 var GITLAB_AUTHORIZE_URL = "https://gitlab.com/oauth/authorize";
@@ -33400,7 +34305,7 @@ var OAuthError = class extends Error {
 function createOAuthService(options) {
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
   const now = options.now ?? Date.now;
-  const credentialsPath = join9(options.appostleHome, "credentials.json");
+  const credentialsPath = join11(options.appostleHome, "credentials.json");
   const glabConfigPath = options.glabConfigPath ?? defaultGlabConfigPath();
   const oauthLogger = options.logger.child({ module: "oauth-service" });
   const pending = /* @__PURE__ */ new Map();
@@ -33522,7 +34427,7 @@ function generateCodeVerifier() {
   return base64url(randomBytes2(32));
 }
 function computeCodeChallenge(verifier) {
-  return base64url(createHash3("sha256").update(verifier).digest());
+  return base64url(createHash4("sha256").update(verifier).digest());
 }
 function generateState() {
   return base64url(randomBytes2(24));
@@ -33619,80 +34524,80 @@ async function fetchGitLabUsername(fetchImpl, accessToken) {
     return null;
   }
 }
-async function readCredential(path24, log2) {
+async function readCredential(path26, log2) {
   try {
-    const raw = await readFile3(path24, "utf8");
+    const raw = await readFile3(path26, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.gitlab ?? null;
   } catch (error) {
     if (isNotFound(error)) return null;
-    log2.warn({ err: error, path: path24 }, "oauth.credentials.read_failed");
+    log2.warn({ err: error, path: path26 }, "oauth.credentials.read_failed");
     return null;
   }
 }
-async function persistCredential(path24, credential, log2) {
-  await mkdir4(dirname4(path24), { recursive: true });
+async function persistCredential(path26, credential, log2) {
+  await mkdir4(dirname4(path26), { recursive: true });
   let current = {};
   try {
-    const raw = await readFile3(path24, "utf8");
+    const raw = await readFile3(path26, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (!isNotFound(error)) {
-      log2.warn({ err: error, path: path24 }, "oauth.credentials.read_failed_overwriting");
+      log2.warn({ err: error, path: path26 }, "oauth.credentials.read_failed_overwriting");
     }
   }
   const next = { ...current, gitlab: credential };
-  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path26}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(next, null, 2), { mode: 384 });
-  await rename(tmpPath, path24);
+  await rename(tmpPath, path26);
 }
-async function deleteCredential(path24, log2) {
+async function deleteCredential(path26, log2) {
   let current = {};
   try {
-    const raw = await readFile3(path24, "utf8");
+    const raw = await readFile3(path26, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log2.warn({ err: error, path: path24 }, "oauth.credentials.delete_read_failed");
+    log2.warn({ err: error, path: path26 }, "oauth.credentials.delete_read_failed");
     return;
   }
   delete current.gitlab;
   if (Object.keys(current).length === 0) {
     try {
-      await unlink(path24);
+      await unlink(path26);
     } catch (error) {
       if (!isNotFound(error)) {
-        log2.warn({ err: error, path: path24 }, "oauth.credentials.unlink_failed");
+        log2.warn({ err: error, path: path26 }, "oauth.credentials.unlink_failed");
       }
     }
     return;
   }
-  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path26}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(current, null, 2), { mode: 384 });
-  await rename(tmpPath, path24);
+  await rename(tmpPath, path26);
 }
 function defaultGlabConfigPath() {
   const home = homedir4();
   if (process.platform === "darwin") {
-    return join9(home, "Library", "Application Support", "glab-cli", "config.yml");
+    return join11(home, "Library", "Application Support", "glab-cli", "config.yml");
   }
   if (process.platform === "win32") {
     const appData = process.env.APPDATA;
-    if (appData) return join9(appData, "glab-cli", "config.yml");
-    return join9(home, "AppData", "Roaming", "glab-cli", "config.yml");
+    if (appData) return join11(appData, "glab-cli", "config.yml");
+    return join11(home, "AppData", "Roaming", "glab-cli", "config.yml");
   }
   const xdg = process.env.XDG_CONFIG_HOME;
-  return join9(xdg && xdg.length > 0 ? xdg : join9(home, ".config"), "glab-cli", "config.yml");
+  return join11(xdg && xdg.length > 0 ? xdg : join11(home, ".config"), "glab-cli", "config.yml");
 }
-async function writeGlabConfig(path24, credential, log2) {
-  await mkdir4(dirname4(path24), { recursive: true });
+async function writeGlabConfig(path26, credential, log2) {
+  await mkdir4(dirname4(path26), { recursive: true });
   let doc;
   try {
-    const raw = await readFile3(path24, "utf8");
+    const raw = await readFile3(path26, "utf8");
     doc = YAML.parseDocument(raw);
     if (doc.errors.length > 0) {
       log2.warn(
-        { errors: doc.errors.map((e) => e.message), path: path24 },
+        { errors: doc.errors.map((e) => e.message), path: path26 },
         "oauth.glab.parse_errors_replacing"
       );
       doc = YAML.parseDocument("{}");
@@ -33701,7 +34606,7 @@ async function writeGlabConfig(path24, credential, log2) {
     if (isNotFound(error)) {
       doc = YAML.parseDocument("{}");
     } else {
-      log2.warn({ err: error, path: path24 }, "oauth.glab.read_failed_replacing");
+      log2.warn({ err: error, path: path26 }, "oauth.glab.read_failed_replacing");
       doc = YAML.parseDocument("{}");
     }
   }
@@ -33714,18 +34619,18 @@ async function writeGlabConfig(path24, credential, log2) {
   if (credential.username) {
     hostEntry.set("user", credential.username);
   }
-  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path26}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path24);
+  await rename(tmpPath, path26);
 }
-async function removeGlabHost(path24, log2) {
+async function removeGlabHost(path26, log2) {
   let doc;
   try {
-    const raw = await readFile3(path24, "utf8");
+    const raw = await readFile3(path26, "utf8");
     doc = YAML.parseDocument(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log2.warn({ err: error, path: path24 }, "oauth.glab.remove_read_failed");
+    log2.warn({ err: error, path: path26 }, "oauth.glab.remove_read_failed");
     return;
   }
   const hosts = doc.get("hosts");
@@ -33734,9 +34639,9 @@ async function removeGlabHost(path24, log2) {
   if (hosts.items.length === 0) {
     doc.delete("hosts");
   }
-  const tmpPath = `${path24}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path26}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path24);
+  await rename(tmpPath, path26);
 }
 function ensureMap(doc, key) {
   const existing = doc.get(key);
@@ -34702,6 +35607,50 @@ function summarizeFetchWorkspacesEntries(entries) {
     workspaces
   };
 }
+function synthesizeRecordedUserText(rawText, files, imageCount = 0) {
+  if (rawText.trim().length > 0) {
+    return rawText;
+  }
+  if (files.length === 0 && imageCount === 0) {
+    return rawText;
+  }
+  const parts = [];
+  if (imageCount > 0) {
+    parts.push(imageCount === 1 ? "Sent 1 image" : `Sent ${imageCount} images`);
+  }
+  if (files.length > 0) {
+    const names = files.map((f) => f.fileName).join(", ");
+    parts.push(
+      files.length === 1 ? `uploaded ${names}` : `uploaded ${files.length} files: ${names}`
+    );
+  }
+  return parts.join(" and ");
+}
+function buildImageEcho(incoming, persisted) {
+  const out = [];
+  for (let i = 0; i < incoming.length; i++) {
+    const img = incoming[i];
+    const stored = persisted[i];
+    const id = stored?.id ?? img?.id;
+    if (!img || !id) continue;
+    const fileName = img.fileName ?? stored?.fileName ?? void 0;
+    const byteSize = typeof img.byteSize === "number" ? img.byteSize : typeof stored?.size === "number" ? stored.size : void 0;
+    out.push({
+      id,
+      mimeType: img.mimeType,
+      ...fileName ? { fileName } : {},
+      ...typeof byteSize === "number" ? { byteSize } : {},
+      ...stored ? {
+        daemonRef: {
+          kind: "image",
+          attachmentId: stored.id,
+          relativePath: stored.relativePath
+        }
+      } : {}
+    });
+  }
+  return out;
+}
 var SessionRequestError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -34879,6 +35828,8 @@ var Session = class _Session {
     });
     this.agentManager = agentManager;
     this.agentStorage = agentStorage;
+    this.uploadStore = new SessionUploadStore({ logger: this.sessionLogger });
+    this.imageStore = new SessionImageStore({ logger: this.sessionLogger });
     this.projectRegistry = projectRegistry;
     this.workspaceRegistry = workspaceRegistry;
     this.chatService = chatService;
@@ -34990,11 +35941,12 @@ var Session = class _Session {
   /**
    * Normalize a user prompt (with optional image metadata) for AgentManager
    */
-  buildAgentPrompt(text, images, attachments) {
+  buildAgentPrompt(text, images, attachments, files) {
     const normalized = text?.trim() ?? "";
     const hasImages = Boolean(images && images.length > 0);
     const hasAttachments = Boolean(attachments && attachments.length > 0);
-    if (!hasImages && !hasAttachments) {
+    const hasFiles = Boolean(files && files.length > 0);
+    if (!hasImages && !hasAttachments && !hasFiles) {
       return normalized;
     }
     const blocks = [];
@@ -35007,8 +35959,46 @@ var Session = class _Session {
     for (const attachment of attachments ?? []) {
       blocks.push(attachment);
     }
+    if (hasFiles && files) {
+      blocks.push({ type: "text", text: renderFileAttachmentFooter(files) });
+    }
     return blocks;
   }
+  /**
+   * Read persisted image bytes off disk for the LLM prompt. The daemon is
+   * the canonical source of truth for image bytes (Clay pattern); the wire
+   * payload is just an upload conduit. Reads through the agent's cwd via
+   * `imageStore.readImageBytes`, which traversal-guards the relative path.
+   *
+   * Falls back to skipping any image whose disk read fails (logged) — better
+   * to send a partial prompt than to crash the whole turn.
+   */
+  async loadPromptImagesFromDisk(persistedImages, agentId) {
+    const agent = this.agentManager.getAgent(agentId);
+    if (!agent) {
+      this.sessionLogger.warn(
+        { agentId },
+        "loadPromptImagesFromDisk: agent vanished between persist and read"
+      );
+      return [];
+    }
+    const out = [];
+    for (const persisted of persistedImages) {
+      try {
+        const { data, mimeType } = await this.imageStore.readImageBytes({
+          cwd: agent.cwd,
+          relativePath: persisted.relativePath
+        });
+        out.push({ data: data.toString("base64"), mimeType });
+      } catch (error) {
+        this.sessionLogger.warn(
+          { agentId, attachmentId: persisted.id, err: error },
+          "loadPromptImagesFromDisk: failed to read image; skipping for this turn"
+        );
+      }
+    }
+    return out;
+  }
   /**
    * Interrupt the agent's active run so the next prompt starts a fresh turn.
    * Returns once the manager confirms the stream has been cancelled.
@@ -35477,6 +36467,21 @@ var Session = class _Session {
           case "send_agent_message_request":
             await this.handleSendAgentMessageRequest(msg);
             break;
+          case "list_session_uploads_request":
+            await this.handleListSessionUploadsRequest(msg);
+            break;
+          case "delete_session_upload_request":
+            await this.handleDeleteSessionUploadRequest(msg);
+            break;
+          case "list_session_images_request":
+            await this.handleListSessionImagesRequest(msg);
+            break;
+          case "delete_session_image_request":
+            await this.handleDeleteSessionImageRequest(msg);
+            break;
+          case "fetch_attachment_bytes_request":
+            await this.handleFetchAttachmentBytesRequest(msg);
+            break;
           case "wait_for_finish_request":
             await this.handleWaitForFinish(msg.agentId, msg.requestId, msg.timeoutMs);
             break;
@@ -36747,26 +37752,86 @@ var Session = class _Session {
    * Handle text message to agent (with optional image attachments)
    */
   async handleSendAgentMessage(agentId, text, messageId, images, attachments, runOptions, options) {
+    const files = options?.files ?? [];
     this.sessionLogger.info(
       {
         agentId,
         textPreview: text.substring(0, 50),
         imageCount: images?.length ?? 0,
-        attachmentCount: attachments?.length ?? 0
+        attachmentCount: attachments?.length ?? 0,
+        fileCount: files.length
       },
-      `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ""}${attachments && attachments.length > 0 ? ` and ${attachments.length} structured attachment(s)` : ""}`
+      `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ""}${attachments && attachments.length > 0 ? ` and ${attachments.length} structured attachment(s)` : ""}${files.length > 0 ? ` and ${files.length} file attachment(s)` : ""}`
     );
+    let persistedFiles = [];
+    let persistedImages = [];
+    const hasFiles = files.length > 0;
+    const hasImages = (images?.length ?? 0) > 0;
+    if (hasFiles || hasImages) {
+      const agent = this.agentManager.getAgent(agentId);
+      if (!agent) {
+        return {
+          ok: false,
+          error: `Agent ${agentId} not found; cannot persist attachments`
+        };
+      }
+      try {
+        if (hasFiles) {
+          persistedFiles = await this.uploadStore.persistFiles({
+            cwd: agent.cwd,
+            agentId,
+            messageId: messageId ?? null,
+            files
+          });
+        }
+        if (hasImages && images) {
+          persistedImages = await this.imageStore.persistImages({
+            cwd: agent.cwd,
+            agentId,
+            messageId: messageId ?? null,
+            images
+          });
+        }
+      } catch (error) {
+        if (error instanceof UploadSizeError) {
+          return {
+            ok: false,
+            error: `Attachments exceed the ${MAX_UPLOAD_BYTES_PER_MESSAGE} byte limit per message`
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: `Failed to persist attachments: ${message}` };
+      }
+    }
     const promptText = options?.spokenInput ? wrapSpokenInput(text) : text;
-    const prompt = this.buildAgentPrompt(promptText, images, attachments);
+    const promptImages = persistedImages.length > 0 ? await this.loadPromptImagesFromDisk(persistedImages, agentId) : images;
+    const prompt = this.buildAgentPrompt(promptText, promptImages, attachments, persistedFiles);
+    const recordedText = synthesizeRecordedUserText(text, persistedFiles, images?.length ?? 0);
+    const userMessageImages = buildImageEcho(images ?? [], persistedImages);
+    const userMessageFiles = persistedFiles.map((f) => ({
+      id: f.id,
+      fileName: f.fileName,
+      mimeType: f.mimeType,
+      size: f.size,
+      daemonRef: {
+        kind: "file",
+        attachmentId: f.id,
+        relativePath: f.relativePath
+      }
+    }));
+    const recordedTextIsSynthesized = text.trim().length === 0 && (userMessageImages.length > 0 || userMessageFiles.length > 0);
     try {
       await sendPromptToAgent({
         agentManager: this.agentManager,
         agentStorage: this.agentStorage,
         agentId,
-        userMessageText: text,
+        userMessageText: recordedText,
         prompt,
         messageId,
         runOptions,
+        ...userMessageImages.length > 0 ? { userMessageImages } : {},
+        ...userMessageFiles.length > 0 ? { userMessageFiles } : {},
+        ...recordedTextIsSynthesized ? { userMessageTextIsSynthesized: true } : {},
         logger: this.sessionLogger
       });
       return { ok: true };
@@ -36791,6 +37856,7 @@ var Session = class _Session {
       outputSchema,
       git,
       images,
+      files,
       attachments,
       labels
     } = msg;
@@ -36831,7 +37897,7 @@ var Session = class _Session {
         }
       );
       await this.forwardAgentUpdate(snapshot);
-      if (trimmedPrompt || (images?.length ?? 0) > 0 || (attachments?.length ?? 0) > 0) {
+      if (trimmedPrompt || (images?.length ?? 0) > 0 || (attachments?.length ?? 0) > 0 || (files?.length ?? 0) > 0) {
         scheduleAgentMetadataGeneration({
           agentManager: this.agentManager,
           agentId: snapshot.id,
@@ -36847,7 +37913,8 @@ var Session = class _Session {
           resolveClientMessageId(clientMessageId),
           images,
           attachments,
-          outputSchema ? { outputSchema } : void 0
+          outputSchema ? { outputSchema } : void 0,
+          files && files.length > 0 ? { files } : void 0
         );
         if (!started.ok) {
           throw new Error(started.error);
@@ -38264,7 +39331,7 @@ var Session = class _Session {
         homeDir: process.env.HOME ?? homedir5(),
         query: query2,
         limit
-      })).map((path24) => ({ path: path24, kind: "directory" }));
+      })).map((path26) => ({ path: path26, kind: "directory" }));
       const directories = entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path);
       this.emit({
         type: "directory_suggestions_response",
@@ -39318,10 +40385,11 @@ ${details}`.trim());
         root: cwd,
         relativePath: requestedPath
       });
+      const recoveredFileName = originalUploadFileName(info.path) ?? info.fileName;
       const entry = this.downloadTokenStore.issueToken({
         path: info.path,
         absolutePath: info.absolutePath,
-        fileName: info.fileName,
+        fileName: recoveredFileName,
         mimeType: info.mimeType,
         size: info.size
       });
@@ -39368,7 +40436,7 @@ ${details}`.trim());
     );
     const registryRecords = await this.agentStorage.list();
     const liveIds = new Set(agentSnapshots.map((a) => a.id));
-    const persistedAgents = registryRecords.filter((record) => !liveIds.has(record.id) && !record.internal).map((record) => this.buildStoredAgentPayload(record));
+    const persistedAgents = registryRecords.filter((record) => !liveIds.has(record.id)).map((record) => this.buildStoredAgentPayload(record));
     let agents = [...liveAgents, ...persistedAgents];
     agents = agents.filter((agent) => this.isProviderVisibleToClient(agent.provider));
     if (filter?.labels) {
@@ -40755,19 +41823,96 @@ ${details}`.trim());
     }
     try {
       const agentId = resolved.agentId;
-      const prompt = this.buildAgentPrompt(msg.text, msg.images, msg.attachments);
+      let persistedFiles = [];
+      let persistedImages = [];
+      const hasFiles = (msg.files?.length ?? 0) > 0;
+      const hasImages = (msg.images?.length ?? 0) > 0;
+      if (hasFiles || hasImages) {
+        const agent = this.agentManager.getAgent(agentId);
+        if (!agent) {
+          this.emit({
+            type: "send_agent_message_response",
+            payload: {
+              requestId: msg.requestId,
+              agentId,
+              accepted: false,
+              error: `Agent ${agentId} not found; cannot persist attachments`
+            }
+          });
+          return;
+        }
+        try {
+          if (hasFiles && msg.files) {
+            persistedFiles = await this.uploadStore.persistFiles({
+              cwd: agent.cwd,
+              agentId,
+              messageId: msg.messageId ?? null,
+              files: msg.files
+            });
+          }
+          if (hasImages && msg.images) {
+            persistedImages = await this.imageStore.persistImages({
+              cwd: agent.cwd,
+              agentId,
+              messageId: msg.messageId ?? null,
+              images: msg.images
+            });
+          }
+        } catch (error) {
+          const message = error instanceof UploadSizeError ? `Attachments exceed the ${MAX_UPLOAD_BYTES_PER_MESSAGE} byte limit per message` : error instanceof Error ? `Failed to persist attachments: ${error.message}` : "Failed to persist attachments";
+          this.emit({
+            type: "send_agent_message_response",
+            payload: {
+              requestId: msg.requestId,
+              agentId,
+              accepted: false,
+              error: message
+            }
+          });
+          return;
+        }
+      }
+      const promptImages = persistedImages.length > 0 ? await this.loadPromptImagesFromDisk(persistedImages, agentId) : msg.images;
+      const prompt = this.buildAgentPrompt(msg.text, promptImages, msg.attachments, persistedFiles);
+      const recordedText = synthesizeRecordedUserText(
+        msg.text,
+        persistedFiles,
+        msg.images?.length ?? 0
+      );
+      const userMessageImages = buildImageEcho(msg.images ?? [], persistedImages);
+      const userMessageFiles = persistedFiles.map((f) => ({
+        id: f.id,
+        fileName: f.fileName,
+        mimeType: f.mimeType,
+        size: f.size,
+        daemonRef: {
+          kind: "file",
+          attachmentId: f.id,
+          relativePath: f.relativePath
+        }
+      }));
       this.sessionLogger.trace(
-        { agentId, messageId: msg.messageId, textPrefix: msg.text.slice(0, 80) },
+        {
+          agentId,
+          messageId: msg.messageId,
+          textPrefix: msg.text.slice(0, 80),
+          fileCount: persistedFiles.length,
+          echoImageCount: userMessageImages.length
+        },
         "send_agent_message_request: dispatching shared sendPromptToAgent"
       );
+      const recordedTextIsSynthesized = msg.text.trim().length === 0 && (userMessageImages.length > 0 || userMessageFiles.length > 0);
       try {
         await sendPromptToAgent({
           agentManager: this.agentManager,
           agentStorage: this.agentStorage,
           agentId,
-          userMessageText: msg.text,
+          userMessageText: recordedText,
           prompt,
           messageId: msg.messageId,
+          ...userMessageImages.length > 0 ? { userMessageImages } : {},
+          ...userMessageFiles.length > 0 ? { userMessageFiles } : {},
+          ...recordedTextIsSynthesized ? { userMessageTextIsSynthesized: true } : {},
           logger: this.sessionLogger
         });
       } catch (error) {
@@ -40826,6 +41971,242 @@ ${details}`.trim());
       });
     }
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Session uploads — backs the in-app "Files" tab inside an active session.
+  // Both handlers resolve `agentId` against the agent registry first so we
+  // get the same accept-prefix-or-title behaviour as send_agent_message, and
+  // both fail closed on a missing agent (no implicit "list everything" that
+  // could leak across sessions).
+  // ──────────────────────────────────────────────────────────────────────
+  async handleListSessionUploadsRequest(msg) {
+    const resolved = await this.resolveAgentIdentifier(msg.agentId);
+    if (!resolved.ok) {
+      this.emit({
+        type: "list_session_uploads_response",
+        payload: { requestId: msg.requestId, ok: false, error: resolved.error }
+      });
+      return;
+    }
+    const agent = this.agentManager.getAgent(resolved.agentId);
+    if (!agent) {
+      this.emit({
+        type: "list_session_uploads_response",
+        payload: { requestId: msg.requestId, ok: false, error: "Agent not found" }
+      });
+      return;
+    }
+    try {
+      const uploads = await this.uploadStore.listUploads({
+        cwd: agent.cwd,
+        agentId: resolved.agentId
+      });
+      this.emit({
+        type: "list_session_uploads_response",
+        payload: { requestId: msg.requestId, ok: true, uploads }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit({
+        type: "list_session_uploads_response",
+        payload: { requestId: msg.requestId, ok: false, error: message }
+      });
+    }
+  }
+  async handleDeleteSessionUploadRequest(msg) {
+    const resolved = await this.resolveAgentIdentifier(msg.agentId);
+    if (!resolved.ok) {
+      this.emit({
+        type: "delete_session_upload_response",
+        payload: { requestId: msg.requestId, ok: false, error: resolved.error }
+      });
+      return;
+    }
+    const agent = this.agentManager.getAgent(resolved.agentId);
+    if (!agent) {
+      this.emit({
+        type: "delete_session_upload_response",
+        payload: { requestId: msg.requestId, ok: false, error: "Agent not found" }
+      });
+      return;
+    }
+    try {
+      const result = await this.uploadStore.deleteUpload({
+        cwd: agent.cwd,
+        agentId: resolved.agentId,
+        uploadId: msg.uploadId
+      });
+      if (!result.deleted) {
+        this.emit({
+          type: "delete_session_upload_response",
+          payload: { requestId: msg.requestId, ok: false, error: "Upload not found" }
+        });
+        return;
+      }
+      this.emit({
+        type: "delete_session_upload_response",
+        payload: { requestId: msg.requestId, ok: true }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit({
+        type: "delete_session_upload_response",
+        payload: { requestId: msg.requestId, ok: false, error: message }
+      });
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Session images — backs the "Images" tab inside the uploads modal. Same
+  // shape as the file handlers above; the store has no manifest, so listing
+  // is a directory scan and delete is `unlink` (traversal-guarded).
+  // ──────────────────────────────────────────────────────────────────────
+  async handleListSessionImagesRequest(msg) {
+    const resolved = await this.resolveAgentIdentifier(msg.agentId);
+    if (!resolved.ok) {
+      this.emit({
+        type: "list_session_images_response",
+        payload: { requestId: msg.requestId, ok: false, error: resolved.error }
+      });
+      return;
+    }
+    const agent = this.agentManager.getAgent(resolved.agentId);
+    if (!agent) {
+      this.emit({
+        type: "list_session_images_response",
+        payload: { requestId: msg.requestId, ok: false, error: "Agent not found" }
+      });
+      return;
+    }
+    try {
+      const images = await this.imageStore.listImages({ cwd: agent.cwd });
+      this.emit({
+        type: "list_session_images_response",
+        payload: { requestId: msg.requestId, ok: true, images }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit({
+        type: "list_session_images_response",
+        payload: { requestId: msg.requestId, ok: false, error: message }
+      });
+    }
+  }
+  async handleDeleteSessionImageRequest(msg) {
+    const resolved = await this.resolveAgentIdentifier(msg.agentId);
+    if (!resolved.ok) {
+      this.emit({
+        type: "delete_session_image_response",
+        payload: { requestId: msg.requestId, ok: false, error: resolved.error }
+      });
+      return;
+    }
+    const agent = this.agentManager.getAgent(resolved.agentId);
+    if (!agent) {
+      this.emit({
+        type: "delete_session_image_response",
+        payload: { requestId: msg.requestId, ok: false, error: "Agent not found" }
+      });
+      return;
+    }
+    try {
+      const result = await this.imageStore.deleteImage({
+        cwd: agent.cwd,
+        relativePath: msg.relativePath
+      });
+      if (!result.deleted) {
+        this.emit({
+          type: "delete_session_image_response",
+          payload: { requestId: msg.requestId, ok: false, error: "Image not found" }
+        });
+        return;
+      }
+      this.emit({
+        type: "delete_session_image_response",
+        payload: { requestId: msg.requestId, ok: true }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit({
+        type: "delete_session_image_response",
+        payload: { requestId: msg.requestId, ok: false, error: message }
+      });
+    }
+  }
+  /**
+   * Serve attachment bytes by id. The daemon is the canonical source — every
+   * paired client (Electron after Cmd-R, phone, web) hits this RPC to render
+   * thumbnails or download files. Bytes never round-trip through the chat
+   * timeline; they're fetched on demand.
+   *
+   * `relativePath` comes from the user_message timeline echo's `daemonRef`;
+   * the store's read methods traversal-guard it so it can't escape the
+   * dedicated subdirectories.
+   */
+  async handleFetchAttachmentBytesRequest(msg) {
+    const resolved = await this.resolveAgentIdentifier(msg.agentId);
+    if (!resolved.ok) {
+      this.emit({
+        type: "fetch_attachment_bytes_response",
+        payload: { requestId: msg.requestId, ok: false, error: resolved.error }
+      });
+      return;
+    }
+    const agent = this.agentManager.getAgent(resolved.agentId);
+    if (!agent) {
+      this.emit({
+        type: "fetch_attachment_bytes_response",
+        payload: { requestId: msg.requestId, ok: false, error: "Agent not found" }
+      });
+      return;
+    }
+    try {
+      if (msg.kind === "image") {
+        const { data, mimeType, byteSize } = await this.imageStore.readImageBytes({
+          cwd: agent.cwd,
+          relativePath: msg.relativePath
+        });
+        this.emit({
+          type: "fetch_attachment_bytes_response",
+          payload: {
+            requestId: msg.requestId,
+            ok: true,
+            attachmentId: msg.attachmentId,
+            kind: "image",
+            data: data.toString("base64"),
+            mimeType,
+            byteSize
+          }
+        });
+      } else {
+        const { data, mimeType, byteSize, fileName } = await this.uploadStore.readUploadBytes({
+          cwd: agent.cwd,
+          relativePath: msg.relativePath
+        });
+        this.emit({
+          type: "fetch_attachment_bytes_response",
+          payload: {
+            requestId: msg.requestId,
+            ok: true,
+            attachmentId: msg.attachmentId,
+            kind: "file",
+            data: data.toString("base64"),
+            mimeType,
+            byteSize,
+            fileName
+          }
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.sessionLogger.warn(
+        { agentId: resolved.agentId, attachmentId: msg.attachmentId, kind: msg.kind, err: error },
+        "fetch_attachment_bytes_request: failed to read"
+      );
+      this.emit({
+        type: "fetch_attachment_bytes_response",
+        payload: { requestId: msg.requestId, ok: false, error: message }
+      });
+    }
+  }
   async handleWaitForFinish(agentIdOrIdentifier, requestId, timeoutMs) {
     const resolved = await this.resolveAgentIdentifier(agentIdOrIdentifier);
     if (!resolved.ok) {
@@ -41970,6 +43351,7 @@ ${details}`.trim());
         status: w.status,
         cwd: w.cwd,
         prompt: w.prompt,
+        name: w.name,
         createdAt: w.createdAt,
         updatedAt: w.updatedAt
       }));
@@ -43044,6 +44426,64 @@ var StoredLoopsSchema = z39.array(LoopRecordSchema2);
 import { z as z40 } from "zod";
 var StoredQuestsSchema = z40.array(QuestRecordSchema);
 
+// ../server/src/server/quest/quest-metadata-generator.ts
+import { z as z41 } from "zod";
+
+// ../server/src/server/quest/orchestrator-mcp.ts
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z as z42 } from "zod";
+var HANDOFF_INPUT_SHAPE = {
+  rolePath: z42.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: z42.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."
+  )
+};
+
+// ../server/src/server/quest/runner-orchestrator.ts
+var FALLBACK_QUEEN_PROMPT_TEMPLATE = [
+  "you are going to send out agents, but first you get aquanted with 'the team'",
+  "You don't go do the work yourself!",
+  "",
+  "this team has very deep knowledge of the task at hand. they have very detailed skills and output prefs so they are smarter than you. don't assume otherwise.",
+  "",
+  "the team is split up in categories. you will try to consolidate all of their knowledge into an approach for the task below.",
+  "",
+  "",
+  "The team:",
+  "",
+  "{{team}}",
+  "",
+  "===",
+  "",
+  "The task at hand:",
+  "",
+  "",
+  ">>>>>",
+  "{{task}}",
+  "<<<<<<<<<<",
+  "",
+  "Again, whatever you are thinking of now I repeat: You don't go do the work yourself!",
+  "What your job IS tho:",
+  "",
+  "Now you have full knowledge of what the user wants and how he composed his 'team'",
+  "you do not delegate this team as subagents but you spawn new handoff sessions, you decide on what can be done in paralel and what needs to happen before the next can start. stage. the amount of handof sessions you spawn is equal to the amount of team entries in your prompt.",
+  "",
+  "",
+  "",
+  "We are going to use a hivemind dock in the repo.",
+  "What you can do, is now startup that hivemind doc in /.hivemind/orchestrator-{{questId}}.md",
+  "",
+  "",
+  "You instruct every handoff with a clear instruction on it's task.",
+  "But you also make sure that each handoff knows the greater context of the end goal and knows of the existence of the hivemind document.",
+  "it should know that it can write to it but first needs to check if there are no conflicts.",
+  "",
+  "",
+  "do not use subagents because these are emphetic. we need full sessions."
+].join("\n");
+
 // ../server/src/server/quest/runner-ralph.ts
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
@@ -43051,13 +44491,13 @@ var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
 
 // ../server/src/shared/connection-offer.ts
-import { z as z41 } from "zod";
-var ConnectionOfferV2Schema = z41.object({
-  v: z41.literal(2),
-  serverId: z41.string().min(1),
-  daemonPublicKeyB64: z41.string().min(1),
-  relay: z41.object({
-    endpoint: z41.string().min(1)
+import { z as z43 } from "zod";
+var ConnectionOfferV2Schema = z43.object({
+  v: z43.literal(2),
+  serverId: z43.string().min(1),
+  daemonPublicKeyB64: z43.string().min(1),
+  relay: z43.object({
+    endpoint: z43.string().min(1)
   })
 });
 
@@ -43090,22 +44530,22 @@ function isRelayClientWebSocketUrl(url) {
 }
 
 // ../server/src/server/config.ts
-import path17 from "node:path";
-import { z as z45 } from "zod";
+import path19 from "node:path";
+import { z as z47 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
-import path16 from "node:path";
-import { z as z42 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path16.join("models", "local-speech");
-var NumberLikeSchema2 = z42.union([z42.number(), z42.string().trim().min(1)]);
-var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z42.coerce.number().finite()).optional();
-var OptionalIntegerSchema = NumberLikeSchema2.pipe(z42.coerce.number().int()).optional();
-var LocalSpeechResolutionSchema = z42.object({
-  includeProviderConfig: z42.boolean(),
-  modelsDir: z42.string().trim().min(1),
+import path18 from "node:path";
+import { z as z44 } from "zod";
+var DEFAULT_LOCAL_MODELS_SUBDIR = path18.join("models", "local-speech");
+var NumberLikeSchema2 = z44.union([z44.number(), z44.string().trim().min(1)]);
+var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z44.coerce.number().finite()).optional();
+var OptionalIntegerSchema = NumberLikeSchema2.pipe(z44.coerce.number().int()).optional();
+var LocalSpeechResolutionSchema = z44.object({
+  includeProviderConfig: z44.boolean(),
+  modelsDir: z44.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),
@@ -43126,7 +44566,7 @@ function resolveLocalSpeechConfig(params) {
   const includeProviderConfig = shouldIncludeLocalProviderConfig(params);
   const parsed = LocalSpeechResolutionSchema.parse({
     includeProviderConfig,
-    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path16.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path18.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
     dictationLocalSttModel: params.env.APPOSTLE_DICTATION_LOCAL_STT_MODEL ?? persistedLocalFeatureModel(
       params.providers.dictationStt.provider,
       params.providers.dictationStt.enabled,
@@ -43161,17 +44601,17 @@ function resolveLocalSpeechConfig(params) {
 }
 
 // ../server/src/server/speech/speech-types.ts
-import { z as z43 } from "zod";
-var SpeechProviderIdSchema2 = z43.enum(["openai", "local"]);
-var RequestedSpeechProviderSchema = z43.object({
+import { z as z45 } from "zod";
+var SpeechProviderIdSchema2 = z45.enum(["openai", "local"]);
+var RequestedSpeechProviderSchema = z45.object({
   provider: SpeechProviderIdSchema2,
-  explicit: z43.boolean(),
-  enabled: z43.boolean().optional()
+  explicit: z45.boolean(),
+  enabled: z45.boolean().optional()
 });
 
 // ../server/src/server/speech/speech-config-resolver.ts
-var OptionalSpeechProviderSchema = z44.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
-var OptionalBooleanFlagSchema = z44.union([z44.boolean(), z44.string().trim().toLowerCase()]).optional().transform((value) => {
+var OptionalSpeechProviderSchema = z46.string().trim().toLowerCase().pipe(SpeechProviderIdSchema2).optional();
+var OptionalBooleanFlagSchema = z46.union([z46.boolean(), z46.string().trim().toLowerCase()]).optional().transform((value) => {
   if (typeof value === "boolean") {
     return value;
   }
@@ -43186,7 +44626,7 @@ var OptionalBooleanFlagSchema = z44.union([z44.boolean(), z44.string().trim().to
   }
   return void 0;
 });
-var RequestedSpeechProvidersSchema = z44.object({
+var RequestedSpeechProvidersSchema = z46.object({
   dictationStt: OptionalSpeechProviderSchema.default("local"),
   voiceTurnDetection: OptionalSpeechProviderSchema.default("local"),
   voiceStt: OptionalSpeechProviderSchema.default("local"),
@@ -43295,9 +44735,9 @@ function parseBooleanEnv(value) {
   }
   return void 0;
 }
-var OptionalVoiceLlmProviderSchema = z45.union([z45.string(), z45.null(), z45.undefined()]).transform(
+var OptionalVoiceLlmProviderSchema = z47.union([z47.string(), z47.null(), z47.undefined()]).transform(
   (value) => typeof value === "string" ? value.trim().toLowerCase() : null
-).pipe(z45.union([AgentProviderSchema, z45.null()]));
+).pipe(z47.union([AgentProviderSchema, z47.null()]));
 function parseOptionalVoiceLlmProvider(value) {
   const parsed = OptionalVoiceLlmProviderSchema.safeParse(value);
   return parsed.success ? parsed.data : null;
@@ -43382,7 +44822,7 @@ function loadConfig(appostleHome, options) {
     chromeEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
-    agentStoragePath: path17.join(appostleHome, "agents"),
+    agentStoragePath: path19.join(appostleHome, "agents"),
     staticDir: "public",
     agentClients: {},
     relayEnabled,
@@ -44600,12 +46040,12 @@ var DaemonClient = class {
       timeout: 1e4
     });
   }
-  async openInEditor(path24, editorId, requestId) {
+  async openInEditor(path26, editorId, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "open_in_editor_request",
-        path: path24,
+        path: path26,
         editorId
       },
       responseType: "open_in_editor_response",
@@ -44705,6 +46145,7 @@ var DaemonClient = class {
       ...options.clientMessageId ? { clientMessageId: options.clientMessageId } : {},
       ...options.outputSchema ? { outputSchema: options.outputSchema } : {},
       ...options.images && options.images.length > 0 ? { images: options.images } : {},
+      ...options.files && options.files.length > 0 ? { files: options.files } : {},
       ...options.attachments && options.attachments.length > 0 ? { attachments: options.attachments } : {},
       ...options.git ? { git: options.git } : {},
       ...options.worktreeName ? { worktreeName: options.worktreeName } : {},
@@ -44930,6 +46371,7 @@ var DaemonClient = class {
       text,
       ...messageId ? { messageId } : {},
       ...options?.images ? { images: options.images } : {},
+      ...options?.files ? { files: options.files } : {},
       ...options?.attachments ? { attachments: options.attachments } : {}
     });
     const payload = await this.sendRequest({
@@ -44954,6 +46396,157 @@ var DaemonClient = class {
   async sendMessage(agentId, text, options) {
     await this.sendAgentMessage(agentId, text, options);
   }
+  /**
+   * List the files the user has attached to this agent's chat (the "Files"
+   * tab in an active session). Returns newest first; the daemon serves the
+   * manifest stored under `<workspace>/.appostle/uploaded_files/`.
+   */
+  async listSessionUploads(agentId) {
+    const requestId = this.createRequestId();
+    const message = SessionInboundMessageSchema.parse({
+      type: "list_session_uploads_request",
+      requestId,
+      agentId
+    });
+    const payload = await this.sendRequest({
+      requestId,
+      message,
+      timeout: 15e3,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "list_session_uploads_response") return null;
+        if (msg.payload.requestId !== requestId) return null;
+        return msg.payload;
+      }
+    });
+    if (!payload.ok) {
+      throw new Error(payload.error || "Failed to list session uploads");
+    }
+    return payload.uploads;
+  }
+  /**
+   * Delete a single uploaded file. Removes both the manifest entry and the
+   * file on disk; the operation is idempotent — deleting a no-longer-existent
+   * upload throws so the caller can refresh the listing.
+   */
+  async deleteSessionUpload(agentId, uploadId) {
+    const requestId = this.createRequestId();
+    const message = SessionInboundMessageSchema.parse({
+      type: "delete_session_upload_request",
+      requestId,
+      agentId,
+      uploadId
+    });
+    const payload = await this.sendRequest({
+      requestId,
+      message,
+      timeout: 15e3,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "delete_session_upload_response") return null;
+        if (msg.payload.requestId !== requestId) return null;
+        return msg.payload;
+      }
+    });
+    if (!payload.ok) {
+      throw new Error(payload.error || "Failed to delete session upload");
+    }
+  }
+  /**
+   * List the images the user has attached to this agent's chat (the "Images"
+   * tab in the uploads modal). Returns newest first; the daemon scans
+   * `<workspace>/.appostle/uploaded_images/` directly — there's no manifest.
+   */
+  async listSessionImages(agentId) {
+    const requestId = this.createRequestId();
+    const message = SessionInboundMessageSchema.parse({
+      type: "list_session_images_request",
+      requestId,
+      agentId
+    });
+    const payload = await this.sendRequest({
+      requestId,
+      message,
+      timeout: 15e3,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "list_session_images_response") return null;
+        if (msg.payload.requestId !== requestId) return null;
+        return msg.payload;
+      }
+    });
+    if (!payload.ok) {
+      throw new Error(payload.error || "Failed to list session images");
+    }
+    return payload.images;
+  }
+  /**
+   * Delete a single uploaded image by workspace-relative path. The daemon
+   * traversal-guards the path so it cannot escape `.appostle/uploaded_images/`.
+   */
+  async deleteSessionImage(agentId, relativePath) {
+    const requestId = this.createRequestId();
+    const message = SessionInboundMessageSchema.parse({
+      type: "delete_session_image_request",
+      requestId,
+      agentId,
+      relativePath
+    });
+    const payload = await this.sendRequest({
+      requestId,
+      message,
+      timeout: 15e3,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "delete_session_image_response") return null;
+        if (msg.payload.requestId !== requestId) return null;
+        return msg.payload;
+      }
+    });
+    if (!payload.ok) {
+      throw new Error(payload.error || "Failed to delete session image");
+    }
+  }
+  /**
+   * Fetch attachment bytes by id from the daemon. The daemon is the canonical
+   * source for image and file bytes — every paired client (Electron after
+   * Cmd-R, phone, web) hits this RPC to render thumbnails and previews.
+   *
+   * `relativePath` comes from the user_message timeline echo's `daemonRef`.
+   * Returns base64-encoded bytes plus mime/size.
+   */
+  async fetchAttachmentBytes(input) {
+    const requestId = this.createRequestId();
+    const message = SessionInboundMessageSchema.parse({
+      type: "fetch_attachment_bytes_request",
+      requestId,
+      agentId: input.agentId,
+      kind: input.kind,
+      attachmentId: input.attachmentId,
+      relativePath: input.relativePath
+    });
+    const payload = await this.sendRequest({
+      requestId,
+      message,
+      // Image bytes can be a couple MB; allow more time than a typical RPC.
+      timeout: 3e4,
+      options: { skipQueue: true },
+      select: (msg) => {
+        if (msg.type !== "fetch_attachment_bytes_response") return null;
+        if (msg.payload.requestId !== requestId) return null;
+        return msg.payload;
+      }
+    });
+    if (!payload.ok) {
+      throw new Error(payload.error || "Failed to fetch attachment bytes");
+    }
+    return {
+      data: payload.data,
+      mimeType: payload.mimeType,
+      byteSize: payload.byteSize,
+      ...payload.fileName !== void 0 ? { fileName: payload.fileName } : {}
+    };
+  }
   async cancelAgent(agentId) {
     const requestId = this.createRequestId();
     const message = SessionInboundMessageSchema.parse({
@@ -45867,13 +47460,13 @@ var DaemonClient = class {
   // ============================================================================
   // File Explorer
   // ============================================================================
-  async exploreFileSystem(cwd, path24, mode = "list", requestId) {
+  async exploreFileSystem(cwd, path26, mode = "list", requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_explorer_request",
         cwd,
-        path: path24,
+        path: path26,
         mode
       },
       responseType: "file_explorer_response",
@@ -45885,13 +47478,13 @@ var DaemonClient = class {
    * allowlists extensions (currently `.md` only) — callers don't need to
    * re-check. Used by the plan-todos UI to rewrite plan-file frontmatter.
    */
-  async writeFile(cwd, path24, content, requestId) {
+  async writeFile(cwd, path26, content, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_write_request",
         cwd,
-        path: path24,
+        path: path26,
         content
       },
       responseType: "file_write_response",
@@ -45904,42 +47497,42 @@ var DaemonClient = class {
    * action is the only consumer). Returns the daemon's structured response
    * so callers can surface the error in the UI.
    */
-  async deleteFile(cwd, path24, requestId) {
+  async deleteFile(cwd, path26, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_delete_request",
         cwd,
-        path: path24
+        path: path26
       },
       responseType: "file_delete_response",
       timeout: 1e4
     });
   }
-  async requestDownloadToken(cwd, path24, requestId) {
+  async requestDownloadToken(cwd, path26, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
         type: "file_download_token_request",
         cwd,
-        path: path24
+        path: path26
       },
       responseType: "file_download_token_response",
       timeout: 1e4
     });
   }
-  async explorerDeleteEntry(cwd, path24, requestId) {
+  async explorerDeleteEntry(cwd, path26, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
-      message: { type: "file_explorer_delete_request", cwd, path: path24 },
+      message: { type: "file_explorer_delete_request", cwd, path: path26 },
       responseType: "file_explorer_delete_response",
       timeout: 1e4
     });
   }
-  async explorerMkdir(cwd, path24, requestId) {
+  async explorerMkdir(cwd, path26, requestId) {
     return this.sendCorrelatedSessionRequest({
       requestId,
-      message: { type: "file_mkdir_request", cwd, path: path24 },
+      message: { type: "file_mkdir_request", cwd, path: path26 },
       responseType: "file_mkdir_response",
       timeout: 1e4
     });
@@ -47329,16 +48922,16 @@ function resolveAgentConfig(options) {
 }
 
 // ../cli/src/utils/client.ts
-import path18 from "node:path";
+import path20 from "node:path";
 import WebSocket3 from "ws";
 
 // ../cli/src/utils/client-id.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { dirname as dirname5, join as join12 } from "node:path";
 import { homedir as homedir6 } from "node:os";
-var CLIENT_SESSION_KEY_FILE = join10(
-  process.env.APPOSTLE_HOME ?? join10(homedir6(), ".appostle"),
+var CLIENT_SESSION_KEY_FILE = join12(
+  process.env.APPOSTLE_HOME ?? join12(homedir6(), ".appostle"),
   "cli-client-id"
 );
 var cachedClientId = null;
@@ -47347,7 +48940,7 @@ function normalizeClientId2(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function generateClientId() {
-  return `cid_${randomUUID5().replace(/-/g, "")}`;
+  return `cid_${randomUUID6().replace(/-/g, "")}`;
 }
 async function getOrCreateCliClientId() {
   if (cachedClientId) {
@@ -47405,7 +48998,7 @@ function isTcpDaemonHost(host) {
   return host !== null && !isIpcDaemonHost(host);
 }
 function readPidSocketTarget(appostleHome) {
-  const pidPath = path18.join(appostleHome, PID_FILENAME);
+  const pidPath = path20.join(appostleHome, PID_FILENAME);
   if (!existsSync10(pidPath)) {
     return null;
   }
@@ -47874,12 +49467,12 @@ function relativeTime(date) {
   if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
   return `${Math.floor(seconds / 86400)} days ago`;
 }
-function shortenPath(path24) {
+function shortenPath(path26) {
   const home = process.env.HOME;
-  if (home && path24.startsWith(home)) {
-    return "~" + path24.slice(home.length);
+  if (home && path26.startsWith(home)) {
+    return "~" + path26.slice(home.length);
   }
-  return path24;
+  return path26;
 }
 function normalizeModelId(modelId) {
   if (typeof modelId !== "string") return null;
@@ -48722,7 +50315,7 @@ async function runStopCommand(id, options, _command) {
 
 // ../cli/src/commands/agent/send.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { extname as extname3, resolve as resolve11 } from "node:path";
+import { extname as extname4, resolve as resolve11 } from "node:path";
 var agentSendSchema = {
   idField: "agentId",
   columns: [
@@ -48736,10 +50329,10 @@ function addSendOptions(cmd) {
 }
 async function readImageFiles(imagePaths) {
   const images = [];
-  for (const path24 of imagePaths) {
+  for (const path26 of imagePaths) {
     try {
-      const buffer = await readFile5(path24);
-      const ext = extname3(path24).toLowerCase();
+      const buffer = await readFile5(path26);
+      const ext = extname4(path26).toLowerCase();
       let mimeType = "image/jpeg";
       switch (ext) {
         case ".png":
@@ -48767,7 +50360,7 @@ async function readImageFiles(imagePaths) {
       const message = err instanceof Error ? err.message : String(err);
       const error = {
         code: "IMAGE_READ_ERROR",
-        message: `Failed to read image file: ${path24}`,
+        message: `Failed to read image file: ${path26}`,
         details: message
       };
       throw error;
@@ -48940,12 +50533,12 @@ function createInspectSchema(agent) {
     serialize: (_item) => agent
   };
 }
-function shortenPath2(path24) {
+function shortenPath2(path26) {
   const home = process.env.HOME;
-  if (home && path24.startsWith(home)) {
-    return "~" + path24.slice(home.length);
+  if (home && path26.startsWith(home)) {
+    return "~" + path26.slice(home.length);
   }
-  return path24;
+  return path26;
 }
 function formatCost(costUsd) {
   if (costUsd === 0) return "$0.00";
@@ -49913,7 +51506,7 @@ import chalk3 from "chalk";
 import { spawn as spawn7, spawnSync } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import path19 from "node:path";
+import path21 from "node:path";
 import { fileURLToPath } from "node:url";
 var DETACHED_STARTUP_GRACE_MS = 1200;
 var PID_POLL_INTERVAL_MS = 100;
@@ -49964,7 +51557,7 @@ function buildChildEnv(options) {
 function resolveDaemonRunnerEntry() {
   try {
     const here = fileURLToPath(import.meta.url);
-    const sibling = path19.join(path19.dirname(here), "supervisor-entrypoint.js");
+    const sibling = path21.join(path21.dirname(here), "supervisor-entrypoint.js");
     if (existsSync11(sibling)) {
       return sibling;
     }
@@ -49978,23 +51571,23 @@ function resolveDaemonRunnerEntry() {
       "Unable to resolve @appostle/server package root for daemon runner (and no sibling supervisor-entrypoint.js was bundled)"
     );
   }
-  let currentDir = path19.dirname(serverExportPath);
+  let currentDir = path21.dirname(serverExportPath);
   while (true) {
-    const packageJsonPath = path19.join(currentDir, "package.json");
+    const packageJsonPath = path21.join(currentDir, "package.json");
     if (existsSync11(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
         if (packageJson.name === "@appostle/server") {
-          const distRunner = path19.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
+          const distRunner = path21.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
           if (existsSync11(distRunner)) {
             return distRunner;
           }
-          return path19.join(currentDir, "scripts", "supervisor-entrypoint.ts");
+          return path21.join(currentDir, "scripts", "supervisor-entrypoint.ts");
         }
       } catch {
       }
     }
-    const parentDir = path19.dirname(currentDir);
+    const parentDir = path21.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -50003,7 +51596,7 @@ function resolveDaemonRunnerEntry() {
   throw new Error("Unable to resolve @appostle/server package root for daemon runner");
 }
 function pidFilePath(appostleHome) {
-  return path19.join(appostleHome, DAEMON_PID_FILENAME);
+  return path21.join(appostleHome, DAEMON_PID_FILENAME);
 }
 function readPidFile(pidPath) {
   try {
@@ -50145,7 +51738,7 @@ function resolveLocalDaemonState(options = {}) {
   const home = resolveAppostleHome(env);
   const config = loadConfig(home, { env });
   const pidPath = pidFilePath(home);
-  const logPath = path19.join(home, DAEMON_LOG_FILENAME);
+  const logPath = path21.join(home, DAEMON_LOG_FILENAME);
   const pidInfo = existsSync11(pidPath) ? readPidFile(pidPath) : null;
   const running = pidInfo ? isProcessRunning(pidInfo.pid) : false;
   const listen = pidInfo?.listen ?? config.listen;
@@ -50160,7 +51753,7 @@ function resolveLocalDaemonState(options = {}) {
   };
 }
 function tailDaemonLog(home, lines = 30) {
-  const logPath = path19.join(resolveLocalAppostleHome(home), DAEMON_LOG_FILENAME);
+  const logPath = path21.join(resolveLocalAppostleHome(home), DAEMON_LOG_FILENAME);
   return tailFile(logPath, lines);
 }
 async function startLocalDaemonDetached(options) {
@@ -50169,7 +51762,7 @@ async function startLocalDaemonDetached(options) {
   }
   const childEnv = buildChildEnv(options);
   const appostleHome = resolveAppostleHome(childEnv);
-  const logPath = path19.join(appostleHome, DAEMON_LOG_FILENAME);
+  const logPath = path21.join(appostleHome, DAEMON_LOG_FILENAME);
   const daemonRunnerEntry = resolveDaemonRunnerEntry();
   const child = spawn7(
     process.execPath,
@@ -52894,22 +54487,22 @@ import { Command as Command13 } from "commander";
 
 // ../cli/src/commands/worktree/ls.ts
 import { homedir as homedir7 } from "node:os";
-import { basename as basename7, join as join11, sep as sep3 } from "node:path";
-function shortenPath3(path24) {
+import { basename as basename7, join as join13, sep as sep3 } from "node:path";
+function shortenPath3(path26) {
   const home = process.env.HOME;
-  if (home && path24.startsWith(home)) {
-    return "~" + path24.slice(home.length);
+  if (home && path26.startsWith(home)) {
+    return "~" + path26.slice(home.length);
   }
-  return path24;
+  return path26;
 }
-function extractWorktreeName(path24) {
-  return basename7(path24);
+function extractWorktreeName(path26) {
+  return basename7(path26);
 }
 function resolveAppostleHomePath() {
-  return process.env.APPOSTLE_HOME ?? join11(homedir7(), ".appostle");
+  return process.env.APPOSTLE_HOME ?? join13(homedir7(), ".appostle");
 }
 function resolveAppostleWorktreesDir() {
-  return join11(resolveAppostleHomePath(), "worktrees");
+  return join13(resolveAppostleHomePath(), "worktrees");
 }
 function isAgentInManagedWorktree(agentCwd) {
   const worktreesDir = resolveAppostleWorktreesDir();
@@ -52983,7 +54576,7 @@ async function runLsCommand7(options, _command) {
 }
 
 // ../cli/src/commands/worktree/archive.ts
-import path20 from "path";
+import path22 from "path";
 var archiveSchema2 = {
   idField: "name",
   columns: [
@@ -53027,7 +54620,7 @@ async function runArchiveCommand2(nameArg, options, _command) {
       throw error;
     }
     const worktree = listResponse.worktrees.find((wt) => {
-      const name = path20.basename(wt.worktreePath);
+      const name = path22.basename(wt.worktreePath);
       return name === nameArg || wt.branchName === nameArg;
     });
     if (!worktree) {
@@ -53049,7 +54642,7 @@ async function runArchiveCommand2(nameArg, options, _command) {
       };
       throw error;
     }
-    const worktreeName = path20.basename(worktree.worktreePath) || nameArg;
+    const worktreeName = path22.basename(worktree.worktreePath) || nameArg;
     return {
       type: "single",
       data: {
@@ -53090,7 +54683,7 @@ function createWorktreeCommand() {
 import { cancel, confirm, intro, isCancel, log, note, outro, spinner } from "@clack/prompts";
 import { Command as Command14, Option as Option4 } from "commander";
 import { writeFileSync as writeFileSync5 } from "node:fs";
-import path21 from "node:path";
+import path23 from "node:path";
 var DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1e3;
 var OnboardCancelledError = class extends Error {
 };
@@ -53133,7 +54726,7 @@ function toCliOverrides(options) {
   return cliOverrides;
 }
 function savePersistedConfig2(appostleHome, config) {
-  const configPath = path21.join(appostleHome, "config.json");
+  const configPath = path23.join(appostleHome, "config.json");
   writeFileSync5(configPath, `${JSON.stringify(config, null, 2)}
 `);
 }
@@ -53254,7 +54847,7 @@ ${recentLogs}` : null
   );
 }
 function printNextSteps(pairingUrl, appostleHome, richUi) {
-  const daemonLogPath = path21.join(appostleHome, "daemon.log");
+  const daemonLogPath = path23.join(appostleHome, "daemon.log");
   const nextStepsLines = [
     pairingUrl ? "1. Open Appostle and scan the QR code above, or paste the pairing link." : "1. Open Appostle and connect to your daemon.",
     "2. Web app: https://appostle.app",
@@ -53508,18 +55101,18 @@ function createCli() {
 // ../cli/src/classify.ts
 import { existsSync as existsSync12, statSync as statSync3 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import path22 from "node:path";
+import path24 from "node:path";
 function expandUserPath2(inputPath) {
   if (inputPath === "~") {
     return homedir8();
   }
   if (inputPath.startsWith("~/")) {
-    return path22.join(homedir8(), inputPath.slice(2));
+    return path24.join(homedir8(), inputPath.slice(2));
   }
   return inputPath;
 }
 function isExistingDirectory(input) {
-  const resolvedPath = path22.resolve(input.cwd, expandUserPath2(input.pathArg));
+  const resolvedPath = path24.resolve(input.cwd, expandUserPath2(input.pathArg));
   if (!existsSync12(resolvedPath)) {
     return false;
   }
@@ -53539,7 +55132,7 @@ function classifyInvocation(input) {
   if (isExistingDirectory({ pathArg: firstArg, cwd: input.cwd })) {
     return {
       kind: "open-project",
-      resolvedPath: path22.resolve(input.cwd, expandUserPath2(firstArg))
+      resolvedPath: path24.resolve(input.cwd, expandUserPath2(firstArg))
     };
   }
   return { kind: "cli", argv: input.argv };
@@ -53549,12 +55142,12 @@ function classifyInvocation(input) {
 import { existsSync as existsSync13 } from "node:fs";
 import { spawn as spawn8 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
-import path23 from "node:path";
+import path25 from "node:path";
 function findDesktopApp() {
   if (process.platform === "darwin") {
     const candidates = [
       "/Applications/Appostle.app",
-      path23.join(homedir9(), "Applications", "Appostle.app")
+      path25.join(homedir9(), "Applications", "Appostle.app")
     ];
     for (const candidate of candidates) {
       if (existsSync13(candidate)) {
@@ -53567,7 +55160,7 @@ function findDesktopApp() {
     const candidates = [
       "/usr/bin/Appostle",
       "/opt/Appostle/Appostle",
-      path23.join(homedir9(), "Applications", "Appostle.AppImage")
+      path25.join(homedir9(), "Applications", "Appostle.AppImage")
     ];
     for (const candidate of candidates) {
       if (existsSync13(candidate)) {
@@ -53581,7 +55174,7 @@ function findDesktopApp() {
     if (!localAppData) {
       return null;
     }
-    const candidate = path23.join(localAppData, "Programs", "Appostle", "Appostle.exe");
+    const candidate = path25.join(localAppData, "Programs", "Appostle", "Appostle.exe");
     return existsSync13(candidate) ? candidate : null;
   }
   return null;