appostle-installer 0.0.13 → 0.0.14

package/dist/worker.js

@@ -16,10 +16,10 @@ __export(rightfont_service_exports, {
   isRightFontLibrary: () => isRightFontLibrary,
   readRightFontLibrary: () => readRightFontLibrary
 });
-import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync6 } from "node:fs";
 import { join as join12 } from "node:path";
 function isRightFontLibrary(libraryPath) {
-  return libraryPath.endsWith(".rightfontlibrary") && existsSync10(join12(libraryPath, "fonts")) && existsSync10(join12(libraryPath, "metadata"));
+  return libraryPath.endsWith(".rightfontlibrary") && existsSync11(join12(libraryPath, "fonts")) && existsSync11(join12(libraryPath, "metadata"));
 }
 function readRightFontLibrary(libraryPath) {
   if (!isRightFontLibrary(libraryPath)) {
@@ -30,7 +30,7 @@ function readRightFontLibrary(libraryPath) {
   const metadataListsDir = join12(libraryPath, "metadata", "fontlists");
   const familyMap = /* @__PURE__ */ new Map();
   let totalFonts = 0;
-  if (existsSync10(metadataFontsDir)) {
+  if (existsSync11(metadataFontsDir)) {
     const files = readdirSync(metadataFontsDir).filter((f) => f.endsWith(".rightfontmetadata"));
     for (const file of files) {
       try {
@@ -70,7 +70,7 @@ function readRightFontLibrary(libraryPath) {
     fam.fonts.sort((a, b) => a.weight - b.weight || a.style.localeCompare(b.style));
   }
   const collections = [];
-  if (existsSync10(metadataListsDir)) {
+  if (existsSync11(metadataListsDir)) {
     const files = readdirSync(metadataListsDir).filter((f) => f.endsWith(".rightfontmetadata"));
     for (const file of files) {
       try {
@@ -255,11 +255,11 @@ import { fileURLToPath as fileURLToPath7 } from "node:url";
 // ../server/src/server/bootstrap.ts
 import express from "express";
 import { createServer as createHTTPServer } from "http";
-import { createReadStream, unlinkSync, existsSync as existsSync19 } from "fs";
+import { createReadStream, unlinkSync, existsSync as existsSync20 } from "fs";
 import { stat as stat9 } from "fs/promises";
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { hostname as getHostname2 } from "node:os";
-import path33 from "node:path";
+import path34 from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
@@ -712,18 +712,18 @@ function resolveNodePtyPackageRoot() {
     return null;
   }
 }
-function ensureExecutableBit(path37) {
-  if (!existsSync2(path37)) {
+function ensureExecutableBit(path38) {
+  if (!existsSync2(path38)) {
     return;
   }
-  const stat10 = statSync(path37);
+  const stat10 = statSync(path38);
   if (!stat10.isFile()) {
     return;
   }
   if ((stat10.mode & 73) === 73) {
     return;
   }
-  chmodSync(path37, stat10.mode | 73);
+  chmodSync(path38, stat10.mode | 73);
 }
 function ensureNodePtySpawnHelperExecutableForCurrentPlatform(options = {}) {
   const platform = options.platform ?? process.platform;
@@ -1341,11 +1341,11 @@ function parseGitRevParsePath(stdout) {
   if (lines.length !== 1) {
     return null;
   }
-  const path37 = lines[0]?.trim() ?? "";
-  if (!path37 || path37.startsWith("--")) {
+  const path38 = lines[0]?.trim() ?? "";
+  if (!path38 || path38.startsWith("--")) {
     return null;
   }
-  return path37;
+  return path38;
 }
 function resolveGitRevParsePath(cwd, stdout) {
   const parsed = parseGitRevParsePath(stdout);
@@ -2118,9 +2118,9 @@ async function deleteAppostleWorktree({
     }
   }
 }
-async function pathExists(path37) {
+async function pathExists(path38) {
   try {
-    await stat(path37);
+    await stat(path38);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -2129,8 +2129,8 @@ async function pathExists(path37) {
     throw error;
   }
 }
-async function removeDirectoryWithRetries(path37) {
-  if (!await pathExists(path37)) {
+async function removeDirectoryWithRetries(path38) {
+  if (!await pathExists(path38)) {
     return;
   }
   const delaysMs = [0, 100, 300, 700, 1500];
@@ -2140,17 +2140,17 @@ async function removeDirectoryWithRetries(path37) {
       await new Promise((resolve15) => setTimeout(resolve15, delay));
     }
     try {
-      await rm(path37, { recursive: true, force: true });
-      if (!await pathExists(path37)) {
+      await rm(path38, { recursive: true, force: true });
+      if (!await pathExists(path38)) {
         return;
       }
-      lastError = new Error(`Directory still present after rm: ${path37}`);
+      lastError = new Error(`Directory still present after rm: ${path38}`);
     } catch (error) {
       lastError = error;
     }
   }
-  if (await pathExists(path37)) {
-    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path37}`);
+  if (await pathExists(path38)) {
+    throw lastError instanceof Error ? lastError : new Error(`Failed to remove worktree directory: ${path38}`);
   }
 }
 var createWorktree = async ({
@@ -5836,6 +5836,50 @@ var LinkAccountResponseMessageSchema = z11.object({
     })
   ])
 });
+var ClaudeProfileLoginRequestMessageSchema = z11.object({
+  type: z11.literal("claude_profile_login_request"),
+  requestId: z11.string(),
+  /** Username for the profile dir (~/.claude-{username}/). */
+  username: z11.string().min(1)
+});
+var ClaudeProfileLoginUrlMessageSchema = z11.object({
+  type: z11.literal("claude_profile_login_url"),
+  requestId: z11.string(),
+  url: z11.string().min(1)
+});
+var ClaudeProfileLoginCallbackMessageSchema = z11.object({
+  type: z11.literal("claude_profile_login_callback"),
+  requestId: z11.string(),
+  callbackToken: z11.string().min(1)
+});
+var ClaudeProfileLoginResultMessageSchema = z11.object({
+  type: z11.literal("claude_profile_login_result"),
+  requestId: z11.string(),
+  ok: z11.boolean(),
+  error: z11.string().optional()
+});
+var ClaudeProfileRemoveRequestMessageSchema = z11.object({
+  type: z11.literal("claude_profile_remove_request"),
+  requestId: z11.string(),
+  username: z11.string().min(1)
+});
+var ClaudeProfileRemoveResponseMessageSchema = z11.object({
+  type: z11.literal("claude_profile_remove_response"),
+  requestId: z11.string(),
+  ok: z11.boolean(),
+  error: z11.string().optional()
+});
+var ClaudeProfileStatusRequestMessageSchema = z11.object({
+  type: z11.literal("claude_profile_status_request"),
+  requestId: z11.string(),
+  username: z11.string().min(1)
+});
+var ClaudeProfileStatusResponseMessageSchema = z11.object({
+  type: z11.literal("claude_profile_status_response"),
+  requestId: z11.string(),
+  hasProfile: z11.boolean(),
+  isAuthenticated: z11.boolean()
+});
 var ListSessionUploadsRequestSchema = z11.object({
   type: z11.literal("list_session_uploads_request"),
   requestId: z11.string(),
@@ -5966,6 +6010,10 @@ var SessionInboundMessageSchema = z11.discriminatedUnion("type", [
   AbortRequestMessageSchema,
   AudioPlayedMessageSchema,
   LinkAccountRequestMessageSchema,
+  ClaudeProfileLoginRequestMessageSchema,
+  ClaudeProfileLoginCallbackMessageSchema,
+  ClaudeProfileStatusRequestMessageSchema,
+  ClaudeProfileRemoveRequestMessageSchema,
   FetchAgentsRequestMessageSchema,
   FetchWorkspacesRequestMessageSchema,
   FetchAgentRequestMessageSchema,
@@ -7691,6 +7739,10 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   GoogleFontsDownloadResponseSchema,
   GetVapidPublicKeyResponseSchema,
   LinkAccountResponseMessageSchema,
+  ClaudeProfileLoginUrlMessageSchema,
+  ClaudeProfileLoginResultMessageSchema,
+  ClaudeProfileStatusResponseMessageSchema,
+  ClaudeProfileRemoveResponseMessageSchema,
   ListSessionUploadsResponseSchema,
   DeleteSessionUploadResponseSchema,
   ListSessionImagesResponseSchema,
@@ -7712,7 +7764,11 @@ var WSHelloMessageSchema = z11.object({
   capabilities: z11.object({
     voice: z11.boolean().optional(),
     pushNotifications: z11.boolean().optional()
-  }).passthrough().optional()
+  }).passthrough().optional(),
+  /** Auth-server userId of the connecting user. Used for per-user Claude profile selection. */
+  userId: z11.string().optional(),
+  /** Display name of the connecting user (for profile dir naming). */
+  username: z11.string().optional()
 });
 var WSRecordingStateMessageSchema = z11.object({
   type: z11.literal("recording_state"),
@@ -10229,14 +10285,14 @@ var DictationStreamManager = class {
       PCM_CHANNELS,
       PCM_BITS_PER_SAMPLE
     );
-    const path37 = await maybePersistDictationDebugAudio(
+    const path38 = await maybePersistDictationDebugAudio(
       wavBuffer,
       { sessionId: state.sessionId, dictationId: state.dictationId, format: "audio/wav" },
       this.logger,
       state.debugChunkWriter?.folder
     );
-    state.debugRecordingPath = path37;
-    return path37;
+    state.debugRecordingPath = path38;
+    return path38;
   }
   failDictationStream(dictationId, error, retryable) {
     this.emit({
@@ -12247,14 +12303,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 path37 = "unknown";
+    let path38 = "unknown";
     const pathMatch = firstLine.match(/a\/(.*?) b\//);
     if (pathMatch) {
-      path37 = pathMatch[1];
+      path38 = pathMatch[1];
     } else {
       const newFileMatch = firstLine.match(/b\/(.+)$/);
       if (newFileMatch) {
-        path37 = newFileMatch[1];
+        path38 = newFileMatch[1];
       }
     }
     const hunks = [];
@@ -12298,7 +12354,7 @@ function parseDiff(diffText) {
     if (currentHunk) {
       hunks.push(currentHunk);
     }
-    files.push({ path: path37, isNew, isDeleted, additions, deletions, hunks });
+    files.push({ path: path38, isNew, isDeleted, additions, deletions, hunks });
   }
   return files;
 }
@@ -12354,9 +12410,9 @@ function buildTokenLookup(lineMap, highlighted) {
   }
   return lookup;
 }
-function buildFullFileTokenLookup(fileContent, path37) {
+function buildFullFileTokenLookup(fileContent, path38) {
   const lookup = /* @__PURE__ */ new Map();
-  const highlighted = highlightCode(fileContent, path37);
+  const highlighted = highlightCode(fileContent, path38);
   for (let i = 0; i < highlighted.length; i++) {
     lookup.set(i + 1, highlighted[i]);
   }
@@ -14061,11 +14117,11 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
       }
       continue;
     }
-    const path37 = tabParts[1];
-    if (!path37) continue;
+    const path38 = tabParts[1];
+    if (!path38) continue;
     const code = rawStatus[0];
     changes.push({
-      path: path37,
+      path: path38,
       status: rawStatus,
       isNew: code === "A",
       isDeleted: code === "D"
@@ -14100,9 +14156,9 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
   }
   return Array.from(byPath.values());
 }
-async function readGitFileContentAtRef(cwd, ref, path37) {
+async function readGitFileContentAtRef(cwd, ref, path38) {
   try {
-    const { stdout } = await runGitCommand(["show", `${ref}:${path37}`], {
+    const { stdout } = await runGitCommand(["show", `${ref}:${path38}`], {
       cwd,
       env: READ_ONLY_GIT_ENV2
     });
@@ -14163,21 +14219,21 @@ async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
     const additionsField = parts[0] ?? "";
     const deletionsField = parts[1] ?? "";
     const rawPath = parts.slice(2).join("	");
-    const path37 = normalizeNumstatPath(rawPath);
-    if (!path37) {
+    const path38 = normalizeNumstatPath(rawPath);
+    if (!path38) {
       continue;
     }
     if (additionsField === "-" || deletionsField === "-") {
-      stats.set(path37, { additions: 0, deletions: 0, isBinary: true });
+      stats.set(path38, { 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(path37, null);
+      stats.set(path38, null);
       continue;
     }
-    stats.set(path37, { additions, deletions, isBinary: false });
+    stats.set(path38, { additions, deletions, isBinary: false });
   }
   return stats;
 }
@@ -14869,10 +14925,10 @@ async function listUncommittedFiles(cwd) {
         if (dest) results.push({ path: dest, changeType: code });
         continue;
       }
-      const path37 = parts[1];
-      if (!path37) continue;
+      const path38 = parts[1];
+      if (!path38) continue;
       if (code === "A" || code === "M" || code === "D") {
-        results.push({ path: path37, changeType: code });
+        results.push({ path: path38, changeType: code });
       }
     }
   } catch {
@@ -18915,12 +18971,12 @@ function extractPlanNameFromFrontmatter(content) {
   return null;
 }
 function resolvePlanFilename(options) {
-  const { originalPath, newSlug, existsSync: existsSync22 } = options;
+  const { originalPath, newSlug, existsSync: existsSync23 } = options;
   const dir = path8.dirname(originalPath);
   const base = `${newSlug}.md`;
   let candidate = path8.join(dir, base);
   let counter = 2;
-  while (candidate !== originalPath && existsSync22(candidate)) {
+  while (candidate !== originalPath && existsSync23(candidate)) {
     candidate = path8.join(dir, `${newSlug}-${counter}.md`);
     counter += 1;
   }
@@ -23157,14 +23213,14 @@ function codexApplyPatchToUnifiedDiff(text) {
   for (const line of lines) {
     const directive = parseCodexApplyPatchDirective(line);
     if (directive) {
-      const path37 = normalizeDiffHeaderPath(directive.path);
-      if (path37.length > 0) {
+      const path38 = normalizeDiffHeaderPath(directive.path);
+      if (path38.length > 0) {
         if (output.length > 0 && output[output.length - 1] !== "") {
           output.push("");
         }
-        const left = directive.kind === "add" ? "/dev/null" : `a/${path37}`;
-        const right = directive.kind === "delete" ? "/dev/null" : `b/${path37}`;
-        output.push(`diff --git a/${path37} b/${path37}`);
+        const left = directive.kind === "add" ? "/dev/null" : `a/${path38}`;
+        const right = directive.kind === "delete" ? "/dev/null" : `b/${path38}`;
+        output.push(`diff --git a/${path38} b/${path38}`);
         output.push(`--- ${left}`);
         output.push(`+++ ${right}`);
         sawDiffContent = true;
@@ -23234,9 +23290,9 @@ function asEditTextFields(text) {
 function normalizeRolloutEditInput(input) {
   if (typeof input === "string") {
     const textFields2 = asEditTextFields(input);
-    const path37 = extractPatchPrimaryFilePath(input);
+    const path38 = extractPatchPrimaryFilePath(input);
     return {
-      ...path37 ? { path: path37 } : {},
+      ...path38 ? { path: path38 } : {},
       ...textFields2.unifiedDiff ? { patch: textFields2.unifiedDiff } : {},
       ...textFields2.newString ? { content: textFields2.newString } : {}
     };
@@ -23384,12 +23440,12 @@ function parseFileChangeDiff(entry) {
   ]);
 }
 function toFileChangeEntry(entry, options, fallbackPath) {
-  const path37 = parseFileChangePath(entry, options, fallbackPath);
-  if (!path37) {
+  const path38 = parseFileChangePath(entry, options, fallbackPath);
+  if (!path38) {
     return null;
   }
   return {
-    path: path37,
+    path: path38,
     kind: parseFileChangeKind(entry),
     diff: parseFileChangeDiff(entry)
   };
@@ -23411,12 +23467,12 @@ function parseFileChangeEntries(changes, options) {
   if (singleEntry) {
     return [singleEntry];
   }
-  return Object.entries(changes).map(([path37, value]) => {
+  return Object.entries(changes).map(([path38, value]) => {
     if (isRecord2(value)) {
-      return toFileChangeEntry(value, options, path37);
+      return toFileChangeEntry(value, options, path38);
     }
     if (typeof value === "string") {
-      const normalizedPath = normalizeCodexFilePath(path37.trim(), options?.cwd);
+      const normalizedPath = normalizeCodexFilePath(path38.trim(), options?.cwd);
       if (!normalizedPath) {
         return null;
       }
@@ -24161,16 +24217,16 @@ function isObjectSchemaNode(schema) {
   const type = schema.type;
   return isSchemaRecord(schema.properties) || type === "object" || Array.isArray(type) && type.includes("object");
 }
-function normalizeCodexOutputSchemaNode(schema, path37) {
+function normalizeCodexOutputSchemaNode(schema, path38) {
   if (Array.isArray(schema)) {
-    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path37}[${index}]`));
+    return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path38}[${index}]`));
   }
   if (!isSchemaRecord(schema)) {
     return schema;
   }
   const normalized = {};
   for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path37}.${key}`);
+    normalized[key] = normalizeCodexOutputSchemaNode(value, `${path38}.${key}`);
   }
   if (!isObjectSchemaNode(normalized)) {
     return normalized;
@@ -24179,7 +24235,7 @@ function normalizeCodexOutputSchemaNode(schema, path37) {
     normalized.additionalProperties = false;
   } else if (normalized.additionalProperties !== false) {
     throw new Error(
-      `Codex structured outputs require ${path37} to set additionalProperties to false for object schemas.`
+      `Codex structured outputs require ${path38} to set additionalProperties to false for object schemas.`
     );
   }
   const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
@@ -24943,8 +24999,8 @@ function parseCodexPatchChanges(changes) {
       }
     ];
   }
-  return Object.entries(recordChanges).map(([path37, value]) => {
-    const normalizedPath = path37.trim();
+  return Object.entries(recordChanges).map(([path38, value]) => {
+    const normalizedPath = path38.trim();
     if (!normalizedPath) {
       return null;
     }
@@ -32717,8 +32773,8 @@ function buildZodValidator(schema, schemaName) {
         return { ok: true, value: result.data };
       }
       const errors = result.error.issues.map((issue) => {
-        const path37 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `${path37}: ${issue.message}`;
+        const path38 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path38}: ${issue.message}`;
       });
       return { ok: false, errors };
     }
@@ -32736,9 +32792,9 @@ function buildJsonSchemaValidator(schema) {
         return { ok: true, value };
       }
       const errors = (validate.errors ?? []).map((error) => {
-        const path37 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
+        const path38 = error.instancePath && error.instancePath.length > 0 ? error.instancePath : "(root)";
         const message = error.message ?? "is invalid";
-        return `${path37}: ${message}`;
+        return `${path38}: ${message}`;
       });
       return { ok: false, errors };
     }
@@ -34342,15 +34398,15 @@ async function getProjectIcon(projectDir) {
 
 // ../server/src/utils/path.ts
 import os5 from "os";
-function expandTilde(path37) {
-  if (path37.startsWith("~/")) {
+function expandTilde(path38) {
+  if (path38.startsWith("~/")) {
     const homeDir3 = process.env.HOME || os5.homedir();
-    return path37.replace("~", homeDir3);
+    return path38.replace("~", homeDir3);
   }
-  if (path37 === "~") {
+  if (path38 === "~") {
     return process.env.HOME || os5.homedir();
   }
-  return path37;
+  return path38;
 }
 
 // ../server/src/server/skills/scanner.ts
@@ -37280,6 +37336,45 @@ async function generateAndApplyArtDirection(options) {
   return { generatedCount: acceptedUpdates.size };
 }
 
+// ../server/src/server/claude-profile.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, symlinkSync, rmSync as rmSync2 } from "node:fs";
+import path22 from "node:path";
+import os8 from "node:os";
+var SHARED_ITEMS = ["settings.json", "hooks", "agents", "skills", "plugins", "keybindings.json"];
+function getClaudeProfileDir(username) {
+  return path22.join(os8.homedir(), `.claude-${username}`);
+}
+function ensureClaudeProfile(username, logger) {
+  const profileDir = getClaudeProfileDir(username);
+  const ownerDir = path22.join(os8.homedir(), ".claude");
+  if (!existsSync10(ownerDir)) {
+    throw new Error(`Owner claude config dir not found: ${ownerDir}`);
+  }
+  if (!existsSync10(profileDir)) {
+    mkdirSync5(profileDir, { recursive: true });
+    logger?.info({ profileDir, username }, "created claude profile directory");
+  }
+  for (const item of SHARED_ITEMS) {
+    const target = path22.join(ownerDir, item);
+    const link = path22.join(profileDir, item);
+    if (!existsSync10(target)) continue;
+    if (existsSync10(link)) continue;
+    symlinkSync(target, link);
+    logger?.info({ item, profileDir }, "symlinked shared config item");
+  }
+  return profileDir;
+}
+function hasClaudeAuth(username) {
+  const profileDir = getClaudeProfileDir(username);
+  return existsSync10(profileDir);
+}
+function removeClaudeProfile(username, logger) {
+  const profileDir = getClaudeProfileDir(username);
+  if (!existsSync10(profileDir)) return;
+  rmSync2(profileDir, { recursive: true, force: true });
+  logger?.info({ profileDir, username }, "removed claude profile directory");
+}
+
 // ../server/src/services/oauth-service.ts
 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";
@@ -37525,57 +37620,57 @@ async function fetchGitLabUsername(fetchImpl, accessToken) {
     return null;
   }
 }
-async function readCredential(path37, log) {
+async function readCredential(path38, log) {
   try {
-    const raw = await readFile3(path37, "utf8");
+    const raw = await readFile3(path38, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.gitlab ?? null;
   } catch (error) {
     if (isNotFound(error)) return null;
-    log.warn({ err: error, path: path37 }, "oauth.credentials.read_failed");
+    log.warn({ err: error, path: path38 }, "oauth.credentials.read_failed");
     return null;
   }
 }
-async function persistCredential(path37, credential, log) {
-  await mkdir4(dirname4(path37), { recursive: true });
+async function persistCredential(path38, credential, log) {
+  await mkdir4(dirname4(path38), { recursive: true });
   let current = {};
   try {
-    const raw = await readFile3(path37, "utf8");
+    const raw = await readFile3(path38, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (!isNotFound(error)) {
-      log.warn({ err: error, path: path37 }, "oauth.credentials.read_failed_overwriting");
+      log.warn({ err: error, path: path38 }, "oauth.credentials.read_failed_overwriting");
     }
   }
   const next = { ...current, gitlab: credential };
-  const tmpPath = `${path37}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path38}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(next, null, 2), { mode: 384 });
-  await rename(tmpPath, path37);
+  await rename(tmpPath, path38);
 }
-async function deleteCredential(path37, log) {
+async function deleteCredential(path38, log) {
   let current = {};
   try {
-    const raw = await readFile3(path37, "utf8");
+    const raw = await readFile3(path38, "utf8");
     current = JSON.parse(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path37 }, "oauth.credentials.delete_read_failed");
+    log.warn({ err: error, path: path38 }, "oauth.credentials.delete_read_failed");
     return;
   }
   delete current.gitlab;
   if (Object.keys(current).length === 0) {
     try {
-      await unlink(path37);
+      await unlink(path38);
     } catch (error) {
       if (!isNotFound(error)) {
-        log.warn({ err: error, path: path37 }, "oauth.credentials.unlink_failed");
+        log.warn({ err: error, path: path38 }, "oauth.credentials.unlink_failed");
       }
     }
     return;
   }
-  const tmpPath = `${path37}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path38}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, JSON.stringify(current, null, 2), { mode: 384 });
-  await rename(tmpPath, path37);
+  await rename(tmpPath, path38);
 }
 function defaultGlabConfigPath() {
   const home = homedir4();
@@ -37590,15 +37685,15 @@ function defaultGlabConfigPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
   return join11(xdg && xdg.length > 0 ? xdg : join11(home, ".config"), "glab-cli", "config.yml");
 }
-async function writeGlabConfig(path37, credential, log) {
-  await mkdir4(dirname4(path37), { recursive: true });
+async function writeGlabConfig(path38, credential, log) {
+  await mkdir4(dirname4(path38), { recursive: true });
   let doc;
   try {
-    const raw = await readFile3(path37, "utf8");
+    const raw = await readFile3(path38, "utf8");
     doc = YAML.parseDocument(raw);
     if (doc.errors.length > 0) {
       log.warn(
-        { errors: doc.errors.map((e) => e.message), path: path37 },
+        { errors: doc.errors.map((e) => e.message), path: path38 },
         "oauth.glab.parse_errors_replacing"
       );
       doc = YAML.parseDocument("{}");
@@ -37607,7 +37702,7 @@ async function writeGlabConfig(path37, credential, log) {
     if (isNotFound(error)) {
       doc = YAML.parseDocument("{}");
     } else {
-      log.warn({ err: error, path: path37 }, "oauth.glab.read_failed_replacing");
+      log.warn({ err: error, path: path38 }, "oauth.glab.read_failed_replacing");
       doc = YAML.parseDocument("{}");
     }
   }
@@ -37620,18 +37715,18 @@ async function writeGlabConfig(path37, credential, log) {
   if (credential.username) {
     hostEntry.set("user", credential.username);
   }
-  const tmpPath = `${path37}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path38}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path37);
+  await rename(tmpPath, path38);
 }
-async function removeGlabHost(path37, log) {
+async function removeGlabHost(path38, log) {
   let doc;
   try {
-    const raw = await readFile3(path37, "utf8");
+    const raw = await readFile3(path38, "utf8");
     doc = YAML.parseDocument(raw);
   } catch (error) {
     if (isNotFound(error)) return;
-    log.warn({ err: error, path: path37 }, "oauth.glab.remove_read_failed");
+    log.warn({ err: error, path: path38 }, "oauth.glab.remove_read_failed");
     return;
   }
   const hosts = doc.get("hosts");
@@ -37640,9 +37735,9 @@ async function removeGlabHost(path37, log) {
   if (hosts.items.length === 0) {
     doc.delete("hosts");
   }
-  const tmpPath = `${path37}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path38}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmpPath, doc.toString(), { mode: 384 });
-  await rename(tmpPath, path37);
+  await rename(tmpPath, path38);
 }
 function ensureMap(doc, key) {
   const existing = doc.get(key);
@@ -38768,6 +38863,8 @@ var Session = class _Session {
     this.nextTerminalSlot = 0;
     this.inflightRequests = 0;
     this.peakInflightRequests = 0;
+    /** In-progress `claude login` processes, keyed by requestId. */
+    this.pendingClaudeLogins = /* @__PURE__ */ new Map();
     this.checkoutDiffSubscriptions = /* @__PURE__ */ new Map();
     this.workspaceGitWatchTargets = /* @__PURE__ */ new Map();
     this.workspaceSetupSnapshots = /* @__PURE__ */ new Map();
@@ -38829,6 +38926,8 @@ var Session = class _Session {
     this.clientId = clientId;
     this.appVersion = appVersion ?? null;
     this.sessionId = uuidv47();
+    this.userId = options.userId ?? null;
+    this.username = options.username ?? null;
     this.onMessage = onMessage;
     this.onBinaryMessage = onBinaryMessage ?? null;
     this.onLifecycleIntent = onLifecycleIntent ?? null;
@@ -39448,6 +39547,18 @@ var Session = class _Session {
           case "link_account_request":
             await this.handleLinkAccountRequest(msg);
             break;
+          case "claude_profile_login_request":
+            await this.handleClaudeProfileLoginRequest(msg);
+            break;
+          case "claude_profile_login_callback":
+            await this.handleClaudeProfileLoginCallback(msg);
+            break;
+          case "claude_profile_status_request":
+            await this.handleClaudeProfileStatusRequest(msg);
+            break;
+          case "claude_profile_remove_request":
+            await this.handleClaudeProfileRemoveRequest(msg);
+            break;
           case "fetch_agents_request":
             await this.handleFetchAgents(msg);
             break;
@@ -40154,6 +40265,138 @@ var Session = class _Session {
       respond({ ok: false, error: message });
     }
   }
+  // ---------------------------------------------------------------------------
+  // Claude profile login — per-user subscription on shared hosts
+  // ---------------------------------------------------------------------------
+  async handleClaudeProfileLoginRequest(msg) {
+    const { requestId, username } = msg;
+    const log = this.sessionLogger.child({ handler: "claude_profile_login" });
+    try {
+      const profileDir = ensureClaudeProfile(username, log);
+      const child = spawnProcess("claude", ["auth", "login"], {
+        env: {
+          ...process.env,
+          CLAUDE_CONFIG_DIR: profileDir
+        },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.pendingClaudeLogins.set(requestId, { process: child, username });
+      let stdoutBuffer = "";
+      child.stdout?.on("data", (chunk) => {
+        stdoutBuffer += chunk.toString();
+        const urlMatch = stdoutBuffer.match(/(https?:\/\/[^\s]+)/);
+        if (urlMatch) {
+          this.emit({
+            type: "claude_profile_login_url",
+            requestId,
+            url: urlMatch[1]
+          });
+        }
+      });
+      child.stderr?.on("data", (chunk) => {
+        log.debug({ stderr: chunk.toString() }, "claude login stderr");
+      });
+      child.on("close", (code) => {
+        this.pendingClaudeLogins.delete(requestId);
+        if (code === 0) {
+          log.info({ username }, "claude profile login succeeded");
+          this.emit({
+            type: "claude_profile_login_result",
+            requestId,
+            ok: true
+          });
+        } else {
+          log.warn({ username, code }, "claude profile login failed");
+          this.emit({
+            type: "claude_profile_login_result",
+            requestId,
+            ok: false,
+            error: `claude login exited with code ${code}`
+          });
+        }
+      });
+      child.on("error", (err) => {
+        this.pendingClaudeLogins.delete(requestId);
+        log.error({ err }, "claude login process error");
+        this.emit({
+          type: "claude_profile_login_result",
+          requestId,
+          ok: false,
+          error: err.message
+        });
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "unknown_error";
+      log.error({ err }, "claude profile login request failed");
+      this.emit({
+        type: "claude_profile_login_result",
+        requestId,
+        ok: false,
+        error: message
+      });
+    }
+  }
+  async handleClaudeProfileLoginCallback(msg) {
+    const { requestId, callbackToken } = msg;
+    const pending = this.pendingClaudeLogins.get(requestId);
+    if (!pending) {
+      this.sessionLogger.warn({ requestId }, "claude_profile_login_callback: no pending login");
+      this.emit({
+        type: "claude_profile_login_result",
+        requestId,
+        ok: false,
+        error: "no_pending_login"
+      });
+      return;
+    }
+    try {
+      pending.process.stdin?.write(callbackToken + "\n");
+    } catch (err) {
+      this.sessionLogger.error({ err }, "failed to write callback token to claude login stdin");
+    }
+  }
+  async handleClaudeProfileStatusRequest(msg) {
+    const { requestId, username } = msg;
+    const profileExists = hasClaudeAuth(username);
+    let isAuthenticated = false;
+    if (profileExists) {
+      try {
+        const profileDir = ensureClaudeProfile(username);
+        const result = await execCommand("claude", ["auth", "status"], {
+          env: { ...process.env, CLAUDE_CONFIG_DIR: profileDir },
+          timeout: 5e3
+        });
+        isAuthenticated = !result.stdout.toLowerCase().includes("not logged in");
+      } catch {
+      }
+    }
+    this.emit({
+      type: "claude_profile_status_response",
+      requestId,
+      hasProfile: profileExists,
+      isAuthenticated
+    });
+  }
+  async handleClaudeProfileRemoveRequest(msg) {
+    const { requestId, username } = msg;
+    try {
+      removeClaudeProfile(username, this.sessionLogger);
+      this.emit({
+        type: "claude_profile_remove_response",
+        requestId,
+        ok: true
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "unknown_error";
+      this.sessionLogger.error({ err, username }, "claude profile remove failed");
+      this.emit({
+        type: "claude_profile_remove_response",
+        requestId,
+        ok: false,
+        error: message
+      });
+    }
+  }
   async handleRestartServerRequest(requestId, reason) {
     const payload = {
       status: "restart_requested",
@@ -40987,7 +41230,9 @@ var Session = class _Session {
         {
           labels,
           workspaceId: resolvedWorkspace.workspaceId,
-          initialPrompt: trimmedPrompt
+          initialPrompt: trimmedPrompt,
+          userId: this.userId ?? void 0,
+          username: this.username ?? void 0
         }
       );
       await this.forwardAgentUpdate(snapshot);
@@ -42455,7 +42700,7 @@ var Session = class _Session {
         homeDir: process.env.HOME ?? homedir5(),
         query: query2,
         limit
-      })).map((path37) => ({ path: path37, kind: "directory" }));
+      })).map((path38) => ({ path: path38, kind: "directory" }));
       const directories = entries.filter((entry) => entry.kind === "directory").map((entry) => entry.path);
       this.emit({
         type: "directory_suggestions_response",
@@ -47590,7 +47835,7 @@ function toErrorMessage(error) {
 }
 
 // ../server/src/server/push/token-store.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 var PushTokenStore = class {
   constructor(logger, filePath) {
@@ -47684,7 +47929,7 @@ var PushTokenStore = class {
   }
   loadFromDisk() {
     try {
-      if (!existsSync11(this.filePath)) {
+      if (!existsSync12(this.filePath)) {
         return;
       }
       const raw = readFileSync7(this.filePath, "utf-8");
@@ -47720,7 +47965,7 @@ var PushTokenStore = class {
   }
   persist() {
     try {
-      mkdirSync5(dirname5(this.filePath), { recursive: true });
+      mkdirSync6(dirname5(this.filePath), { recursive: true });
       const tmpPath = `${this.filePath}.tmp`;
       const payload = { entries: Array.from(this.entries.values()) };
       writeFileSync5(tmpPath, JSON.stringify(payload, null, 2) + "\n");
@@ -47800,7 +48045,7 @@ var PushService = class {
 };
 
 // ../server/src/server/push/web-push-store.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync6, chmodSync as chmodSync2 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync6, chmodSync as chmodSync2 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 import webpush from "web-push";
 var WebPushStore = class {
@@ -47906,7 +48151,7 @@ var WebPushStore = class {
   }
   loadOrCreateVapidKeys() {
     try {
-      if (existsSync12(this.vapidPath)) {
+      if (existsSync13(this.vapidPath)) {
         const raw = readFileSync8(this.vapidPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed.publicKey && parsed.privateKey) {
@@ -47918,7 +48163,7 @@ var WebPushStore = class {
     }
     const generated = webpush.generateVAPIDKeys();
     try {
-      mkdirSync6(dirname6(this.vapidPath), { recursive: true });
+      mkdirSync7(dirname6(this.vapidPath), { recursive: true });
       writeFileSync6(this.vapidPath, JSON.stringify(generated, null, 2) + "\n");
       if (process.platform !== "win32") {
         try {
@@ -47934,7 +48179,7 @@ var WebPushStore = class {
   }
   loadSubscriptions() {
     try {
-      if (!existsSync12(this.subsPath)) return;
+      if (!existsSync13(this.subsPath)) return;
       const raw = readFileSync8(this.subsPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.vapidKey && parsed.vapidKey !== this.vapid.publicKey) {
@@ -47975,7 +48220,7 @@ var WebPushStore = class {
   }
   persist() {
     try {
-      mkdirSync6(dirname6(this.subsPath), { recursive: true });
+      mkdirSync7(dirname6(this.subsPath), { recursive: true });
       const tmpPath = `${this.subsPath}.tmp`;
       const payload = {
         vapidKey: this.vapid.publicKey,
@@ -48705,6 +48950,8 @@ var VoiceAssistantWebSocketServer = class {
     const session = new Session({
       clientId,
       appVersion,
+      userId: params.userId,
+      username: params.username,
       onMessage: (msg) => {
         if (!connection) {
           return;
@@ -48782,7 +49029,9 @@ var VoiceAssistantWebSocketServer = class {
       appVersion,
       connectionLogger,
       sockets: /* @__PURE__ */ new Set([ws]),
-      externalDisconnectCleanupTimeout: null
+      externalDisconnectCleanupTimeout: null,
+      userId: params.userId ?? null,
+      username: params.username ?? null
     };
     return connection;
   }
@@ -48857,7 +49106,9 @@ var VoiceAssistantWebSocketServer = class {
       ws,
       clientId,
       appVersion: message.appVersion ?? null,
-      connectionLogger
+      connectionLogger,
+      userId: message.userId,
+      username: message.username
     });
     this.sessions.set(ws, connection);
     this.externalSessionsByKey.set(clientId, connection);
@@ -49560,7 +49811,7 @@ import { join as join17 } from "node:path";
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir6, rename as rename2, rm as rm2, stat as stat5 } from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { spawn as spawn7 } from "node:child_process";
@@ -49696,11 +49947,11 @@ function getSherpaOnnxModelSpec(id) {
 // ../server/src/server/speech/providers/local/sherpa/model-downloader.ts
 function getSherpaOnnxModelDir(modelsDir, modelId) {
   const spec = getSherpaOnnxModelSpec(modelId);
-  return path22.join(modelsDir, spec.extractedDir);
+  return path23.join(modelsDir, spec.extractedDir);
 }
 async function hasRequiredFiles(modelDir, requiredFiles) {
   for (const rel of requiredFiles) {
-    const abs = path22.join(modelDir, rel);
+    const abs = path23.join(modelDir, rel);
     try {
       const s = await stat5(abs);
       if (s.isDirectory()) {
@@ -49726,7 +49977,7 @@ async function downloadToFile(options) {
     throw new Error(`Failed to download ${url}: missing response body`);
   }
   const tmpPath = `${outputPath}.tmp-${Date.now()}`;
-  await mkdir6(path22.dirname(outputPath), { recursive: true });
+  await mkdir6(path23.dirname(outputPath), { recursive: true });
   const nodeStream = Readable2.fromWeb(res.body);
   try {
     await pipeline(nodeStream, createWriteStream(tmpPath));
@@ -49763,16 +50014,16 @@ async function ensureSherpaOnnxModel(options) {
     modelId: options.modelId
   });
   const spec = getSherpaOnnxModelSpec(options.modelId);
-  const modelDir = path22.join(options.modelsDir, spec.extractedDir);
+  const modelDir = path23.join(options.modelsDir, spec.extractedDir);
   if (await hasRequiredFiles(modelDir, spec.requiredFiles)) {
     return modelDir;
   }
   logger.info({ modelsDir: options.modelsDir }, "Starting model download");
   try {
     if (spec.archiveUrl) {
-      const downloadsDir = path22.join(options.modelsDir, ".downloads");
-      const archiveFilename = path22.basename(new URL(spec.archiveUrl).pathname);
-      const archivePath = path22.join(downloadsDir, archiveFilename);
+      const downloadsDir = path23.join(options.modelsDir, ".downloads");
+      const archiveFilename = path23.basename(new URL(spec.archiveUrl).pathname);
+      const archivePath = path23.join(downloadsDir, archiveFilename);
       if (!await isNonEmptyFile(archivePath)) {
         await downloadToFile({
           url: spec.archiveUrl,
@@ -49817,7 +50068,7 @@ async function ensureSherpaOnnxModel(options) {
     if (spec.downloadFiles && spec.downloadFiles.length > 0) {
       await mkdir6(modelDir, { recursive: true });
       for (const file of spec.downloadFiles) {
-        const dst = path22.join(modelDir, file.relPath);
+        const dst = path23.join(modelDir, file.relPath);
         if (await isNonEmptyFile(dst)) {
           continue;
         }
@@ -49876,17 +50127,17 @@ async function ensureLocalSpeechModels(options) {
 }
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-offline-recognizer.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.ts
 import { createRequire as createRequire4 } from "node:module";
-import path24 from "node:path";
-import { existsSync as existsSync13 } from "node:fs";
+import path25 from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
 import { spawnSync } from "node:child_process";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-runtime-env.ts
 import { createRequire as createRequire3 } from "node:module";
-import path23 from "node:path";
+import path24 from "node:path";
 function sherpaPlatformArch(platform = process.platform, arch = process.arch) {
   const normalizedPlatform = platform === "win32" ? "win" : platform;
   return `${normalizedPlatform}-${arch}`;
@@ -49907,11 +50158,11 @@ function sherpaLoaderEnvKey(platform = process.platform) {
   return null;
 }
 function prependEnvPath(existing, value) {
-  const parts = (existing ?? "").split(path23.delimiter).filter(Boolean);
+  const parts = (existing ?? "").split(path24.delimiter).filter(Boolean);
   if (parts.includes(value)) {
-    return parts.join(path23.delimiter);
+    return parts.join(path24.delimiter);
   }
-  return [value, ...parts].join(path23.delimiter);
+  return [value, ...parts].join(path24.delimiter);
 }
 function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch) {
   const key = sherpaLoaderEnvKey(platform);
@@ -49924,7 +50175,7 @@ function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch
     const pkgJson = require4.resolve(`${packageName}/package.json`);
     return {
       key,
-      libDir: path23.dirname(pkgJson),
+      libDir: path24.dirname(pkgJson),
       packageName
     };
   } catch {
@@ -50033,8 +50284,8 @@ function loadSherpaOnnxNode() {
   const platformPkgDir = resolvedEnv?.libDir ?? null;
   if (platformPkgDir) {
     applySherpaLoaderEnv(process.env);
-    const addonPath = path24.join(platformPkgDir, "sherpa-onnx.node");
-    if (existsSync13(addonPath)) {
+    const addonPath = path25.join(platformPkgDir, "sherpa-onnx.node");
+    if (existsSync14(addonPath)) {
       const byPath = loadWithRequire(require4, addonPath, attempts);
       if (byPath) {
         cached = byPath;
@@ -50053,7 +50304,7 @@ function loadSherpaOnnxNode() {
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-offline-recognizer.ts
 function assertFileExists(filePath, label) {
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -50120,7 +50371,7 @@ var SherpaOfflineRecognizerEngine = class {
 };
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-online-recognizer.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-loader.ts
 import { createRequire as createRequire5 } from "node:module";
@@ -50136,7 +50387,7 @@ function loadSherpaOnnx() {
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-online-recognizer.ts
 function assertFileExists2(filePath, label) {
-  if (!existsSync15(filePath)) {
+  if (!existsSync16(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -50712,9 +50963,9 @@ var SherpaOnnxSTT = class {
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-tts.ts
 import { Readable as Readable3 } from "node:stream";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 function assertFileExists3(filePath, label) {
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -50805,7 +51056,7 @@ var SherpaOnnxTTS = class {
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-provider.ts
 import { copyFile, mkdir as mkdir7, stat as stat6 } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // ../server/src/server/speech/providers/local/sherpa/silero-vad-session.ts
 import { EventEmitter as EventEmitter6 } from "node:events";
@@ -50997,8 +51248,8 @@ var SherpaSileroVadSession = class extends EventEmitter6 {
 var SILERO_VAD_DIR = "silero-vad";
 var SILERO_VAD_FILE = "silero_vad.onnx";
 async function ensureSileroVadModel(modelsDir, logger) {
-  const destDir = path25.join(modelsDir, SILERO_VAD_DIR);
-  const destPath = path25.join(destDir, SILERO_VAD_FILE);
+  const destDir = path26.join(modelsDir, SILERO_VAD_DIR);
+  const destPath = path26.join(destDir, SILERO_VAD_FILE);
   try {
     const s = await stat6(destPath);
     if (s.isFile() && s.size > 0) return destPath;
@@ -52422,7 +52673,7 @@ import { z as z40 } from "zod";
 import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
 
 // ../server/src/server/agent/session-fork.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, readdirSync as readdirSync2, existsSync as existsSync17 } from "node:fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, readdirSync as readdirSync2, existsSync as existsSync18 } from "node:fs";
 import { dirname as dirname7, join as join18 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 var ForkPointInvalidError = class extends Error {
@@ -52457,11 +52708,11 @@ function extractUserMessageText2(message) {
 function findClaudeSessionFile(params) {
   const home = params.claudeHomeDir ?? join18(homedir6(), ".claude");
   const projectsDir = join18(home, "projects");
-  if (!existsSync17(projectsDir)) return null;
+  if (!existsSync18(projectsDir)) return null;
   for (const entry of readdirSync2(projectsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const candidate = join18(projectsDir, entry.name, `${params.sessionId}.jsonl`);
-    if (existsSync17(candidate)) return candidate;
+    if (existsSync18(candidate)) return candidate;
   }
   return null;
 }
@@ -52514,7 +52765,7 @@ function forkSession(input) {
   }
   const copied = lines.slice(0, forkLineIndex).filter((l) => l.length > 0);
   const targetDir = dirname7(input.targetSessionPath);
-  if (!existsSync17(targetDir)) {
+  if (!existsSync18(targetDir)) {
     throw new Error(`Target directory does not exist: ${targetDir}`);
   }
   const payload = copied.length > 0 ? copied.join("\n") + "\n" : "";
@@ -53124,6 +53375,7 @@ var AgentManager = class {
     this.mcpBaseUrl = options?.mcpBaseUrl ?? null;
     this.appostleHome = options?.appostleHome ?? null;
     this.chromeEnabled = options?.chromeEnabled ?? true;
+    this.ownerUserId = options?.ownerUserId ?? null;
     this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
     this.agentStreamCoalescer = new AgentStreamCoalescer({
       windowMs: options.agentStreamCoalesceWindowMs ?? AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS,
@@ -53381,7 +53633,10 @@ var AgentManager = class {
       mcpServers
     };
     const normalizedConfig = await this.normalizeConfig(injectedConfig);
-    const launchContext = this.buildLaunchContext(resolvedAgentId);
+    const launchContext = this.buildLaunchContext(resolvedAgentId, {
+      userId: options?.userId,
+      username: options?.username
+    });
     const client = this.requireClient(normalizedConfig.provider);
     const available = await client.isAvailable();
     if (!available) {
@@ -55266,13 +55521,19 @@ var AgentManager = class {
     }
     return normalized;
   }
-  buildLaunchContext(agentId) {
-    return {
-      env: {
-        APPOSTLE_AGENT_ID: agentId
-      },
-      chromeEnabled: this.chromeEnabled
+  buildLaunchContext(agentId, user) {
+    const env = {
+      APPOSTLE_AGENT_ID: agentId
     };
+    if (user?.username && user?.userId && this.ownerUserId && user.userId !== this.ownerUserId) {
+      const profileDir = ensureClaudeProfile(user.username, this.logger);
+      env.CLAUDE_CONFIG_DIR = profileDir;
+      this.logger.info(
+        { username: user.username, userId: user.userId, profileDir },
+        "using shared user claude profile"
+      );
+    }
+    return { env, chromeEnabled: this.chromeEnabled };
   }
   requireClient(provider) {
     const client = this.clients.get(provider);
@@ -55301,7 +55562,7 @@ var AgentManager = class {
 // ../server/src/server/agent/agent-storage.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { promises as fs15 } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 import { z as z41 } from "zod";
 var SERIALIZABLE_CONFIG_SCHEMA = z41.object({
   title: z41.string().nullable().optional(),
@@ -55388,7 +55649,7 @@ var AgentStorage = class {
       }
       const nextPath = this.buildRecordPath(record);
       const previousPath = this.pathById.get(agentId);
-      await fs15.mkdir(path26.dirname(nextPath), { recursive: true });
+      await fs15.mkdir(path27.dirname(nextPath), { recursive: true });
       await writeFileAtomically(nextPath, JSON.stringify(record, null, 2));
       this.addIndexedPath(agentId, nextPath);
       if (previousPath && previousPath !== nextPath) {
@@ -55504,7 +55765,7 @@ var AgentStorage = class {
     }
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".json")) {
-        const rootPath = path26.join(this.baseDir, entry.name);
+        const rootPath = path27.join(this.baseDir, entry.name);
         const rootRecord = await this.readRecordFile(rootPath);
         if (!rootRecord) {
           continue;
@@ -55518,7 +55779,7 @@ var AgentStorage = class {
       if (!entry.isDirectory()) {
         continue;
       }
-      const projectDir = path26.join(this.baseDir, entry.name);
+      const projectDir = path27.join(this.baseDir, entry.name);
       let files = [];
       try {
         files = await fs15.readdir(projectDir, { withFileTypes: true });
@@ -55529,7 +55790,7 @@ var AgentStorage = class {
         if (!file.isFile() || !file.name.endsWith(".json")) {
           continue;
         }
-        const filePath = path26.join(projectDir, file.name);
+        const filePath = path27.join(projectDir, file.name);
         const record = await this.readRecordFile(filePath);
         if (!record) {
           continue;
@@ -55554,7 +55815,7 @@ var AgentStorage = class {
   }
   buildRecordPath(record) {
     const projectDir = projectDirNameFromCwd(record.cwd);
-    return path26.join(this.baseDir, projectDir, `${record.id}.json`);
+    return path27.join(this.baseDir, projectDir, `${record.id}.json`);
   }
   addIndexedPath(agentId, filePath) {
     const paths = this.pathsById.get(agentId) ?? /* @__PURE__ */ new Set();
@@ -55576,7 +55837,7 @@ var AgentStorage = class {
   }
 };
 function projectDirNameFromCwd(cwd) {
-  const { root } = path26.win32.parse(cwd);
+  const { root } = path27.win32.parse(cwd);
   const withoutRoot = cwd.slice(root.length).replace(/[\\/]+$/, "");
   const sanitizedRoot = root.replace(/[:\\/]+/g, "-").replace(/^-+|-+$/g, "");
   const prefix = sanitizedRoot ? sanitizedRoot + "-" : "";
@@ -55586,8 +55847,8 @@ function projectDirNameFromCwd(cwd) {
   return prefix + withoutRoot.replace(/[\\/]+/g, "-");
 }
 async function writeFileAtomically(targetPath, payload) {
-  const directory = path26.dirname(targetPath);
-  const tempPath = path26.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID12()}`);
+  const directory = path27.dirname(targetPath);
+  const tempPath = path27.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID12()}`);
   await fs15.writeFile(tempPath, payload, "utf8");
   await fs15.rename(tempPath, targetPath);
 }
@@ -57095,7 +57356,7 @@ async function createMcpWorktree(options) {
 }
 
 // ../server/src/server/workspace-registry-bootstrap.ts
-import path27 from "node:path";
+import path28 from "node:path";
 function minIsoDate(left, right) {
   if (!left) {
     return right;
@@ -57192,8 +57453,8 @@ async function bootstrapWorkspaceRegistries(options) {
   }
   options.logger.info(
     {
-      projectsFile: path27.join(options.appostleHome, "projects", "projects.json"),
-      workspacesFile: path27.join(options.appostleHome, "projects", "workspaces.json"),
+      projectsFile: path28.join(options.appostleHome, "projects", "projects.json"),
+      workspacesFile: path28.join(options.appostleHome, "projects", "workspaces.json"),
       materializedProjects: projectRanges.size,
       materializedWorkspaces: recordsByWorkspaceId.size
     },
@@ -57390,7 +57651,7 @@ var CheckoutDiffManager = class {
 // ../server/src/server/loop-service.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
 import { promises as fs16 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 import { z as z43 } from "zod";
 var LOOP_ID_LENGTH = 8;
 var DEFAULT_LOOP_PROVIDER = "claude";
@@ -57596,7 +57857,7 @@ var LoopService = class {
     this.loops = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
     this.running = /* @__PURE__ */ new Map();
-    this.storePath = path28.join(options.appostleHome, "loops", "loops.json");
+    this.storePath = path29.join(options.appostleHome, "loops", "loops.json");
     this.logger = options.logger.child({ module: "loop-service" });
   }
   async initialize() {
@@ -57665,7 +57926,7 @@ var LoopService = class {
       id: createLoopId(),
       name: normalizeName(input.name),
       prompt,
-      cwd: path28.resolve(input.cwd),
+      cwd: path29.resolve(input.cwd),
       provider: input.provider ?? DEFAULT_LOOP_PROVIDER,
       model: normalizePrompt(input.model, "model"),
       workerProvider: input.workerProvider ?? null,
@@ -58113,7 +58374,7 @@ ${output}` : `exit ${result.exitCode}`
   }
   async persist() {
     const nextPersist = this.persistQueue.then(async () => {
-      await fs16.mkdir(path28.dirname(this.storePath), { recursive: true });
+      await fs16.mkdir(path29.dirname(this.storePath), { recursive: true });
       const records = Array.from(this.loops.values()).sort(
         (left, right) => left.createdAt.localeCompare(right.createdAt)
       );
@@ -58659,12 +58920,12 @@ import { randomUUID as randomUUID15 } from "node:crypto";
 
 // ../server/src/server/quest/store.ts
 import { promises as fs17 } from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 import { z as z44 } from "zod";
 var StoredQuestsSchema = z44.array(QuestRecordSchema);
 var QuestStore = class {
   constructor(options) {
-    this.filePath = path29.join(options.appostleHome, "quests", "quests.json");
+    this.filePath = path30.join(options.appostleHome, "quests", "quests.json");
     this.logger = options.logger;
     this.records = /* @__PURE__ */ new Map();
     this.persistQueue = Promise.resolve();
@@ -58705,7 +58966,7 @@ var QuestStore = class {
   }
   async persist() {
     this.persistQueue = this.persistQueue.then(async () => {
-      await fs17.mkdir(path29.dirname(this.filePath), { recursive: true });
+      await fs17.mkdir(path30.dirname(this.filePath), { recursive: true });
       const payload = JSON.stringify([...this.records.values()], null, 2);
       await fs17.writeFile(this.filePath, payload, "utf8");
     }).catch((err) => {
@@ -59471,7 +59732,7 @@ ${text || "(no output)"}`).join("\n\n");
 
 // ../server/src/server/quest/runner-orchestrator.ts
 import { access, readFile as readFile5 } from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../server/src/server/quest/orchestrator-mcp.ts
@@ -59702,16 +59963,16 @@ var FALLBACK_QUEEN_PROMPT_TEMPLATE = [
 var QUEEN_PROMPT_FILENAME = "queen-prompt.md";
 var QUEEN_PROMPT_MAX_LOOKUP_LEVELS = 10;
 async function findQueenPromptOnDisk() {
-  const start = path30.dirname(fileURLToPath5(import.meta.url));
+  const start = path31.dirname(fileURLToPath5(import.meta.url));
   let cursor = start;
   for (let i = 0; i < QUEEN_PROMPT_MAX_LOOKUP_LEVELS; i += 1) {
-    const candidate = path30.join(cursor, QUEEN_PROMPT_FILENAME);
+    const candidate = path31.join(cursor, QUEEN_PROMPT_FILENAME);
     try {
       await access(candidate);
       return candidate;
     } catch {
     }
-    const parent = path30.dirname(cursor);
+    const parent = path31.dirname(cursor);
     if (parent === cursor) break;
     cursor = parent;
   }
@@ -59757,7 +60018,7 @@ async function resolveWorkerConfigForHandoff(args) {
     title: `quest ${record.id} handoff: ${taskTitle}`,
     internal: true
   };
-  const roleName = path30.basename(rolePath, path30.extname(rolePath));
+  const roleName = path31.basename(rolePath, path31.extname(rolePath));
   try {
     const resolved = await resolveRole({
       roleName,
@@ -59936,7 +60197,7 @@ var OrchestratorRunner = class {
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
 import { appendFile, mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
-import path31 from "node:path";
+import path32 from "node:path";
 var execFileAsync3 = promisify4(execFile3);
 var MAX_VERIFY_OUTPUT_BYTES2 = 64 * 1024;
 function nowIso5() {
@@ -60011,7 +60272,7 @@ function runContainsPromise(run, completionPromise) {
   return finalText.includes(completionPromise);
 }
 function resolveRalphStatePaths(cwd) {
-  const dir = path31.join(cwd, ".hiveminds", "ralph loop");
+  const dir = path32.join(cwd, ".hiveminds", "ralph loop");
   return {
     dir,
     logPath: ""
@@ -60021,7 +60282,7 @@ async function initializeRalphState(args) {
   const base = resolveRalphStatePaths(args.record.cwd);
   const paths = {
     dir: base.dir,
-    logPath: path31.join(base.dir, `ralphloop_${args.record.id}.md`)
+    logPath: path32.join(base.dir, `ralphloop_${args.record.id}.md`)
   };
   await mkdir9(paths.dir, { recursive: true });
   await writeFile8(
@@ -60256,8 +60517,8 @@ function deepMerge(current, patch) {
   }
   return next;
 }
-function getValueAtPath(config, path37) {
-  return path37.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
+function getValueAtPath(config, path38) {
+  return path38.split(".").reduce((value, segment) => isRecord3(value) ? value[segment] : void 0, config);
 }
 function isEqualValue(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
@@ -60276,20 +60537,20 @@ var DaemonConfigStore = class {
   patch(partial) {
     const parsedPatch = MutableDaemonConfigPatchSchema.parse(partial);
     const next = MutableDaemonConfigSchema.parse(deepMerge(this.current, parsedPatch));
-    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path37) => {
-      return !isEqualValue(getValueAtPath(this.current, path37), getValueAtPath(next, path37));
+    const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path38) => {
+      return !isEqualValue(getValueAtPath(this.current, path38), getValueAtPath(next, path38));
     });
     if (changedFieldPaths.length === 0 && isEqualValue(this.current, next)) {
       return this.current;
     }
     this.persistConfig(next);
     this.current = next;
-    for (const path37 of changedFieldPaths) {
-      const handlers = this.fieldChangeHandlers.get(path37);
+    for (const path38 of changedFieldPaths) {
+      const handlers = this.fieldChangeHandlers.get(path38);
       if (!handlers) {
         continue;
       }
-      const value = getValueAtPath(next, path37);
+      const value = getValueAtPath(next, path38);
       for (const handler of handlers) {
         handler(value);
       }
@@ -60299,18 +60560,18 @@ var DaemonConfigStore = class {
     }
     return next;
   }
-  onFieldChange(path37, handler) {
-    const handlers = this.fieldChangeHandlers.get(path37) ?? /* @__PURE__ */ new Set();
+  onFieldChange(path38, handler) {
+    const handlers = this.fieldChangeHandlers.get(path38) ?? /* @__PURE__ */ new Set();
     handlers.add(handler);
-    this.fieldChangeHandlers.set(path37, handlers);
+    this.fieldChangeHandlers.set(path38, handlers);
     return () => {
-      const currentHandlers = this.fieldChangeHandlers.get(path37);
+      const currentHandlers = this.fieldChangeHandlers.get(path38);
       if (!currentHandlers) {
         return;
       }
       currentHandlers.delete(handler);
       if (currentHandlers.size === 0) {
-        this.fieldChangeHandlers.delete(path37);
+        this.fieldChangeHandlers.delete(path38);
       }
     };
   }
@@ -61806,8 +62067,8 @@ function createAuthServerClient(options) {
 }
 
 // ../server/src/server/package-version.ts
-import { existsSync as existsSync18, readFileSync as readFileSync10 } from "node:fs";
-import path32 from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync10 } from "node:fs";
+import path33 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 var PackageVersionResolutionError = class extends Error {
   constructor(params) {
@@ -61817,10 +62078,10 @@ var PackageVersionResolutionError = class extends Error {
 };
 function resolvePackageVersion(params) {
   const moduleUrl = params.moduleUrl ?? import.meta.url;
-  let currentDir = path32.dirname(fileURLToPath6(moduleUrl));
+  let currentDir = path33.dirname(fileURLToPath6(moduleUrl));
   while (true) {
-    const packageJsonPath = path32.join(currentDir, "package.json");
-    if (existsSync18(packageJsonPath)) {
+    const packageJsonPath = path33.join(currentDir, "package.json");
+    if (existsSync19(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
         if (packageJson.name === params.packageName) {
@@ -61838,7 +62099,7 @@ function resolvePackageVersion(params) {
         }
       }
     }
-    const parentDir = path32.dirname(currentDir);
+    const parentDir = path33.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -62203,8 +62464,10 @@ async function createAppostleDaemon(config, rootLogger) {
     const daemonKeyPair = await loadOrCreateDaemonKeyPair(config.appostleHome, logger);
     let relayTransport = null;
     let authServerClient = null;
+    let ownerUserId = null;
     {
       const persisted = loadPersistedConfig(config.appostleHome, logger);
+      ownerUserId = persisted.account?.userId ?? null;
       if (persisted.account) {
         authServerClient = createAuthServerClient({
           logger,
@@ -62341,11 +62604,11 @@ async function createAppostleDaemon(config, rootLogger) {
     httpServer.on("upgrade", scriptProxyUpgradeHandler);
     const agentStorage = new AgentStorage(config.agentStoragePath, logger);
     const projectRegistry = new FileBackedProjectRegistry(
-      path33.join(config.appostleHome, "projects", "projects.json"),
+      path34.join(config.appostleHome, "projects", "projects.json"),
       logger
     );
     workspaceRegistry = new FileBackedWorkspaceRegistry(
-      path33.join(config.appostleHome, "projects", "workspaces.json"),
+      path34.join(config.appostleHome, "projects", "workspaces.json"),
       logger
     );
     const chatService = new FileBackedChatService({
@@ -62363,6 +62626,7 @@ async function createAppostleDaemon(config, rootLogger) {
       registry: agentStorage,
       appostleHome: config.appostleHome,
       chromeEnabled: config.chromeEnabled ?? true,
+      ownerUserId: ownerUserId ?? void 0,
       logger
     });
     const providerRegistry = buildProviderRegistry(logger, {
@@ -62691,7 +62955,7 @@ async function createAppostleDaemon(config, rootLogger) {
         if (listenTarget.type === "tcp") {
           httpServer.listen(listenTarget.port, listenTarget.host);
         } else {
-          if (listenTarget.type === "socket" && existsSync19(listenTarget.path)) {
+          if (listenTarget.type === "socket" && existsSync20(listenTarget.path)) {
             unlinkSync(listenTarget.path);
           }
           httpServer.listen(listenTarget.path);
@@ -62721,7 +62985,7 @@ async function createAppostleDaemon(config, rootLogger) {
       await new Promise((resolve15) => {
         httpServer.close(() => resolve15());
       });
-      if (listenTarget.type === "socket" && existsSync19(listenTarget.path)) {
+      if (listenTarget.type === "socket" && existsSync20(listenTarget.path)) {
         unlinkSync(listenTarget.path);
       }
     };
@@ -62752,16 +63016,16 @@ async function closeAllAgents(logger, agentManager) {
 }
 
 // ../server/src/server/config.ts
-import path35 from "node:path";
+import path36 from "node:path";
 import { z as z51 } from "zod";
 
 // ../server/src/server/speech/speech-config-resolver.ts
 import { z as z50 } from "zod";
 
 // ../server/src/server/speech/providers/local/config.ts
-import path34 from "node:path";
+import path35 from "node:path";
 import { z as z48 } from "zod";
-var DEFAULT_LOCAL_MODELS_SUBDIR = path34.join("models", "local-speech");
+var DEFAULT_LOCAL_MODELS_SUBDIR = path35.join("models", "local-speech");
 var NumberLikeSchema2 = z48.union([z48.number(), z48.string().trim().min(1)]);
 var OptionalFiniteNumberSchema2 = NumberLikeSchema2.pipe(z48.coerce.number().finite()).optional();
 var OptionalIntegerSchema = NumberLikeSchema2.pipe(z48.coerce.number().int()).optional();
@@ -62788,7 +63052,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 ?? path34.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+    modelsDir: params.env.APPOSTLE_LOCAL_MODELS_DIR ?? params.persisted.providers?.local?.modelsDir ?? path35.join(params.appostleHome, DEFAULT_LOCAL_MODELS_SUBDIR),
     dictationLocalSttModel: params.env.APPOSTLE_DICTATION_LOCAL_STT_MODEL ?? persistedLocalFeatureModel(
       params.providers.dictationStt.provider,
       params.providers.dictationStt.enabled,
@@ -63044,7 +63308,7 @@ function loadConfig(appostleHome, options) {
     chromeEnabled,
     mcpDebug: env.MCP_DEBUG === "1",
     daemonIcon,
-    agentStoragePath: path35.join(appostleHome, "agents"),
+    agentStoragePath: path36.join(appostleHome, "agents"),
     staticDir: "public",
     agentClients: {},
     relayEnabled,
@@ -63062,8 +63326,8 @@ function loadConfig(appostleHome, options) {
 }
 
 // ../server/src/server/logger.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync7, readdirSync as readdirSync3, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import path36 from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync8, readdirSync as readdirSync3, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import path37 from "node:path";
 import pino from "pino";
 import pretty from "pino-pretty";
 import { createStream as createRotatingFileStream } from "rotating-file-stream";
@@ -63106,14 +63370,14 @@ function parsePositiveInteger(value) {
   return parsed;
 }
 function resolveFilePath(appostleHome, configuredPath) {
-  const fallback = path36.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
+  const fallback = path37.join(appostleHome, DEFAULT_DAEMON_LOG_FILENAME);
   if (!configuredPath) {
     return fallback;
   }
-  if (path36.isAbsolute(configuredPath)) {
+  if (path37.isAbsolute(configuredPath)) {
     return configuredPath;
   }
-  return path36.resolve(appostleHome, configuredPath);
+  return path37.resolve(appostleHome, configuredPath);
 }
 function minLogLevel(levels) {
   let minLevel = levels[0];
@@ -63149,21 +63413,21 @@ function normalizeLoggerConfigInput(config) {
   return config;
 }
 function rotateOnRestart(filePath, maxFiles) {
-  if (!existsSync20(filePath)) return;
-  const dir = path36.dirname(filePath);
-  const base = path36.basename(filePath);
+  if (!existsSync21(filePath)) return;
+  const dir = path37.dirname(filePath);
+  const base = path37.basename(filePath);
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
   const ts = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
   try {
-    renameSync3(filePath, path36.join(dir, `${ts}-00-${base}`));
+    renameSync3(filePath, path37.join(dir, `${ts}-00-${base}`));
   } catch {
     return;
   }
   const rotatedFiles = readdirSync3(dir).filter((f) => f.endsWith(`-${base}`) && f !== base).sort().reverse();
   for (const file of rotatedFiles.slice(maxFiles)) {
     try {
-      unlinkSync2(path36.join(dir, file));
+      unlinkSync2(path37.join(dir, file));
     } catch {
     }
   }
@@ -63212,15 +63476,15 @@ function resolveLogConfig(configInput, options) {
 }
 function createRootLogger(configInput, options) {
   const config = resolveLogConfig(configInput, options);
-  mkdirSync7(path36.dirname(config.file.path), { recursive: true });
+  mkdirSync8(path37.dirname(config.file.path), { recursive: true });
   const consoleStream = config.console.format === "pretty" ? pretty({
     colorize: true,
     singleLine: true,
     ignore: "pid,hostname"
   }) : pino.destination({ dest: 1, sync: false });
   rotateOnRestart(config.file.path, config.file.rotate.maxFiles);
-  const fileStream = createRotatingFileStream(path36.basename(config.file.path), {
-    path: path36.dirname(config.file.path),
+  const fileStream = createRotatingFileStream(path37.basename(config.file.path), {
+    path: path37.dirname(config.file.path),
     size: toRotatingFileStreamSize(config.file.rotate.maxSize),
     maxFiles: config.file.rotate.maxFiles
   });
@@ -63235,7 +63499,7 @@ function createRootLogger(configInput, options) {
 
 // ../server/src/server/pid-lock.ts
 import { open, readFile as readFile7, unlink as unlink4, mkdir as mkdir10 } from "node:fs/promises";
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { join as join23 } from "node:path";
 import { hostname } from "node:os";
 var PidLockError = class extends Error {
@@ -63264,7 +63528,7 @@ function resolveOwnerPid(ownerPid) {
 }
 async function acquirePidLock(appostleHome, listen, options) {
   const pidPath = getPidFilePath(appostleHome);
-  if (!existsSync21(appostleHome)) {
+  if (!existsSync22(appostleHome)) {
     await mkdir10(appostleHome, { recursive: true });
   }
   let existingLock = null;