appostle-installer 0.0.9 → 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 ({
@@ -3373,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"),
@@ -3653,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"),
@@ -3663,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({
@@ -3727,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({
@@ -3788,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({}),
@@ -4584,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,
@@ -4725,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(),
@@ -6269,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")
@@ -8671,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({
@@ -9707,6 +9910,9 @@ async function sendPromptToAgent(params) {
     messageId,
     runOptions,
     sessionMode,
+    userMessageImages,
+    userMessageFiles,
+    userMessageTextIsSynthesized,
     logger
   } = params;
   await unarchiveAgentState(agentStorage, agentManager, agentId);
@@ -9721,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");
@@ -9732,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";
@@ -9924,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 = [];
@@ -9975,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;
 }
@@ -10031,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]);
   }
@@ -11734,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"
@@ -11773,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
     });
@@ -11836,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;
 }
@@ -12435,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 {
@@ -14136,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";
@@ -15215,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;
@@ -15352,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) {
@@ -15531,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;
@@ -16098,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") {
@@ -16202,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;
@@ -16766,12 +17493,12 @@ 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;
@@ -17118,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 [];
     }
@@ -17340,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") {
@@ -17438,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 };
@@ -17680,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);
   }
@@ -17931,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;
@@ -18082,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) {
@@ -18129,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",
@@ -18140,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",
@@ -18899,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;
       }
@@ -18920,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;
@@ -19008,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) {
     }
   }
@@ -19054,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));
@@ -19518,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";
     }
@@ -19529,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;
   }
@@ -19719,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);
@@ -19739,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 });
@@ -19914,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
@@ -20376,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;
@@ -20453,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 } : {}
     };
@@ -20603,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)
   };
@@ -20630,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;
       }
@@ -20797,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 }];
@@ -20806,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-");
@@ -21171,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 [];
@@ -21224,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) {
@@ -21380,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;
@@ -21398,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;
@@ -21439,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 = [];
@@ -21519,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 [];
   }
@@ -21538,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;
     }
@@ -21558,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", {
@@ -21573,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;
     }
@@ -21589,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;
       }
@@ -22162,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;
     }
@@ -22901,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) {
@@ -23187,7 +23969,7 @@ var CodexAppServerAgentSession = class {
     };
   }
   emitSyntheticPlanApprovalRequest(planText) {
-    const requestId = `permission-${randomUUID2()}`;
+    const requestId = `permission-${randomUUID3()}`;
     const request = {
       id: requestId,
       provider: CODEX_PROVIDER,
@@ -23344,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);
     }
@@ -24577,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,
@@ -24876,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() {
@@ -25103,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);
@@ -25405,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);
@@ -25446,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 };
     }
@@ -25456,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])
     );
@@ -28515,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,
@@ -29288,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;
@@ -29523,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 {
@@ -29531,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) {
@@ -29924,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 };
     }
@@ -29943,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 };
     }
@@ -30830,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";
@@ -30878,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({
@@ -30920,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",
@@ -30940,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,
@@ -30962,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,
@@ -30998,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);
@@ -31028,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;
@@ -31061,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 }),
@@ -31075,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;
@@ -31105,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",
@@ -31219,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";
@@ -31255,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()) {
@@ -31286,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()) {
@@ -31309,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()) {
@@ -31327,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);
@@ -31335,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;
@@ -31343,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()) {
@@ -31393,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()) {
@@ -31432,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;
     }
   }
@@ -31609,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 [];
   }
@@ -31620,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);
@@ -31638,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);
@@ -31660,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;
@@ -31668,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 "";
@@ -31684,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") {
@@ -31699,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;
@@ -31713,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) {
@@ -31743,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)) {
@@ -31751,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)}`
@@ -31764,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;
@@ -31855,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 [];
@@ -31920,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 [];
@@ -32166,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, "/");
@@ -32190,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;
     }
@@ -32231,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;
     }
@@ -32258,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;
@@ -32285,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,
@@ -32322,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,
@@ -32345,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);
@@ -32356,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;
     }
@@ -32443,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;
@@ -32454,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;
@@ -32462,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,
@@ -32473,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)}`
     );
@@ -32486,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) {
@@ -32619,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();
@@ -32631,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;
     }
   }
@@ -32834,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 [];
   }
@@ -32844,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 = {
@@ -32888,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) => {
@@ -32934,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") {
@@ -32949,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) {
@@ -32970,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)) {
@@ -32978,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)}`
@@ -32991,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;
@@ -33017,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;
@@ -33045,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 {
     }
@@ -33056,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;
     }
   }
@@ -33296,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 [];
   }
@@ -33306,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 {
@@ -33350,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") {
@@ -33363,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) {
@@ -33408,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("..")) {
@@ -33416,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
@@ -33447,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;
@@ -33465,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)) {
@@ -33481,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)}`
@@ -33494,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";
@@ -33523,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();
@@ -33645,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));
@@ -33742,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("{}");
@@ -33824,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("{}");
     }
   }
@@ -33837,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");
@@ -33857,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);
@@ -34825,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);
@@ -35002,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;
@@ -35113,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 = [];
@@ -35130,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.
@@ -35600,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;
@@ -36870,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 };
@@ -36914,6 +37856,7 @@ var Session = class _Session {
       outputSchema,
       git,
       images,
+      files,
       attachments,
       labels
     } = msg;
@@ -36954,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,
@@ -36970,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);
@@ -38387,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",
@@ -39441,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
       });
@@ -40878,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) {
@@ -40949,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) {
@@ -43272,16 +44530,16 @@ function isRelayClientWebSocketUrl(url) {
 }
 
 // ../server/src/server/config.ts
-import path17 from "node:path";
+import path19 from "node:path";
 import { z as z47 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
 import { z as z46 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
-import path16 from "node:path";
+import path18 from "node:path";
 import { z as z44 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path16.join("models", "local-speech");
+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();
@@ -43308,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,
@@ -43564,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,
@@ -44782,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",
@@ -44887,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 } : {},
@@ -45112,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({
@@ -45136,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({
@@ -46049,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",
@@ -46067,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",
@@ -46086,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
     });
@@ -47511,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;
@@ -47529,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) {
@@ -47587,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;
   }
@@ -48056,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;
@@ -48904,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: [
@@ -48918,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":
@@ -48949,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;
@@ -49122,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";
@@ -50095,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;
@@ -50146,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;
     }
@@ -50160,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;
     }
@@ -50185,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 {
@@ -50327,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;
@@ -50342,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) {
@@ -50351,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,
@@ -53076,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();
@@ -53165,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: [
@@ -53209,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) {
@@ -53231,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: {
@@ -53272,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 {
 };
@@ -53315,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)}
 `);
 }
@@ -53436,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",
@@ -53690,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;
   }
@@ -53721,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 };
@@ -53731,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)) {
@@ -53749,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)) {
@@ -53763,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;