openmates 0.27.0-alpha.3 → 0.27.0-alpha.4

package/dist/{chunk-USV2GHLA.js → chunk-LRCPOHGZ.js}

@@ -1859,6 +1859,7 @@ function purgeLocalTeamKeys(hashedEmail) {
   writeJsonFile(filePath, keys);
 }
 function purgeSyncCaches(stateDir2) {
+  rmSync(join2(stateDir2, "project_file_privacy"), { recursive: true, force: true });
   for (const fileName of readdirSync(stateDir2)) {
     if (fileName === SYNC_CACHE_FILE || fileName.startsWith("sync_cache.team.") && fileName.endsWith(".json")) {
       rmSync(join2(stateDir2, fileName), { force: true });
@@ -2448,7 +2449,7 @@ function assertCodexClaimCaller(threadId, currentThread = process.env.CODEX_THRE
 }
 
 // src/client.ts
-import { createHash as createHash14, randomBytes as randomBytes5, randomUUID as randomUUID10, timingSafeEqual } from "crypto";
+import { createHash as createHash15, randomBytes as randomBytes5, randomUUID as randomUUID10, timingSafeEqual } from "crypto";
 import { arch, platform as platform2, release } from "os";
 import { createInterface as createInterface2 } from "readline/promises";
 import { stdin as stdin2, stdout } from "process";
@@ -3256,7 +3257,9 @@ function resolveServerPath(flags) {
 }
 
 // src/projectFileExecutor.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID6, createHash as createHash10 } from "crypto";
+import { mkdir as mkdir2, readFile, writeFile, rename as rename2 } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/projectRequester.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -3633,12 +3636,14 @@ function createProjectFileJobExecutor(options) {
       let proposalCommitment;
       if (isProjectFileMutationOperation(job.operation)) {
         mutation = validateProjectFileMutation({ ...job.arguments, operation: job.operation, operation_id: job.operation_id });
+        if (context.privacy) mutation = context.privacy.restoreMutation(mutation);
         if (!context.writeMode) throw Object.assign(new Error(), { code: "write_policy_required" });
         const digest3 = await projectFileMutationDigest(context.projectKey, job.project_id, job.chat_id, mutation);
         proposalCommitment = digest3;
         if (context.writeMode === "always_ask" && approved.get(job.operation_id) !== digest3) {
           const approvalRequest = { projectId: job.project_id, chatId: job.chat_id, mutation };
-          await result("awaiting_approval", { proposal_commitment: digest3, proposal: mutation });
+          const proposal = context.privacy ? await context.privacy.redactResult(mutation) : mutation;
+          await result("awaiting_approval", { proposal_commitment: digest3, proposal });
           leaseReleased = true;
           options.onWaitingForUser?.(approvalRequest);
           if (!options.requestApproval) return;
@@ -3656,7 +3661,8 @@ function createProjectFileJobExecutor(options) {
         }
       }
       if (job.lease_expires_at * 1e3 <= Date.now()) throw Object.assign(new Error(), { code: "lease_expired" });
-      const requestedPath = job.operation === "read_text" && typeof job.arguments.path === "string" ? job.arguments.path : null;
+      const executionJob = context.privacy ? { ...job, arguments: context.privacy.restoreArguments(job.arguments) } : job;
+      const requestedPath = job.operation === "read_text" && typeof executionJob.arguments.path === "string" ? executionJob.arguments.path : null;
       const readApprovalRequest = requestedPath ? {
         projectId: job.project_id,
         sourceId: context.sourceId !== void 0 ? context.sourceId : job.source_id ?? null,
@@ -3668,14 +3674,15 @@ function createProjectFileJobExecutor(options) {
       let output;
       try {
         output = await context.execute(
-          job,
+          executionJob,
           mutation,
           readApprovalRequest && readApprovalKey && approvedIgnoredReads.has(readApprovalKey) ? { path: readApprovalRequest.path, chatId: job.chat_id, operationId: job.operation_id } : void 0
         );
       } catch (error) {
         const code = error?.code;
         if (code !== "ignored_path_requires_approval" || !readApprovalRequest || !readApprovalKey) throw error;
-        await result("awaiting_approval", { reason: "ignored_path_requires_approval", path: readApprovalRequest.path });
+        const waiting = { reason: "ignored_path_requires_approval", path: readApprovalRequest.path };
+        await result("awaiting_approval", context.privacy ? await context.privacy.redactResult(waiting) : waiting);
         leaseReleased = true;
         options.onWaitingForRead?.(readApprovalRequest);
         if (!options.requestReadApproval) return;
@@ -3691,7 +3698,8 @@ function createProjectFileJobExecutor(options) {
         return;
       }
       approved.delete(job.operation_id);
-      await result("completed", { ...output && typeof output === "object" ? output : { value: output }, ...proposalCommitment ? { proposal_commitment: proposalCommitment } : {} });
+      const safeOutput = context.privacy ? await context.privacy.redactResult(output) : output;
+      await result("completed", { ...safeOutput && typeof safeOutput === "object" ? safeOutput : { value: safeOutput }, ...proposalCommitment ? { proposal_commitment: proposalCommitment } : {} });
       if (mutation) {
         try {
           options.onMutationApplied?.({ projectId: job.project_id, chatId: job.chat_id, mutation });
@@ -4590,6 +4598,746 @@ async function encryptEmbed(embed, masterKey, chatKey, chatId, messageId, userId
   }
 }
 
+// ../secret-scanner/src/identifierRanges.ts
+function codingIdentifierRanges(text4) {
+  const ranges = [];
+  const identifiers2 = /\b[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\b|\b[\da-f]{40,64}\b|\[[A-Z][A-Z\d_]*\]/gi;
+  for (const match of Array.from(text4.matchAll(identifiers2))) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  return ranges;
+}
+
+// ../ui/src/components/enter_message/services/piiDetectionService.ts
+function luhnCheck(cardNumber) {
+  const digits = cardNumber.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let isEven = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let digit = parseInt(digits[i], 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+function ibanCheck(iban) {
+  const cleaned = iban.replace(/\s/g, "").toUpperCase();
+  if (cleaned.length < 15 || cleaned.length > 34) return false;
+  const rearranged = cleaned.substring(4) + cleaned.substring(0, 4);
+  let numericStr = "";
+  for (const char of rearranged) {
+    const code = char.charCodeAt(0);
+    if (code >= 65 && code <= 90) {
+      numericStr += (code - 55).toString();
+    } else {
+      numericStr += char;
+    }
+  }
+  let remainder = 0;
+  for (const digit of numericStr) {
+    remainder = (remainder * 10 + parseInt(digit, 10)) % 97;
+  }
+  return remainder === 1;
+}
+function getSecretSuffix(match, n = 3) {
+  const cleaned = match.replace(/['";\s]+$/g, "");
+  if (cleaned.length <= n) return cleaned;
+  return cleaned.slice(-n);
+}
+function generateMatchId(type, startIndex) {
+  return `pii-${type}-${startIndex}`;
+}
+var PII_PATTERNS = [
+  // API Keys (most specific - check first to avoid partial matches)
+  {
+    type: "AWS_ACCESS_KEY",
+    regex: /\bAKIA[0-9A-Z]{16}\b/g,
+    label: "AWS Access Key",
+    getPlaceholder: (match, counter) => `[AWS_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "OPENAI_KEY",
+    // Matches: sk-proj-..., sk-svcacct-..., sk-... (legacy)
+    regex: /\bsk-(?:proj-|svcacct-)?[A-Za-z0-9_-]{20,200}\b/g,
+    label: "OpenAI API Key",
+    getPlaceholder: (match, counter) => `[OPENAI_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "ANTHROPIC_KEY",
+    regex: /\bsk-ant-api03-[A-Za-z0-9_-]{90,110}\b/g,
+    label: "Anthropic API Key",
+    getPlaceholder: (match, counter) => `[ANTHROPIC_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "GITHUB_PAT",
+    // Classic PAT, fine-grained PAT, and OAuth tokens
+    regex: /\b(?:ghp_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}|gho_[a-zA-Z0-9]{36})\b/g,
+    label: "GitHub Token",
+    getPlaceholder: (match, counter) => `[GITHUB_TOKEN_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "STRIPE_KEY",
+    // Live, test, and restricted keys
+    regex: /\b[sr]k_(?:live|test)_[0-9a-zA-Z]{24,99}\b/g,
+    label: "Stripe API Key",
+    getPlaceholder: (match, counter) => `[STRIPE_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "GOOGLE_API_KEY",
+    regex: /\bAIza[0-9A-Za-z\-_]{35}\b/g,
+    label: "Google API Key",
+    getPlaceholder: (match, counter) => `[GOOGLE_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "SLACK_TOKEN",
+    // Bot, user, and app tokens
+    regex: /\bxox[bpras]-[0-9a-zA-Z-]{10,250}\b/g,
+    label: "Slack Token",
+    getPlaceholder: (match, counter) => `[SLACK_TOKEN_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "AWS_SECRET_KEY",
+    // 40-character base64-like string - only match if preceded by common context keywords
+    // This reduces false positives significantly
+    regex: /(?:aws_secret|secret_key|secretkey|secret_access_key)['":\s=]+([0-9a-zA-Z/+=]{40})\b/gi,
+    label: "AWS Secret Key",
+    getPlaceholder: (match, counter) => `[AWS_SECRET_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "TWILIO_KEY",
+    // Twilio Account SID (AC...) and Auth Token (SK...)
+    regex: /\b(?:AC[a-f0-9]{32}|SK[a-f0-9]{32})\b/g,
+    label: "Twilio Key",
+    getPlaceholder: (match, counter) => `[TWILIO_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "SENDGRID_KEY",
+    // SendGrid API keys start with SG.
+    regex: /\bSG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}\b/g,
+    label: "SendGrid API Key",
+    getPlaceholder: (match, counter) => `[SENDGRID_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "AZURE_KEY",
+    // Azure subscription keys are 32-character hex strings, matched only when
+    // preceded by a contextual keyword to avoid false positives on random hex.
+    regex: /(?:azure|subscription|ocp-apim)[_-]?(?:key|secret|token)['":\s=]+([0-9a-f]{32})\b/gi,
+    label: "Azure Key",
+    getPlaceholder: (match, counter) => `[AZURE_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "HUGGINGFACE_KEY",
+    // Hugging Face API tokens: hf_...
+    regex: /\bhf_[a-zA-Z0-9]{34,}\b/g,
+    label: "Hugging Face Token",
+    getPlaceholder: (match, counter) => `[HF_TOKEN_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "DATABRICKS_TOKEN",
+    // Databricks personal access tokens: dapi...
+    regex: /\bdapi[a-f0-9]{32,40}\b/g,
+    label: "Databricks Token",
+    getPlaceholder: (match, counter) => `[DATABRICKS_TOKEN_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "FIREBASE_KEY",
+    // Firebase server keys typically start with AAAA and are ~152 chars
+    regex: /\bAAAA[A-Za-z0-9_-]{100,200}\b/g,
+    label: "Firebase Key",
+    getPlaceholder: (match, counter) => `[FIREBASE_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "GENERIC_SECRET",
+    // Generic secret/key/token/password patterns — catches assignment-style secrets
+    // that don't match any vendor-specific pattern above. Requires a keyword like
+    // "api_key", "secret", "password", "token", "auth", "credential", "access_key",
+    // followed by an assignment operator and a value of 8+ alphanumeric characters.
+    // The value must be 8+ chars to avoid matching trivial assignments like key="id".
+    regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key|auth[_-]?token|access[_-]?token|bearer[_-]?token|private[_-]?key|password|passwd|credential|client[_-]?secret|app[_-]?secret|signing[_-]?key|encryption[_-]?key)['":\s=]+['"]?([A-Za-z0-9_\-/.+=]{8,200})['"]?/gi,
+    label: "Secret/Credential",
+    getPlaceholder: (match, counter) => `[SECRET_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Private keys and tokens
+  {
+    type: "PRIVATE_KEY",
+    regex: /-----BEGIN (?:RSA |DSA |EC |OPENSSH |ENCRYPTED )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |DSA |EC |OPENSSH |ENCRYPTED )?PRIVATE KEY-----/g,
+    label: "Private Key",
+    getPlaceholder: (match, counter) => `[PRIVATE_KEY_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "JWT",
+    // JWT format: base64.base64.base64
+    regex: /\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+/g,
+    label: "JWT Token",
+    getPlaceholder: (match, counter) => `[JWT_TOKEN_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Personal identifiers
+  {
+    type: "EMAIL",
+    regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+    label: "Email Address",
+    getPlaceholder: (match, counter) => `[EMAIL_${counter}_${getSecretSuffix(match)}]`
+  },
+  {
+    type: "CREDIT_CARD",
+    // Major card formats: Visa, Mastercard, Amex, Discover
+    // With optional spaces or dashes between groups
+    regex: /\b(?:4[0-9]{3}[-\s]?[0-9]{4}[-\s]?[0-9]{4}[-\s]?[0-9]{4}|5[1-5][0-9]{2}[-\s]?[0-9]{4}[-\s]?[0-9]{4}[-\s]?[0-9]{4}|3[47][0-9]{2}[-\s]?[0-9]{6}[-\s]?[0-9]{5}|6(?:011|5[0-9]{2})[-\s]?[0-9]{4}[-\s]?[0-9]{4}[-\s]?[0-9]{4})\b/g,
+    label: "Credit Card",
+    getPlaceholder: (match, counter) => `[CARD_${counter}_${getSecretSuffix(match)}]`,
+    validate: luhnCheck
+  },
+  {
+    type: "SSN",
+    // US Social Security Number: XXX-XX-XXXX or XXX XX XXXX or XXXXXXXXX
+    regex: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g,
+    label: "SSN",
+    getPlaceholder: (match, counter) => `[SSN_${counter}_${getSecretSuffix(match)}]`,
+    // Additional validation: first 3 digits can't be 000, 666, or 900-999
+    validate: (match) => {
+      const digits = match.replace(/\D/g, "");
+      if (digits.length !== 9) return false;
+      const area = parseInt(digits.substring(0, 3), 10);
+      if (area === 0 || area === 666 || area >= 900) return false;
+      const group = parseInt(digits.substring(3, 5), 10);
+      if (group === 0) return false;
+      const serial = parseInt(digits.substring(5, 9), 10);
+      if (serial === 0) return false;
+      return true;
+    }
+  },
+  {
+    type: "PHONE",
+    // Comprehensive phone number detection covering multiple international formats:
+    //
+    // Branch 1 — International with country code (+ or 00 prefix):
+    //   Matches +49 2123 21234, +44 20 7946 0958, +1 (555) 123-4567,
+    //   0049 2123 21234, 0044-20-7946-0958, +492123212234 (E.164)
+    //   Requires country code digit [1-9] then 6-14 more digits with optional
+    //   separators (space, dash, dot, slash, parens) between groups.
+    //
+    // Branch 2 — US/Canada format without country code:
+    //   Matches (555) 123-4567, 555-123-4567, 555.123.4567
+    //   Area code starts with [2-9] per NANP rules.
+    //
+    // Branch 3 — Local format with leading 0 (common in DE, UK, FR, etc.):
+    //   Matches 01123/121/31222, 030 1234 5678, 0171-123-4567
+    //   Leading 0 + at least 7 more digits with separators.
+    //
+    // Validation function filters false positives (plain numbers, years, etc.)
+    regex: /(?:(?:\+|00)[1-9]\d{0,2}[-.\s/]?(?:\(?\d{1,5}\)?[-.\s/]?){1,4}\d{2,4})|(?:\+?1[-.\s]?)?\(?[2-9]\d{2}\)?[-.\s]?\d{3}[-.\s]?\d{4}|(?:0\d[-.\s/]?(?:\(?\d{1,5}\)?[-.\s/]?){1,4}\d{2,4})/g,
+    label: "Phone Number",
+    getPlaceholder: (match, counter) => `[PHONE_${counter}_${getSecretSuffix(match)}]`,
+    // Validate: require at least 7 digits total (country code excluded) to avoid
+    // matching short number-like strings (zip codes, years, short IDs).
+    validate: (match) => {
+      const trimmed = match.trim();
+      const digits = trimmed.replace(/\D/g, "");
+      if (digits.length < 7 || digits.length > 15) return false;
+      if (/^\d{4}$/.test(trimmed)) return false;
+      if (/^\d{4}[-/.]\d{1,2}[-/.]\d{1,2}$/.test(trimmed)) return false;
+      if (/^\d{1,2}[-/.]\d{1,2}[-/.]\d{4}$/.test(trimmed)) return false;
+      if (/^(?:19|20)\d{6}$/.test(trimmed)) return false;
+      if (/^0\d{1,2}[-/.]\d{1,2}[-/.]\d{1,2}$/.test(trimmed)) return false;
+      return true;
+    }
+  },
+  // IP Addresses
+  {
+    type: "IPV4",
+    regex: /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g,
+    label: "IP Address",
+    getPlaceholder: (match, counter) => `[IP_${counter}_${getSecretSuffix(match)}]`,
+    // Exclude common non-sensitive IPs
+    validate: (match) => {
+      if (match === "127.0.0.1" || match === "0.0.0.0") return false;
+      if (match.startsWith("192.168.") || match.startsWith("10.") || match.startsWith("172."))
+        return false;
+      return true;
+    }
+  },
+  {
+    type: "IPV6",
+    // Full IPv6 format
+    regex: /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b/g,
+    label: "IPv6 Address",
+    getPlaceholder: (match, counter) => `[IPV6_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Bank account numbers (IBAN)
+  {
+    type: "IBAN",
+    // IBAN format: 2-letter country code + 2 check digits + up to 30 alphanumeric chars.
+    // Supports both compact (DE89370400440532013000) and spaced (DE89 3704 0044 0532 0130 00).
+    // Country code is required to reduce false positives on random alphanumeric strings.
+    regex: /\b[A-Z]{2}\d{2}[\s]?[\dA-Z]{4}[\s]?(?:[\dA-Z]{4}[\s]?){1,7}[\dA-Z]{1,4}\b/g,
+    label: "IBAN",
+    getPlaceholder: (match, counter) => `[IBAN_${counter}_${getSecretSuffix(match)}]`,
+    validate: ibanCheck
+  },
+  // Home folder / user directory paths that leak the local username.
+  //   /home/marco/projects/foo, /Users/marco/.ssh/config, C:\Users\Marco\Documents
+  //   PS C:\Users\Marco>, PS /home/marco>
+  {
+    type: "HOME_FOLDER",
+    // Two branches:
+    // Branch 1 — Unix/macOS/Windows home directory paths:
+    //   /home/user, /Users/user, C:\Users\user
+    //   Username: 1-64 alphanumeric/dash/underscore/dot chars.
+    //   Requires trailing slash, backslash, or word boundary.
+    //
+    // Branch 2 — PowerShell prompt with home path:
+    //   PS C:\Users\user> or PS /home/user>
+    regex: /(?:\/home\/|\/Users\/|[A-Z]:\\Users\\)[a-zA-Z0-9_.-]{1,64}(?=[/\\]|\b)|PS [A-Z]:\\Users\\[a-zA-Z0-9_.-]{1,64}(?=[\\>]|\b)|PS \/(?:home|Users)\/[a-zA-Z0-9_.-]{1,64}(?=[/>]|\b)/g,
+    label: "Home Folder",
+    getPlaceholder: (match, counter) => `[HOME_PATH_${counter}_${getSecretSuffix(match)}]`,
+    // Exclude common system/service accounts that are not personal
+    validate: (match) => {
+      const username = match.replace(/^(?:PS\s+)?(?:\/home\/|\/Users\/|[A-Z]:\\Users\\)/i, "").toLowerCase();
+      const systemAccounts = /* @__PURE__ */ new Set([
+        "root",
+        "admin",
+        "shared",
+        "public",
+        "default",
+        "guest",
+        "nobody",
+        "daemon",
+        "www-data",
+        "ubuntu"
+      ]);
+      return !systemAccounts.has(username);
+    }
+  },
+  // Terminal prompt user@hostname patterns that leak username and machine name.
+  //   marco@Marcos-MacBook-Pro-3 ~ %      (zsh on macOS)
+  //   marco@devserver:~/projects$          (bash on Linux)
+  //   [marco@centos8 ~]$                   (RHEL/CentOS bash)
+  {
+    type: "USER_AT_HOSTNAME",
+    // Matches user@hostname followed by common terminal prompt context characters
+    // (colon, space, tilde, ~). The hostname may contain dots (FQDN) and dashes.
+    // The lookahead for [:~ \s] ensures we only match in prompt-like contexts,
+    // not in email addresses (which are caught earlier by the EMAIL pattern
+    // due to pattern ordering — EMAIL is checked before USER_AT_HOSTNAME).
+    regex: /\b[a-zA-Z0-9_][a-zA-Z0-9_.-]{0,31}@[a-zA-Z0-9_][a-zA-Z0-9_.-]{0,63}(?=[\s:~])/g,
+    label: "User@Hostname",
+    getPlaceholder: (match, counter) => `[USER_HOST_${counter}_${getSecretSuffix(match)}]`,
+    // Exclude well-known service accounts and non-personal user@host patterns
+    validate: (match) => {
+      const username = match.split("@")[0].toLowerCase();
+      const host = (match.split("@")[1] ?? "").toLowerCase();
+      const serviceHosts = /* @__PURE__ */ new Set([
+        "github.com",
+        "gitlab.com",
+        "bitbucket.org",
+        "ssh.dev.azure.com"
+      ]);
+      if (serviceHosts.has(host)) return false;
+      const systemAccounts = /* @__PURE__ */ new Set([
+        "root",
+        "admin",
+        "guest",
+        "nobody",
+        "daemon",
+        "www-data",
+        "noreply",
+        "no-reply",
+        "git",
+        "svn",
+        "user",
+        "test",
+        "ubuntu"
+      ]);
+      return !systemAccounts.has(username);
+    }
+  },
+  // MAC addresses (network hardware identifiers)
+  {
+    type: "MAC_ADDRESS",
+    // Standard MAC address formats:
+    // - Colon-separated: AA:BB:CC:DD:EE:FF
+    // - Dash-separated: AA-BB-CC-DD-EE-FF
+    // Case-insensitive, requires word boundaries to avoid matching inside hex strings.
+    regex: /\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b/g,
+    label: "MAC Address",
+    getPlaceholder: (match, counter) => `[MAC_${counter}_${getSecretSuffix(match)}]`,
+    // Exclude broadcast and zero addresses
+    validate: (match) => {
+      const normalized = match.replace(/[:-]/g, "").toUpperCase();
+      if (normalized === "000000000000" || normalized === "FFFFFFFFFFFF")
+        return false;
+      return true;
+    }
+  },
+  // Passport numbers (major countries — context-dependent to reduce false positives)
+  {
+    type: "PASSPORT",
+    // Matches passport numbers when preceded by a context keyword like "passport",
+    // "reisepass", "passeport", or passport-number-like labels.
+    // Formats covered:
+    //   - US: 9 digits (C + 8 digits, or 9 digits)
+    //   - DE: 9 alphanumeric (C followed by 8 chars, or 9 uppercase alphanumeric)
+    //   - UK: 9 digits
+    //   - FR: 2 digits + 2 letters + 5 digits
+    //   - Generic: 6-9 alphanumeric (with context keyword requirement)
+    // The context keyword requirement is critical to avoid matching random short strings.
+    regex: /(?:passport|reisepass|passeport|pass(?:port)?[\s._-]?(?:no|nr|num(?:ber)?|#))[:\s#=]*([A-Z0-9]{6,9})\b/gi,
+    label: "Passport Number",
+    getPlaceholder: (match, counter) => `[PASSPORT_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Tax ID / VAT numbers (EU VAT + context-dependent national formats)
+  {
+    type: "TAX_ID",
+    // Two branches:
+    // Branch 1 — EU VAT numbers: 2-letter country prefix + 8-12 alphanumeric digits.
+    //   e.g., DE123456789, GB123456789, FR12345678901, ATU12345678
+    //   Requires \b boundaries to avoid matching inside longer strings.
+    //
+    // Branch 2 — Context-dependent: matches when preceded by keywords like
+    //   "tax id", "tax number", "steuernummer", "steuer-nr", "tin number",
+    //   "vat id", "vat number", "tax identification", followed by a
+    //   colon/equals/space and a number. All keywords require a qualifier
+    //   suffix (e.g., "vat id" not bare "vat") to prevent false positives
+    //   on common words like "vat Konto" or "tin can".
+    //   This catches national tax IDs like US EIN (XX-XXXXXXX), German
+    //   Steuernummer (XXX/XXX/XXXXX), etc.
+    regex: /\b(?:AT ?U\d{8}|BE ?0?\d{9,10}|BG ?\d{9,10}|HR ?\d{11}|CY ?\d{8}[A-Z]|CZ ?\d{8,10}|DK ?\d{8}|EE ?\d{9}|FI ?\d{8}|FR ?[0-9A-Z]{2}\d{9}|DE ?\d{9}|EL ?\d{9}|HU ?\d{8}|IE ?\d{7}[A-Z]{1,2}|IT ?\d{11}|LV ?\d{11}|LT ?\d{9,12}|LU ?\d{8}|MT ?\d{8}|NL ?\d{9}B\d{2}|PL ?\d{10}|PT ?\d{9}|RO ?\d{2,10}|SK ?\d{10}|SI ?\d{8}|ES ?[A-Z0-9]\d{7}[A-Z0-9]|SE ?\d{12}|GB ?\d{9}(?:\d{3})?)\b|(?:tax[\s_-]?(?:id|number|no|nr)|steuer(?:nummer|identifikationsnummer|nr|ident(?:nummer)?)|tin[\s_-]?(?:number|no|nr)|vat[\s_-]?(?:id|number|no|nr)|tax[\s_-]?identification(?:[\s_-]?number)?)[:\s#=]+([A-Z0-9\s/-]{5,20})/gi,
+    label: "Tax ID",
+    getPlaceholder: (match, counter) => `[TAX_ID_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Vehicle license plate numbers (DE, AT, CH, UK, FR, NL, IT, ES, PL, US)
+  {
+    type: "VEHICLE_PLATE",
+    // Context-dependent: requires a preceding keyword like "license plate",
+    // "kennzeichen", "nummernschild", "immatriculation", "plate number", etc.
+    // to avoid false positives on random letter-number combinations.
+    //
+    // Without context, plate formats (e.g., "B AB 1234") are too ambiguous
+    // and would match many non-plate strings. The keyword requirement
+    // eliminates nearly all false positives while still catching explicit mentions.
+    regex: /(?:license[\s_-]?plate|plate[\s_-]?(?:number|no|nr)|kennzeichen|nummernschild|kfz[\s_-]?kennzeichen|immatriculation|registration[\s_-]?(?:number|no|nr|plate)|vrm|numberplate)[:\s#=]*([A-Z0-9]{1,4}[\s-]?[A-Z0-9]{1,4}[\s-]?[A-Z0-9]{1,6})\b/gi,
+    label: "Vehicle Plate",
+    getPlaceholder: (match, counter) => `[PLATE_${counter}_${getSecretSuffix(match)}]`
+  },
+  // Cryptocurrency wallet addresses (Bitcoin + Ethereum)
+  {
+    type: "CRYPTO_WALLET",
+    // Three branches:
+    // Branch 1 — Bitcoin Bech32 (SegWit): bc1 + 25-87 lowercase alphanumeric chars
+    //   e.g., bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4
+    //
+    // Branch 2 — Bitcoin Legacy (P2PKH/P2SH): starts with 1 or 3, 25-34 base58 chars
+    //   e.g., 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa
+    //   Base58 excludes 0, O, I, l to avoid ambiguity.
+    //
+    // Branch 3 — Ethereum: 0x + 40 hex characters
+    //   e.g., 0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18
+    regex: /\b(?:bc1[a-z0-9]{25,87}|[13][a-km-zA-HJ-NP-Z1-9]{25,34}|0x[0-9a-fA-F]{40})\b/g,
+    label: "Crypto Wallet",
+    getPlaceholder: (match, counter) => `[WALLET_${counter}_${getSecretSuffix(match)}]`
+  }
+];
+var MIN_PII_TEXT_LENGTH = 6;
+var PII_TYPE_TO_CATEGORY = {
+  EMAIL: "email_addresses",
+  ADDRESS: "addresses",
+  PHONE: "phone_numbers",
+  CREDIT_CARD: "credit_card_numbers",
+  SSN: "social_security_numbers",
+  IBAN: "iban_bank_account",
+  TAX_ID: "tax_id_vat",
+  PASSPORT: "passport_numbers",
+  CRYPTO_WALLET: "crypto_wallets",
+  VEHICLE_PLATE: "vehicle_plate",
+  // No toggle in settings — always enabled if master is on
+  // API keys & secrets → "api_keys" category
+  AWS_ACCESS_KEY: "api_keys",
+  AWS_SECRET_KEY: "api_keys",
+  OPENAI_KEY: "api_keys",
+  ANTHROPIC_KEY: "api_keys",
+  GITHUB_PAT: "api_keys",
+  STRIPE_KEY: "api_keys",
+  GOOGLE_API_KEY: "api_keys",
+  SLACK_TOKEN: "api_keys",
+  TWILIO_KEY: "api_keys",
+  SENDGRID_KEY: "api_keys",
+  AZURE_KEY: "api_keys",
+  HUGGINGFACE_KEY: "api_keys",
+  DATABRICKS_TOKEN: "api_keys",
+  FIREBASE_KEY: "api_keys",
+  // Developer patterns
+  GENERIC_SECRET: "generic_secrets",
+  PRIVATE_KEY: "private_keys",
+  JWT: "jwt_tokens",
+  IPV4: "ip_addresses",
+  IPV6: "ip_addresses",
+  HOME_FOLDER: "home_folder",
+  USER_AT_HOSTNAME: "user_at_hostname",
+  MAC_ADDRESS: "mac_addresses"
+};
+function detectPII(text4, excludedIdsOrOptions = /* @__PURE__ */ new Set()) {
+  const options = excludedIdsOrOptions instanceof Set ? { excludedIds: excludedIdsOrOptions } : excludedIdsOrOptions;
+  const excludedIds = options.excludedIds ?? /* @__PURE__ */ new Set();
+  const disabledCategories = options.disabledCategories ?? /* @__PURE__ */ new Set();
+  const personalEntries = options.personalDataEntries ?? [];
+  if (!text4 || text4.length < MIN_PII_TEXT_LENGTH && personalEntries.length === 0)
+    return [];
+  const matches2 = [];
+  const coveredRanges = [];
+  const identifierRanges = codingIdentifierRanges(text4);
+  const typeCounts = {};
+  const hasExclusions = excludedIds.size > 0;
+  const hasDisabledCategories = disabledCategories.size > 0;
+  const URL_EXCLUSION_REGEX = /https?:\/\/[^\s]+/g;
+  const urlExclusionZones = [];
+  URL_EXCLUSION_REGEX.lastIndex = 0;
+  let urlMatch;
+  while ((urlMatch = URL_EXCLUSION_REGEX.exec(text4)) !== null) {
+    urlExclusionZones.push({
+      start: urlMatch.index,
+      end: urlMatch.index + urlMatch[0].length
+    });
+  }
+  const hasUrlExclusions = urlExclusionZones.length > 0;
+  if (text4.length >= MIN_PII_TEXT_LENGTH) {
+    for (const pattern of PII_PATTERNS) {
+      if (hasDisabledCategories) {
+        const category = PII_TYPE_TO_CATEGORY[pattern.type];
+        if (category && disabledCategories.has(category)) continue;
+      }
+      pattern.regex.lastIndex = 0;
+      let regexMatch;
+      while ((regexMatch = pattern.regex.exec(text4)) !== null) {
+        const matchText = regexMatch[0];
+        const startIndex = regexMatch.index;
+        const endIndex = startIndex + matchText.length;
+        if (pattern.type === "PHONE" && identifierRanges.some((range) => startIndex < range.end && endIndex > range.start)) continue;
+        if (hasUrlExclusions) {
+          const insideUrl = urlExclusionZones.some(
+            (zone) => startIndex >= zone.start && endIndex <= zone.end
+          );
+          if (insideUrl) continue;
+        }
+        const overlaps = coveredRanges.some(
+          (range) => startIndex >= range.start && startIndex < range.end || endIndex > range.start && endIndex <= range.end || startIndex <= range.start && endIndex >= range.end
+        );
+        if (overlaps) continue;
+        if (pattern.validate && !pattern.validate(matchText)) {
+          continue;
+        }
+        const matchId = generateMatchId(pattern.type, startIndex);
+        if (hasExclusions && excludedIds.has(matchId)) continue;
+        typeCounts[pattern.type] = (typeCounts[pattern.type] || 0) + 1;
+        matches2.push({
+          type: pattern.type,
+          match: matchText,
+          startIndex,
+          endIndex,
+          placeholder: pattern.getPlaceholder(matchText, typeCounts[pattern.type]),
+          id: matchId
+        });
+        coveredRanges.push({ start: startIndex, end: endIndex });
+      }
+    }
+  }
+  for (const entry of personalEntries) {
+    const textsToSearch = [];
+    if (entry.textToHide && entry.textToHide.trim().length > 0) {
+      textsToSearch.push(entry.textToHide);
+    }
+    if (entry.additionalTexts) {
+      for (const additional of entry.additionalTexts) {
+        if (additional && additional.trim().length > 0) {
+          textsToSearch.push(additional);
+        }
+      }
+    }
+    for (const searchText of textsToSearch) {
+      const lowerText = text4.toLowerCase();
+      const lowerSearch = searchText.toLowerCase();
+      let searchFrom = 0;
+      while (searchFrom < lowerText.length) {
+        const idx = lowerText.indexOf(lowerSearch, searchFrom);
+        if (idx === -1) break;
+        const startIndex = idx;
+        const endIndex = idx + searchText.length;
+        const overlaps = coveredRanges.some(
+          (range) => startIndex >= range.start && startIndex < range.end || endIndex > range.start && endIndex <= range.end || startIndex <= range.start && endIndex >= range.end
+        );
+        if (!overlaps) {
+          const matchText = text4.substring(startIndex, endIndex);
+          const matchId = `pii-PERSONAL_DATA-${entry.id}-${startIndex}`;
+          if (!hasExclusions || !excludedIds.has(matchId)) {
+            const placeholder = entry.replaceWith.startsWith("[") ? entry.replaceWith : `[${entry.replaceWith}]`;
+            matches2.push({
+              type: entry.type ?? "EMAIL",
+              match: matchText,
+              startIndex,
+              endIndex,
+              placeholder,
+              id: matchId
+            });
+            coveredRanges.push({ start: startIndex, end: endIndex });
+          }
+        }
+        searchFrom = idx + searchText.length;
+      }
+    }
+  }
+  matches2.sort((a, b) => a.startIndex - b.startIndex);
+  return matches2;
+}
+
+// ../ui/src/services/projectFilePrivacy.ts
+function fail2(code) {
+  throw Object.assign(new Error(code), { code });
+}
+var TOKEN = /\[[A-Za-z][A-Za-z0-9_]*\]/g;
+var GENERATED_TOKEN = /^\[OM_PII_[A-F0-9]{32}\]$/;
+function legacyToken(token) {
+  const match = /^\[([A-Z_]+)_\d+_[A-Za-z0-9]{1,3}\]$/.exec(token);
+  return Boolean(match && Object.prototype.hasOwnProperty.call(PII_TYPE_TO_CATEGORY, match[1]));
+}
+var ProjectFilePrivacy = class {
+  values = /* @__PURE__ */ new Map();
+  ambiguous = /* @__PURE__ */ new Set();
+  conflicts = [];
+  options;
+  savePending = Promise.resolve();
+  constructor(options) {
+    this.options = options;
+    this.addMappings(options.mappings ?? []);
+  }
+  addMappings(mappings) {
+    for (const mapping of mappings) {
+      if (!mapping || typeof mapping.original !== "string" || !mapping.original || typeof mapping.placeholder !== "string" || !/^\[[A-Za-z][A-Za-z0-9_]*\]$/.test(mapping.placeholder)) continue;
+      const previous = this.values.get(mapping.placeholder);
+      if (previous && previous.original !== mapping.original) {
+        this.ambiguous.add(mapping.placeholder);
+        if (!this.conflicts.some((value) => value.placeholder === mapping.placeholder && value.original === mapping.original)) this.conflicts.push({ ...mapping });
+      } else this.values.set(mapping.placeholder, { ...mapping });
+    }
+    if (this.values.size + this.conflicts.length > 1e4) fail2("pii_mapping_limit");
+  }
+  restoreText(text4) {
+    return text4.replace(TOKEN, (token) => {
+      if (this.ambiguous.has(token)) fail2("pii_mapping_ambiguous");
+      const mapping = this.values.get(token);
+      const customToken = this.options.detection?.personalDataEntries?.some((entry) => (entry.replaceWith.startsWith("[") ? entry.replaceWith : `[${entry.replaceWith}]`) === token);
+      if (!mapping && (GENERATED_TOKEN.test(token) || legacyToken(token) || customToken)) fail2("pii_mapping_unavailable");
+      return mapping?.original ?? token;
+    });
+  }
+  restoreArguments(arguments_) {
+    const result = { ...arguments_ };
+    for (const key of ["path", "query", "glob"]) {
+      if (typeof result[key] === "string") result[key] = this.restoreText(result[key]);
+    }
+    return result;
+  }
+  restoreMutation(mutation) {
+    const result = { ...mutation, path: this.restoreText(mutation.path) };
+    if (mutation.content !== void 0) result.content = this.restoreText(mutation.content);
+    if (mutation.patch !== void 0) {
+      result.patch = mutation.patch.split("\n").map((line) => {
+        const restored = this.restoreText(line);
+        if (restored.includes("\n")) fail2("pii_multiline_patch_token");
+        return restored;
+      }).join("\n");
+    }
+    return validateProjectFileMutation(result);
+  }
+  token(original, type) {
+    for (const [token, mapping] of Array.from(this.values)) {
+      if (!this.ambiguous.has(token) && mapping.original === original) return token;
+    }
+    let placeholder;
+    do {
+      placeholder = `[OM_PII_${crypto.randomUUID().replace(/-/g, "").toUpperCase()}]`;
+    } while (this.values.has(placeholder));
+    this.addMappings([{ placeholder, original, type }]);
+    return placeholder;
+  }
+  redactText(text4) {
+    const ranges = [];
+    const tokens = Array.from(text4.matchAll(TOKEN)).map((match) => ({ start: match.index, end: match.index + match[0].length }));
+    for (const range of tokens) {
+      const literal = text4.slice(range.start, range.end);
+      if (this.values.has(literal) || GENERATED_TOKEN.test(literal) || legacyToken(literal)) ranges.push(range);
+    }
+    const overlaps = (start, end) => [...tokens, ...ranges].some((r) => start < r.end && end > r.start);
+    for (const mapping of Array.from(this.values.values()).sort((a, b) => b.original.length - a.original.length)) {
+      let start = text4.indexOf(mapping.original);
+      while (start !== -1) {
+        const end = start + mapping.original.length;
+        if (!overlaps(start, end)) ranges.push({ start, end, type: mapping.type });
+        start = text4.indexOf(mapping.original, end);
+      }
+    }
+    if (this.options.enabled !== false) {
+      for (const match of detectPII(text4, this.options.detection)) {
+        if (!overlaps(match.startIndex, match.endIndex)) ranges.push({ start: match.startIndex, end: match.endIndex, type: match.type });
+      }
+    }
+    let cursor = 0;
+    let result = "";
+    for (const range of ranges.sort((a, b) => a.start - b.start)) {
+      result += text4.slice(cursor, range.start);
+      result += text4.slice(range.start, range.end).split(/(\r?\n)/).map((part) => !part || /^(?:\r?\n)$/.test(part) ? part : this.token(part, range.type)).join("");
+      cursor = range.end;
+    }
+    return result + text4.slice(cursor);
+  }
+  async redactResult(value) {
+    const visit = (item) => {
+      if (typeof item === "string") return this.redactText(item);
+      if (Array.isArray(item)) return item.map(visit);
+      if (item && typeof item === "object") return Object.fromEntries(Object.entries(item).map(([key, child]) => {
+        if (["expected_base", "content_hash", "proposal_commitment"].includes(key)) return [key, child];
+        return [key, visit(child)];
+      }));
+      return item;
+    };
+    const result = visit(value);
+    const save = this.savePending.catch(() => {
+    }).then(() => this.options.save([...Array.from(this.values.values()), ...this.conflicts]));
+    this.savePending = save;
+    await save;
+    return result;
+  }
+};
+
+// ../ui/src/services/projectFilePrivacyStorage.ts
+async function loadProjectFilePrivacy(options) {
+  const ciphertext = await options.read();
+  let mappings = [];
+  if (ciphertext) {
+    const plaintext = await options.decrypt(ciphertext, options.key);
+    try {
+      const saved = JSON.parse(plaintext ?? "null");
+      if (saved?.chat_id !== options.chatId || saved?.project_id !== options.projectId || !Array.isArray(saved?.mappings)) throw new Error();
+      mappings = saved.mappings;
+    } catch {
+      throw Object.assign(new Error(), { code: "pii_mapping_unavailable" });
+    }
+  }
+  return new ProjectFilePrivacy({
+    mappings: [...mappings, ...options.mappings],
+    detection: options.detection,
+    enabled: options.enabled,
+    save: async (current) => {
+      const plaintext = JSON.stringify({ chat_id: options.chatId, project_id: options.projectId, mappings: current });
+      if (new TextEncoder().encode(plaintext).byteLength > 2 * 1024 * 1024) throw Object.assign(new Error(), { code: "pii_mapping_limit" });
+      await options.write(await options.encrypt(plaintext, options.key));
+    }
+  });
+}
+
 // src/projectFileExecutor.ts
 function projectPrivatePaths(settingsText) {
   if (!settingsText) return [];
@@ -4650,6 +5398,7 @@ async function prepareCliProjectFocusForPreflight(options) {
 }
 function registerCliProjectFileExecutor(options) {
   let closed = false;
+  const privacyContexts = /* @__PURE__ */ new Map();
   const executor = createProjectFileJobExecutor({
     isActiveChat: (chatId) => !closed && chatId === options.chatId,
     send: (event, payload) => options.ws.sendAsync(event, payload),
@@ -4664,6 +5413,49 @@ function registerCliProjectFileExecutor(options) {
       const focus = await options.client.getActiveProjectFocus(job.chat_id);
       if (focus?.project_id !== job.project_id) throw Object.assign(new Error(), { code: "project_focus_required" });
       const context = { teamId: focus.team_id, personal: !focus.team_id };
+      if (!privacyContexts.has(job.project_id)) {
+        const loaded = (async () => {
+          const directory = join6(resolveStateDir(), "project_file_privacy");
+          const filename = createHash10("sha256").update(JSON.stringify([options.chatId, job.project_id])).digest("hex") + ".ciphertext";
+          const path2 = join6(directory, filename);
+          const history = await options.client.getChatMessages(options.chatId, context);
+          const memories = options.memories ?? [];
+          const settings2 = memories.find((entry) => entry.app_id === "privacy" && entry.item_type === "pii_detection_settings")?.data;
+          return loadProjectFilePrivacy({
+            chatId: job.chat_id,
+            projectId: job.project_id,
+            key: options.chatKey,
+            mappings: [...history.messages.flatMap((message) => message.piiMappings ?? []), ...options.piiMappings ?? []],
+            enabled: settings2?.masterEnabled,
+            detection: {
+              disabledCategories: new Set(Object.entries(settings2?.categories ?? {}).filter(([, enabled]) => !enabled).map(([key]) => key)),
+              personalDataEntries: memories.filter((entry) => entry.app_id === "privacy" && entry.item_type === "personal_data_entry").flatMap((entry) => {
+                const data = entry.data;
+                return data.enabled && data.textToHide && data.replaceWith ? [{ id: entry.id, textToHide: data.textToHide, replaceWith: data.replaceWith, additionalTexts: Object.values(data.addressLines ?? {}) }] : [];
+              })
+            },
+            read: async () => {
+              try {
+                return await readFile(path2, "utf8");
+              } catch (error) {
+                if (error.code === "ENOENT") return null;
+                throw error;
+              }
+            },
+            write: async (ciphertext) => {
+              await mkdir2(directory, { recursive: true, mode: 448 });
+              const temporary = path2 + "." + randomUUID6();
+              await writeFile(temporary, ciphertext, { mode: 384, flag: "wx" });
+              await rename2(temporary, path2);
+            },
+            encrypt: encryptWithAesGcmCombined,
+            decrypt: decryptWithAesGcmCombined
+          });
+        })();
+        privacyContexts.set(job.project_id, loaded);
+        void loaded.catch(() => privacyContexts.delete(job.project_id));
+      }
+      const privacy = await privacyContexts.get(job.project_id);
       const [detail, settings, sources] = await Promise.all([
         options.client.getProject(job.project_id, context),
         options.client.getProjectSettings(job.project_id, context),
@@ -4679,6 +5471,7 @@ function registerCliProjectFileExecutor(options) {
       if (job.source_id && !source || !job.source_id && sources.length > 1) throw Object.assign(new Error(), { code: "source_selection_required" });
       return {
         projectKey,
+        privacy,
         sourceId: source?.source_id ?? null,
         writeMode: settings.selection_required ? null : settings.write_mode,
         execute: async (currentJob, mutation, approvedIgnoredRead) => {
@@ -4757,12 +5550,12 @@ function registerCliProjectFileExecutor(options) {
 // src/remoteCommandClient.ts
 import { webcrypto as webcrypto3 } from "crypto";
 import { chmodSync as chmodSync3, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/remoteCommandPermissions.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { closeSync as closeSync2, constants, fstatSync, openSync as openSync2, readFileSync as readFileSync7, realpathSync } from "fs";
-import { isAbsolute as isAbsolute3, join as join6, posix, relative } from "path";
+import { isAbsolute as isAbsolute3, join as join7, posix, relative } from "path";
 import { parseDocument } from "yaml";
 var REMOTE_COMMAND_PERMISSIONS_PATH = ".openmates/permissions.yml";
 var RemoteCommandPermissionsError = class extends Error {
@@ -4780,7 +5573,7 @@ var IDENTIFIER = /^[a-z][a-z0-9-]{0,63}$/;
 var ENVIRONMENT_NAME = /^[A-Z_][A-Z0-9_]{0,127}$/;
 function loadRemoteCommandPermissions(projectRoot) {
   const root = realpathSync(projectRoot);
-  const path2 = join6(root, REMOTE_COMMAND_PERMISSIONS_PATH);
+  const path2 = join7(root, REMOTE_COMMAND_PERMISSIONS_PATH);
   let descriptor;
   try {
     descriptor = openSync2(path2, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -5050,7 +5843,7 @@ function stableJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function isInside(root, candidate) {
   const path2 = relative(root, candidate);
@@ -5100,7 +5893,7 @@ var RemoteCommandOutputAccumulator = class {
   }
 };
 function listRemoteCommandPresetGrants() {
-  const path2 = join7(resolveStateDir(), PRESET_GRANTS_FILE);
+  const path2 = join8(resolveStateDir(), PRESET_GRANTS_FILE);
   if (!existsSync5(path2)) return [];
   const stat3 = lstatSync(path2);
   if (!stat3.isFile() || stat3.isSymbolicLink() || (stat3.mode & 63) !== 0) throw new Error("Remote command preset grant store is not private");
@@ -5111,8 +5904,8 @@ function listRemoteCommandPresetGrants() {
     return {
       project_id: identifier2(item.project_id, "project_id"),
       preset_id: identifier2(item.preset_id, "preset_id"),
-      definition_digest: typeof item.definition_digest === "string" && /^[a-f0-9]{64}$/i.test(item.definition_digest) ? item.definition_digest : fail2("invalid preset definition digest"),
-      enabled: item.enabled === true ? true : fail2("invalid preset grant state")
+      definition_digest: typeof item.definition_digest === "string" && /^[a-f0-9]{64}$/i.test(item.definition_digest) ? item.definition_digest : fail3("invalid preset definition digest"),
+      enabled: item.enabled === true ? true : fail3("invalid preset grant state")
     };
   });
 }
@@ -5318,7 +6111,7 @@ function validateRemoteCommandReview(value) {
     state: "REVIEW_REQUIRED",
     created_at: integer2(item.created_at, "created_at"),
     review_expires_at: integer2(item.review_expires_at, "review_expires_at"),
-    review_token: typeof item.review_token === "string" && item.review_token.length >= 32 ? item.review_token : fail2("invalid review token"),
+    review_token: typeof item.review_token === "string" && item.review_token.length >= 32 ? item.review_token : fail3("invalid review token"),
     approval_requirement: oneOf2(item.approval_requirement, ["one_run", "one_run_or_preset"], "approval requirement"),
     command,
     explanation: {
@@ -5368,7 +6161,7 @@ function writePresetGrants(grants) {
   const directory = resolveStateDir();
   mkdirSync6(directory, { recursive: true, mode: 448 });
   chmodSync3(directory, 448);
-  const path2 = join7(directory, PRESET_GRANTS_FILE);
+  const path2 = join8(directory, PRESET_GRANTS_FILE);
   if (existsSync5(path2) && lstatSync(path2).isSymbolicLink()) throw new Error("Remote command preset grant store cannot be a symbolic link");
   const temporary = `${path2}.${process.pid}.tmp`;
   writeFileSync4(temporary, `${JSON.stringify({ version: 1, grants }, null, 2)}
@@ -5419,7 +6212,7 @@ function oneOf2(value, choices, name) {
 function assertProjectKey(value) {
   if (!(value instanceof Uint8Array) || value.byteLength !== 32) throw new Error("Project key must be 32 bytes");
 }
-function fail2(message) {
+function fail3(message) {
   throw new Error(message);
 }
 
@@ -7023,7 +7816,7 @@ function escapeRegExp(s) {
 import { readFileSync as readFileSync9, statSync, existsSync as existsSync6 } from "fs";
 import { basename as basename2, extname as extname2, resolve as resolve4 } from "path";
 import { homedir as homedir4 } from "os";
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import JSZip2 from "jszip";
 var MAX_PER_FILE_SIZE = 100 * 1024 * 1024;
 var BLOCKED_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -7560,7 +8353,7 @@ function processCodeFile(filePath, filename, redactor) {
       line_count: lineCount
     });
     const textPreview = `${filename} (${language}, ${lineCount} lines)`;
-    const contentHash = createHash11("sha256").update(content).digest("hex");
+    const contentHash = createHash12("sha256").update(content).digest("hex");
     const embed = {
       embedId,
       embedRef,
@@ -7627,7 +8420,7 @@ async function processDocxFile(filePath, filename, redactor) {
       textPreview: filename,
       status: "finished",
       filePath: filename,
-      contentHash: createHash11("sha256").update(content).digest("hex"),
+      contentHash: createHash12("sha256").update(content).digest("hex"),
       textLengthChars: content.length
     },
     referenceBlock: createEmbedReferenceBlock(embedRef),
@@ -7670,7 +8463,7 @@ function createSheetFileEmbed(tableMarkdown, filename, redactor) {
       textPreview: filename,
       status: "finished",
       filePath: filename,
-      contentHash: createHash11("sha256").update(content).digest("hex"),
+      contentHash: createHash12("sha256").update(content).digest("hex"),
       textLengthChars: content.length
     },
     referenceBlock: createEmbedReferenceBlock(embedRef),
@@ -7915,7 +8708,7 @@ function buildEmbedShareUrl(origin, embedId, blob) {
 }
 
 // src/connectedAccountImport.ts
-import { createHash as createHash12, randomUUID as randomUUID7, webcrypto as webcrypto5 } from "crypto";
+import { createHash as createHash13, randomUUID as randomUUID7, webcrypto as webcrypto5 } from "crypto";
 var TRANSFER_PREFIX = "OMCA1.";
 var SUPPORTED_KDF_ITERATIONS = 1e5;
 async function decryptConnectedAccountCliTransferPayload(encryptedPayload, passcode) {
@@ -8060,7 +8853,7 @@ function defaultProviderLabel(providerId) {
   return providerId === "google_calendar" ? "Google Calendar" : "Connected account";
 }
 function sha256Hex2(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function base64UrlToBytes2(value) {
   return base64ToBytes(value.replace(/-/g, "+").replace(/_/g, "/"));
@@ -9027,7 +9820,7 @@ function stripTimer(job) {
 }
 
 // src/plansCli.ts
-import { createHash as createHash13, randomBytes as randomBytes3, randomUUID as randomUUID9 } from "crypto";
+import { createHash as createHash14, randomBytes as randomBytes3, randomUUID as randomUUID9 } from "crypto";
 var PLAN_STATUSES = ["draft", "checking_assumptions", "awaiting_confirmation", "active", "executing", "running_checks", "blocked", "completed", "archived"];
 var LEARNING_TYPES = ["workflow_improvement", "agent_instruction_improvement"];
 var LEARNING_TARGET_KINDS = ["workflow", "project_agent_instructions"];
@@ -9551,7 +10344,7 @@ async function planKeyFromRecord(record7, masterKey) {
   return planKey;
 }
 function sha256Hex3(value) {
-  return createHash13("sha256").update(value).digest("hex");
+  return createHash14("sha256").update(value).digest("hex");
 }
 async function decryptOptional2(value, key) {
   if (!value) return "";
@@ -9574,7 +10367,7 @@ function parseUserFlows(value) {
 }
 function deriveShortId2(record7) {
   const source = record7.plan_id || `${record7.created_at ?? ""}-${record7.updated_at ?? ""}`;
-  const digest3 = createHash13("sha256").update(source).digest("hex").slice(0, 6).toUpperCase();
+  const digest3 = createHash14("sha256").update(source).digest("hex").slice(0, 6).toUpperCase();
   return `${DEFAULT_PLAN_PREFIX}-${digest3}`;
 }
 function nowSeconds2() {
@@ -11483,7 +12276,7 @@ var OpenMatesClient = class _OpenMatesClient {
       }
       payload.team_project_key_wrapper = {
         key_type: "team",
-        hashed_team_id: createHash14("sha256").update(teamId).digest("hex"),
+        hashed_team_id: createHash15("sha256").update(teamId).digest("hex"),
         team_key_epoch: 1,
         encrypted_project_key: await encryptBytesWithAesGcm(projectKey, teamKey),
         wrapper_version: 1,
@@ -11793,7 +12586,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!userId) {
       throw new Error("Could not resolve current user id for local connected-account connector.");
     }
-    const { createHash: createHash30 } = await import("crypto");
+    const { createHash: createHash31 } = await import("crypto");
     const accountId = randomUUID10();
     const masterKey = this.getMasterKeyBytes();
     const encryptLocalConnectorValue = async (value) => {
@@ -11802,9 +12595,9 @@ var OpenMatesClient = class _OpenMatesClient {
     };
     const payload = {
       id: accountId,
-      hashed_user_id: createHash30("sha256").update(userId).digest("hex"),
+      hashed_user_id: createHash31("sha256").update(userId).digest("hex"),
       encrypted_provider_type: await encryptLocalConnectorValue(input.provider_id),
-      provider_type_hash: createHash30("sha256").update(input.provider_id).digest("hex"),
+      provider_type_hash: createHash31("sha256").update(input.provider_id).digest("hex"),
       encrypted_account_label: await encryptLocalConnectorValue(input.label),
       encrypted_capabilities: await encryptLocalConnectorValue(input.capabilities),
       encrypted_app_permissions: await encryptLocalConnectorValue({
@@ -12553,8 +13346,8 @@ var OpenMatesClient = class _OpenMatesClient {
     return decryptBytesWithAesGcm(encryptedChatKey, masterKey);
   }
   getContextWrapperEncryptedChatKey(cache, chatId, teamId = null) {
-    const hashedChatId = createHash14("sha256").update(chatId).digest("hex");
-    const hashedTeamId = teamId ? createHash14("sha256").update(teamId).digest("hex") : null;
+    const hashedChatId = createHash15("sha256").update(chatId).digest("hex");
+    const hashedTeamId = teamId ? createHash15("sha256").update(teamId).digest("hex") : null;
     const wrapper = (cache?.chatKeyWrappers ?? []).find(
       (entry) => entry.key_type === (teamId ? "team" : "master") && entry.hashed_chat_id === hashedChatId && (!hashedTeamId || entry.hashed_team_id === hashedTeamId) && typeof entry.encrypted_chat_key === "string"
     );
@@ -12827,7 +13620,7 @@ var OpenMatesClient = class _OpenMatesClient {
       processing_window_id: processingWindowId,
       ideas: params.ideas.map((idea, index) => ({ index: index + 1, ...idea.payload }))
     });
-    const payloadHash = createHash14("sha256").update(serverProcessablePayload).digest("hex");
+    const payloadHash = createHash15("sha256").update(serverProcessablePayload).digest("hex");
     const masterKey = this.getMasterKeyBytes();
     const chatKey = new Uint8Array(randomBytes5(32));
     const encryptedChatKey = await encryptBytesWithAesGcm(chatKey, masterKey);
@@ -13178,7 +13971,7 @@ var OpenMatesClient = class _OpenMatesClient {
       );
       let msgEmbedIds = [];
       if (clientMsgId && embeds.length > 0) {
-        const hashed = createHash14("sha256").update(clientMsgId).digest("hex");
+        const hashed = createHash15("sha256").update(clientMsgId).digest("hex");
         msgEmbedIds = embeds.filter(
           (e) => e.hashed_message_id === hashed && !e.parent_embed_id
         ).map((e) => String(e.embed_id ?? e.id ?? "")).filter(Boolean);
@@ -13193,7 +13986,10 @@ var OpenMatesClient = class _OpenMatesClient {
         category: msgCategory,
         modelName,
         createdAt: typeof m.created_at === "number" ? m.created_at : 0,
-        embedIds: msgEmbedIds
+        embedIds: msgEmbedIds,
+        ...typeof m.encrypted_pii_mappings === "string" && chatKeyBytes ? {
+          piiMappings: JSON.parse(await decryptWithAesGcmCombined(m.encrypted_pii_mappings, chatKeyBytes) ?? "[]")
+        } : {}
       });
     }
     messages.sort((a, b) => a.createdAt - b.createdAt);
@@ -13330,7 +14126,7 @@ var OpenMatesClient = class _OpenMatesClient {
           source_version: 1,
           sequence: segment.sequence,
           kind: segment.kind,
-          source_hash: createHash14("sha256").update(segment.speakableText).digest("hex"),
+          source_hash: createHash15("sha256").update(segment.speakableText).digest("hex"),
           speakable_text: segment.speakableText
         }));
         const messageId = message.clientMessageId || message.id;
@@ -13595,8 +14391,8 @@ var OpenMatesClient = class _OpenMatesClient {
       );
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const { createHash: createHash30 } = await import("crypto");
-    const hashedEmbedId = createHash30("sha256").update(embedId).digest("hex");
+    const { createHash: createHash31 } = await import("crypto");
+    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -13698,7 +14494,7 @@ var OpenMatesClient = class _OpenMatesClient {
   async resolveEmbedKey(cache, masterKey, embed, embedId, hashedEmbedId, visited = /* @__PURE__ */ new Set()) {
     if (visited.has(embedId)) return null;
     visited.add(embedId);
-    const { createHash: createHash30 } = await import("crypto");
+    const { createHash: createHash31 } = await import("crypto");
     const masterKeyEntry = cache.embedKeys.find(
       (ek) => ek.hashed_embed_id === hashedEmbedId && String(ek.key_type) === "master"
     );
@@ -13715,7 +14511,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (chatKeyEntry && typeof chatKeyEntry.encrypted_embed_key === "string") {
       const hashedChatId = String(chatKeyEntry.hashed_chat_id ?? "");
       const owningChat = cache.chats.find((c) => {
-        const chatHash = createHash30("sha256").update(String(c.details.id ?? "")).digest("hex");
+        const chatHash = createHash31("sha256").update(String(c.details.id ?? "")).digest("hex");
         return chatHash === hashedChatId;
       });
       if (owningChat) {
@@ -13744,7 +14540,7 @@ var OpenMatesClient = class _OpenMatesClient {
         const parentFullId = String(
           parentEmbed2.embed_id ?? parentEmbed2.id ?? ""
         );
-        const parentHashedId = createHash30("sha256").update(parentFullId).digest("hex");
+        const parentHashedId = createHash31("sha256").update(parentFullId).digest("hex");
         const parentKey = await this.resolveEmbedKey(
           cache,
           masterKey,
@@ -14046,6 +14842,8 @@ var OpenMatesClient = class _OpenMatesClient {
         ws,
         chatId,
         chatKey: chatKeyBytes,
+        piiMappings,
+        memories: availableMemories,
         requestApproval: params.onProjectWriteApproval,
         requestReadApproval: params.onProjectReadApproval
       });
@@ -16406,7 +17204,7 @@ var OpenMatesClient = class _OpenMatesClient {
     let key = wrapper ? await decryptBytesWithAesGcm(String(wrapper.encrypted_embed_key), projectKey) : null;
     if (!key) {
       const cache = await this.ensureSynced();
-      key = await this.resolveEmbedKey(cache, this.getMasterKeyBytes(), embed, embedId, createHash14("sha256").update(embedId).digest("hex"));
+      key = await this.resolveEmbedKey(cache, this.getMasterKeyBytes(), embed, embedId, createHash15("sha256").update(embedId).digest("hex"));
     }
     if (!key || typeof embed.encrypted_content !== "string") throw Object.assign(new Error("Project file key unavailable"), { code: "file_key_unavailable" });
     const content = await decryptWithAesGcmCombined(embed.encrypted_content, key);
@@ -18352,7 +19150,7 @@ Required: ${schema.required.join(", ")}`
     const session = this.requireSession();
     const masterKey = base64ToBytes(session.masterKeyExportedB64);
     const cache = await this.ensureSynced();
-    const { createHash: createHash30 } = await import("crypto");
+    const { createHash: createHash31 } = await import("crypto");
     const embed = cache.embeds.find(
       (e) => String(e.embed_id ?? "").startsWith(embedIdOrShort) || String(e.id ?? "").startsWith(embedIdOrShort)
     );
@@ -18360,7 +19158,7 @@ Required: ${schema.required.join(", ")}`
       throw new Error(`Embed '${embedIdOrShort}' not found in local cache.`);
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const hashedEmbedId = createHash30("sha256").update(embedId).digest("hex");
+    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -18468,8 +19266,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash30 } = await import("crypto");
-    const hashedEmbedId = createHash30("sha256").update(embedId).digest("hex");
+    const { createHash: createHash31 } = await import("crypto");
+    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -18585,8 +19383,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash30 } = await import("crypto");
-    const hashedEmbedId = createHash30("sha256").update(embedId).digest("hex");
+    const { createHash: createHash31 } = await import("crypto");
+    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -19118,9 +19916,9 @@ Required: ${schema.required.join(", ")}`
     chats.splice(0, chats.length, ...reconciledChats);
     if (totalChatCount === 0) totalChatCount = chats.length;
     if (reconciliation.deleted_chat_ids?.length) {
-      const { createHash: createHash30 } = await import("crypto");
+      const { createHash: createHash31 } = await import("crypto");
       const deletedHashes = new Set(
-        reconciliation.deleted_chat_ids.map((id) => createHash30("sha256").update(id).digest("hex"))
+        reconciliation.deleted_chat_ids.map((id) => createHash31("sha256").update(id).digest("hex"))
       );
       const keptEmbeds = embeds.filter((embed) => !deletedHashes.has(String(embed.hashed_chat_id ?? "")));
       const keptKeys = embedKeys.filter((key) => !deletedHashes.has(String(key.hashed_chat_id ?? "")));
@@ -25792,13 +26590,13 @@ var GeneratedAppSkills = class {
 
 // src/sdk.ts
 import { decode as toonDecode2 } from "@toon-format/toon";
-import { createHash as createHash15, createHmac as createHmac4, randomBytes as randomBytes7, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash16, createHmac as createHmac4, randomBytes as randomBytes7, randomUUID as randomUUID11 } from "crypto";
 import { chmodSync as chmodSync4, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 
 // src/designIcons.ts
-import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, extname as extname3 } from "path";
 import { Resvg } from "@resvg/resvg-js";
 var ICON_SEGMENT_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
@@ -25891,9 +26689,9 @@ function normalizePngSize(value, label3) {
 async function writeExportFile(path2, data) {
   const directory = dirname2(path2);
   if (directory && directory !== ".") {
-    await mkdir2(directory, { recursive: true });
+    await mkdir3(directory, { recursive: true });
   }
-  await writeFile(path2, data);
+  await writeFile2(path2, data);
 }
 
 // src/accountExportArchive.ts
@@ -25954,13 +26752,13 @@ var ACCOUNT_EXPORT_FORBIDDEN_VALUE_PATTERNS = [
   /#key=[A-Za-z0-9_-]{8,}/
 ];
 async function writeAccountExportArchive(bundle, flags = {}) {
-  const { mkdir: mkdir3, writeFile: writeFile2 } = await import("fs/promises");
-  const { join: join29, dirname: dirname17 } = await import("path");
+  const { mkdir: mkdir4, writeFile: writeFile3 } = await import("fs/promises");
+  const { join: join30, dirname: dirname17 } = await import("path");
   const exportId = safeArchiveSegment(String(bundle.export.export_id ?? `export-${Date.now()}`));
   const archiveFormat = flags.format === "directory" ? "directory" : "zip";
   const password = typeof flags.password === "string" && flags.password.length > 0 ? flags.password : null;
   if (password && archiveFormat !== "zip") throw new Error("Password-protected account export is only supported for zip format.");
-  const outputPath = typeof flags.output === "string" ? flags.output : join29(process.cwd(), archiveFormat === "zip" ? `openmates-account-export-${exportId}${password ? ".zip.enc" : ".zip"}` : `openmates-account-export-${exportId}`);
+  const outputPath = typeof flags.output === "string" ? flags.output : join30(process.cwd(), archiveFormat === "zip" ? `openmates-account-export-${exportId}${password ? ".zip.enc" : ".zip"}` : `openmates-account-export-${exportId}`);
   const zip = archiveFormat === "zip" ? new JSZip3() : null;
   const writtenFiles = [];
   async function writeArchiveText(relativePath, content) {
@@ -25971,9 +26769,9 @@ async function writeAccountExportArchive(bundle, flags = {}) {
       return;
     }
     const stagingDir = outputPath;
-    const fullPath = join29(stagingDir, relativePath);
-    await mkdir3(dirname17(fullPath), { recursive: true });
-    await writeFile2(fullPath, content, "utf-8");
+    const fullPath = join30(stagingDir, relativePath);
+    await mkdir4(dirname17(fullPath), { recursive: true });
+    await writeFile3(fullPath, content, "utf-8");
     writtenFiles.push(relativePath);
   }
   await writeArchiveText("README.md", buildAccountExportReadme(bundle));
@@ -25989,9 +26787,9 @@ async function writeAccountExportArchive(bundle, flags = {}) {
   }
   await writeAccountExportChatFiles(domainPayloads.chats ?? [], writeArchiveText);
   if (archiveFormat === "directory") return { output: outputPath, format: "directory", files: writtenFiles.length };
-  await mkdir3(dirname17(outputPath), { recursive: true });
+  await mkdir4(dirname17(outputPath), { recursive: true });
   const zipBuffer = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
-  await writeFile2(outputPath, password ? encryptZipBuffer(zipBuffer, password) : zipBuffer);
+  await writeFile3(outputPath, password ? encryptZipBuffer(zipBuffer, password) : zipBuffer);
   return { output: outputPath, format: "zip", files: writtenFiles.length, ...password ? { encrypted: true } : {} };
 }
 function encryptZipBuffer(zipBuffer, password) {
@@ -26427,7 +27225,7 @@ var OpenMates = class {
   }
   async resolveEmbedKeyForShare(embedKeys, embedId) {
     const masterKey = await this.getMasterKey();
-    const hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
+    const hashedEmbedId = createHash16("sha256").update(embedId).digest("hex");
     return this.resolveLoadedEmbedKey(embedKeys, hashedEmbedId, masterKey, masterKey);
   }
   async decryptChatMetadata(chat, chatKeyWrappers) {
@@ -26486,7 +27284,7 @@ var OpenMates = class {
     return { ...payload, chat: decryptedChat, messages, embeds };
   }
   async resolveLoadedChatKey(chat, chatKeyWrappers) {
-    const hashedChatId = createHash15("sha256").update(chat.id).digest("hex");
+    const hashedChatId = createHash16("sha256").update(chat.id).digest("hex");
     const wrapper = (chatKeyWrappers ?? []).find(
       (entry) => entry.key_type === "master" && entry.hashed_chat_id === hashedChatId && typeof entry.encrypted_chat_key === "string"
     );
@@ -26504,9 +27302,9 @@ var OpenMates = class {
       if (!embedId) {
         return { ...embed };
       }
-      let hashedEmbedId = createHash15("sha256").update(embedId).digest("hex");
+      let hashedEmbedId = createHash16("sha256").update(embedId).digest("hex");
       if (!embedKeys.some((key) => key.hashed_embed_id === hashedEmbedId) && typeof embed.parent_embed_id === "string" && embed.parent_embed_id) {
-        hashedEmbedId = createHash15("sha256").update(embed.parent_embed_id).digest("hex");
+        hashedEmbedId = createHash16("sha256").update(embed.parent_embed_id).digest("hex");
       }
       const embedKey = await this.resolveLoadedEmbedKey(embedKeys, hashedEmbedId, masterKey, chatKey);
       if (!embedKey) {
@@ -26752,7 +27550,7 @@ var OpenMates = class {
   }
 };
 function loadOrCreateDeviceId(customPath) {
-  const path2 = customPath ?? join8(homedir5(), ".openmates", "sdk-device-id");
+  const path2 = customPath ?? join9(homedir5(), ".openmates", "sdk-device-id");
   if (existsSync8(path2)) {
     const stored = readFileSync10(path2, "utf8").trim();
     if (stored) return stored;
@@ -26866,7 +27664,7 @@ async function buildProjectCreatePayload(wrappingKey, input, teamId = null) {
     last_opened_at: timestamp,
     key_wrappers: teamId ? [{
       key_type: "team",
-      hashed_team_id: createHash15("sha256").update(teamId).digest("hex"),
+      hashed_team_id: createHash16("sha256").update(teamId).digest("hex"),
       team_key_epoch: 1,
       encrypted_project_key: await encryptBytesWithAesGcm(projectKey, wrappingKey),
       wrapper_version: 1,
@@ -26876,7 +27674,7 @@ async function buildProjectCreatePayload(wrappingKey, input, teamId = null) {
   return { payload, projectKey };
 }
 async function decryptSdkProject(record7, wrappingKey, teamId = null) {
-  const encryptedProjectKey = teamId ? record7.key_wrappers?.find((wrapper) => wrapper.key_type === "team" && wrapper.hashed_team_id === createHash15("sha256").update(teamId).digest("hex") && wrapper.team_key_epoch === 1)?.encrypted_project_key : record7.encrypted_project_key;
+  const encryptedProjectKey = teamId ? record7.key_wrappers?.find((wrapper) => wrapper.key_type === "team" && wrapper.hashed_team_id === createHash16("sha256").update(teamId).digest("hex") && wrapper.team_key_epoch === 1)?.encrypted_project_key : record7.encrypted_project_key;
   if (typeof encryptedProjectKey !== "string") throw new OpenMatesConfigError(`Project ${record7.project_id} is missing encrypted project key`);
   const projectKey = await decryptBytesWithAesGcm(encryptedProjectKey, wrappingKey);
   if (!projectKey) throw new OpenMatesConfigError(`Failed to decrypt Project key for ${record7.project_id}`);
@@ -26953,7 +27751,7 @@ async function resolveSdkProject(client2, projectId, context = { personal: true
   const response = await client2.get(withQuery(`/v1/projects/${encodeURIComponent(resolvedProjectId)}`, { team_id: crypto3.teamId }));
   const record7 = response.project;
   if (!record7) throw new OpenMatesApiError(404, { detail: "Project not found" });
-  const teamHash = crypto3.teamId ? createHash15("sha256").update(crypto3.teamId).digest("hex") : null;
+  const teamHash = crypto3.teamId ? createHash16("sha256").update(crypto3.teamId).digest("hex") : null;
   const encryptedProjectKey = crypto3.teamId ? record7.key_wrappers?.find((wrapper) => wrapper.key_type === "team" && wrapper.hashed_team_id === teamHash && wrapper.team_key_epoch === 1)?.encrypted_project_key : record7.encrypted_project_key;
   if (typeof encryptedProjectKey !== "string") throw new OpenMatesConfigError("Project response is missing encrypted Project key wrapper");
   const projectKey = await decryptBytesWithAesGcm(encryptedProjectKey, crypto3.key);
@@ -26983,7 +27781,7 @@ async function resolveSdkChatKey(client2, chatId) {
   const payload = await client2.get(`/v1/sdk/chats/${encodeURIComponent(resolvedChatId)}`);
   const chat = payload.chat;
   if (!chat) throw new OpenMatesConfigError("Saved chat payload did not include chat metadata");
-  const hashedChatId = createHash15("sha256").update(chat.id).digest("hex");
+  const hashedChatId = createHash16("sha256").update(chat.id).digest("hex");
   const wrappers = Array.isArray(payload.chat_key_wrappers) ? payload.chat_key_wrappers : Array.isArray(chat.chat_key_wrappers) ? chat.chat_key_wrappers : [];
   const wrapper = wrappers.find(
     (entry) => entry.key_type === "master" && entry.hashed_chat_id === hashedChatId && typeof entry.encrypted_chat_key === "string"
@@ -28038,7 +28836,7 @@ var OpenMatesIdeaBucket = class {
       processing_window_id: bucketId,
       ideas: [{ index: 1, type: "text", text: ideaText }]
     });
-    const payloadHash = createHash15("sha256").update(serverProcessablePayload).digest("hex");
+    const payloadHash = createHash16("sha256").update(serverProcessablePayload).digest("hex");
     const masterKey = await this.client.masterKey();
     const chatKey = new Uint8Array(randomBytes7(32));
     const encryptedChatKey = await encryptBytesWithAesGcm(chatKey, masterKey);
@@ -30219,12 +31017,12 @@ async function readActivityHistory(options) {
 }
 
 // src/taskActivityDelivery.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync11, readdirSync as readdirSync3, rmSync as rmSync3, existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import lockfile4 from "proper-lockfile";
 function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date.now, ownerHash) {
-  const directory = join9(stateDir2, "task-activity-delivery", createHash16("sha256").update(scope2).digest("hex"));
+  const directory = join10(stateDir2, "task-activity-delivery", createHash17("sha256").update(scope2).digest("hex"));
   mkdirSync8(directory, { recursive: true, mode: 448 });
   let parts = null;
   try {
@@ -30233,9 +31031,9 @@ function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date
   } catch {
   }
   const accountScope = parts ? JSON.stringify(parts.slice(0, 3)) : scope2;
-  if (parts) atomicPrivateFile(join9(directory, "scope.json"), JSON.stringify(parts));
-  const pendingDirectory = join9(directory, "pending");
-  const acknowledgedDirectory = join9(directory, "acknowledged");
+  if (parts) atomicPrivateFile(join10(directory, "scope.json"), JSON.stringify(parts));
+  const pendingDirectory = join10(directory, "pending");
+  const acknowledgedDirectory = join10(directory, "acknowledged");
   mkdirSync8(pendingDirectory, { recursive: true, mode: 448 });
   mkdirSync8(acknowledgedDirectory, { recursive: true, mode: 448 });
   const save = (path2, record7) => {
@@ -30259,7 +31057,7 @@ function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date
         throw error;
       }
       record7.acknowledged = acknowledged;
-      save(join9(acknowledgedDirectory, `${record7.input.entry_id}.json`), record7);
+      save(join10(acknowledgedDirectory, `${record7.input.entry_id}.json`), record7);
       rmSync3(path2, { force: true });
     }
     return record7.acknowledged;
@@ -30269,8 +31067,8 @@ function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date
       if (!/^[a-f0-9]{64}$/.test(id)) throw new Error("--delivery-id must be a SHA-256 hex identifier");
       const release2 = await lockTaskDeliveryRecord(directory, id);
       try {
-        const acknowledgedPath = join9(acknowledgedDirectory, `${id}.json`);
-        const path2 = existsSync9(acknowledgedPath) ? acknowledgedPath : join9(pendingDirectory, `${id}.json`);
+        const acknowledgedPath = join10(acknowledgedDirectory, `${id}.json`);
+        const path2 = existsSync9(acknowledgedPath) ? acknowledgedPath : join10(pendingDirectory, `${id}.json`);
         let record7;
         try {
           record7 = JSON.parse(readFileSync11(path2, "utf8"));
@@ -30293,7 +31091,7 @@ function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date
         let rejected = 0;
         let notice;
         for (const name of names) {
-          const path2 = join9(pendingDirectory, name);
+          const path2 = join10(pendingDirectory, name);
           const record7 = JSON.parse(readFileSync11(path2, "utf8"));
           if (record7.acknowledged) continue;
           if (record7.rejected) {
@@ -30330,13 +31128,13 @@ function activityDeliveryStore(scope2, stateDir2 = resolveStateDir(), now = Date
 async function flushPendingTaskActivities(client2, teamId, stateDir2 = resolveStateDir(), onNotice) {
   const session = client2.getSession();
   const expected = JSON.stringify([session.apiUrl, session.hashedEmail, teamId || "personal"]);
-  const base = join9(stateDir2, "task-activity-delivery");
+  const base = join10(stateDir2, "task-activity-delivery");
   if (!existsSync9(base)) return;
   for (const folder of readdirSync3(base)) {
     if (!/^[a-f0-9]{64}$/.test(folder)) continue;
     let scope2;
     try {
-      scope2 = JSON.parse(readFileSync11(join9(base, folder, "scope.json"), "utf8"));
+      scope2 = JSON.parse(readFileSync11(join10(base, folder, "scope.json"), "utf8"));
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -30359,8 +31157,8 @@ async function flushPendingTaskActivities(client2, teamId, stateDir2 = resolveSt
 // src/cli.ts
 import { existsSync as existsSync26, readFileSync as readFileSync24, realpathSync as realpathSync12, readdirSync as readdirSync14, statSync as statSync11, writeFileSync as writeFileSync16 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { basename as basename9, dirname as dirname16, join as join28 } from "path";
-import { createHash as createHash29, randomBytes as randomBytes14, randomUUID as randomUUID23 } from "crypto";
+import { basename as basename9, dirname as dirname16, join as join29 } from "path";
+import { createHash as createHash30, randomBytes as randomBytes14, randomUUID as randomUUID23 } from "crypto";
 import { arch as arch2, platform as platform3 } from "os";
 import { parse as parseYaml, parseDocument as parseYamlDocument, stringify as stringifyYaml } from "yaml";
 
@@ -30614,13 +31412,13 @@ var SECRET_ENV_PATTERNS = [
 ];
 
 // ../secret-scanner/src/patterns.ts
-function getSecretSuffix(match, n = 3) {
+function getSecretSuffix2(match, n = 3) {
   const cleaned = match.replace(/['";\s]+$/g, "");
   if (cleaned.length <= n) return cleaned;
   return cleaned.slice(-n);
 }
 function generatePlaceholder(prefix, match, suffixLength = 3, counter = 1) {
-  return `[${prefix}_${counter}_${getSecretSuffix(match, suffixLength)}]`;
+  return `[${prefix}_${counter}_${getSecretSuffix2(match, suffixLength)}]`;
 }
 var SECRET_PATTERNS = [
   {
@@ -30789,11 +31587,11 @@ var SecretRegistry = class {
       return this.entries.get(value).token;
     }
     const prefix = this.getPlaceholderPrefix(name, type);
-    let token = `[${prefix}_${getSecretSuffix(value, this.suffixLength)}]`;
+    let token = `[${prefix}_${getSecretSuffix2(value, this.suffixLength)}]`;
     const existing = this.usedPlaceholders.get(token);
     if (existing && existing !== value) {
       for (let len = this.suffixLength + 1; len <= 8; len++) {
-        const candidate = `[${prefix}_${getSecretSuffix(value, len)}]`;
+        const candidate = `[${prefix}_${getSecretSuffix2(value, len)}]`;
         const candidateExisting = this.usedPlaceholders.get(candidate);
         if (!candidateExisting || candidateExisting === value) {
           token = candidate;
@@ -31114,6 +31912,7 @@ var SecretScanner = class {
     const allMappings = [];
     const coveredRanges = [];
     const urlExclusionZones = getUrlExclusionZones(text4);
+    const identifierRanges = codingIdentifierRanges(text4);
     if (this.options.enableRegistryDetection && this.registry.size > 0) {
       const registryMappings = this.registry.findAll(text4);
       for (const mapping of registryMappings) {
@@ -31138,6 +31937,7 @@ var SecretScanner = class {
           const matchText = match[0];
           const startIndex = match.index;
           const endIndex = startIndex + matchText.length;
+          if (pattern.type === "PHONE" && identifierRanges.some((range) => startIndex < range.end && endIndex > range.start)) continue;
           if (isInsideAnyRange(startIndex, endIndex, urlExclusionZones)) continue;
           const overlaps = coveredRanges.some(
             (range) => startIndex >= range.start && startIndex < range.end || endIndex > range.start && endIndex <= range.end || startIndex <= range.start && endIndex >= range.end
@@ -32857,12 +33657,12 @@ function resolveHostNotificationDestinations(value, deploymentMode, serverEnviro
 
 // src/server.ts
 import { execFileSync as execFileSync5, execSync, spawn as nodeSpawn, spawnSync } from "child_process";
-import { createHash as createHash18, randomBytes as randomBytes9, randomUUID as randomUUID15 } from "crypto";
+import { createHash as createHash19, randomBytes as randomBytes9, randomUUID as randomUUID15 } from "crypto";
 import { appendFileSync, chmodSync as chmodSync8, closeSync as closeSync4, copyFileSync as copyFileSync2, cpSync, existsSync as existsSync13, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, openSync as openSync4, readFileSync as readFileSync14, readSync, readdirSync as readdirSync6, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
 import { createInterface as createInterface3 } from "readline";
 import { createInterface as createPromptInterface } from "readline/promises";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname8, join as join15, resolve as resolve7 } from "path";
+import { dirname as dirname8, join as join16, resolve as resolve7 } from "path";
 
 // src/branding.ts
 var OPENMATES_WORDMARK = "OPENMATES";
@@ -32905,17 +33705,17 @@ import {
   symlinkSync
 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname4, join as join10, resolve as resolve5 } from "path";
-var UI_PACKAGE_RELATIVE_PATH = join10("frontend", "packages", "ui");
-var GENERATED_LOCALES_RELATIVE_PATH = join10(UI_PACKAGE_RELATIVE_PATH, "src", "i18n", "locales");
-var BUILD_TRANSLATIONS_SCRIPT_RELATIVE_PATH = join10(UI_PACKAGE_RELATIVE_PATH, "scripts", "build-translations.js");
+import { dirname as dirname4, join as join11, resolve as resolve5 } from "path";
+var UI_PACKAGE_RELATIVE_PATH = join11("frontend", "packages", "ui");
+var GENERATED_LOCALES_RELATIVE_PATH = join11(UI_PACKAGE_RELATIVE_PATH, "src", "i18n", "locales");
+var BUILD_TRANSLATIONS_SCRIPT_RELATIVE_PATH = join11(UI_PACKAGE_RELATIVE_PATH, "scripts", "build-translations.js");
 var REQUIRED_LOCALE_JSON = "en.json";
 function sourceInstallLocalesPath(rootPath) {
-  return join10(rootPath, GENERATED_LOCALES_RELATIVE_PATH);
+  return join11(rootPath, GENERATED_LOCALES_RELATIVE_PATH);
 }
 function ensureSourceInstallTranslations(installPath, sourcePath) {
   const localeDir = sourceInstallLocalesPath(installPath);
-  const requiredLocalePath = join10(localeDir, REQUIRED_LOCALE_JSON);
+  const requiredLocalePath = join11(localeDir, REQUIRED_LOCALE_JSON);
   if (existsSync10(requiredLocalePath)) {
     return { status: "already_present", localeDir, copiedFiles: 0 };
   }
@@ -32935,27 +33735,27 @@ function copyGeneratedLocaleJson(sourcePath, installPath) {
   const targetRoot = resolve5(installPath);
   if (sourceRoot === targetRoot) return 0;
   const sourceLocaleDir = sourceInstallLocalesPath(sourceRoot);
-  if (!existsSync10(join10(sourceLocaleDir, REQUIRED_LOCALE_JSON))) return 0;
+  if (!existsSync10(join11(sourceLocaleDir, REQUIRED_LOCALE_JSON))) return 0;
   const targetLocaleDir = sourceInstallLocalesPath(targetRoot);
   mkdirSync9(targetLocaleDir, { recursive: true });
   let copiedFiles = 0;
   for (const entry of readdirSync4(sourceLocaleDir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    copyFileSync(join10(sourceLocaleDir, entry.name), join10(targetLocaleDir, entry.name));
+    copyFileSync(join11(sourceLocaleDir, entry.name), join11(targetLocaleDir, entry.name));
     copiedFiles += 1;
   }
   return copiedFiles;
 }
 function runBuildTranslationsScript(installPath) {
-  const uiPackageDir = join10(installPath, UI_PACKAGE_RELATIVE_PATH);
-  const buildScript = join10(installPath, BUILD_TRANSLATIONS_SCRIPT_RELATIVE_PATH);
+  const uiPackageDir = join11(installPath, UI_PACKAGE_RELATIVE_PATH);
+  const buildScript = join11(installPath, BUILD_TRANSLATIONS_SCRIPT_RELATIVE_PATH);
   if (!existsSync10(buildScript)) {
     throw new Error(`Translation build script not found at ${buildScript}.`);
   }
   const requireFromCli = createRequire3(import.meta.url);
   const yamlPackageDir = dirname4(requireFromCli.resolve("yaml/package.json"));
-  const nodeModulesDir = join10(uiPackageDir, "node_modules");
-  const yamlLink = join10(nodeModulesDir, "yaml");
+  const nodeModulesDir = join11(uiPackageDir, "node_modules");
+  const yamlLink = join11(nodeModulesDir, "yaml");
   const hadNodeModulesDir = existsSync10(nodeModulesDir);
   const hadYamlPackage = existsSync10(yamlLink);
   if (!hadYamlPackage) {
@@ -32976,7 +33776,7 @@ function runBuildTranslationsScript(installPath) {
 }
 
 // src/serverPlanning.ts
-import { dirname as dirname5, join as join11, resolve as resolve6 } from "path";
+import { dirname as dirname5, join as join12, resolve as resolve6 } from "path";
 var CORE_WORKER_SERVICES = [
   "task-worker",
   "user-init-worker",
@@ -33186,10 +33986,10 @@ function parseServerRole(value) {
   throw new Error(`Unsupported server role '${value}'. Use core, upload, or preview.`);
 }
 function defaultOpenMatesCloudOverlayPath(openMatesPath) {
-  return resolve6(join11(dirname5(resolve6(openMatesPath)), OPENMATESCLOUD_OVERLAY_DIR));
+  return resolve6(join12(dirname5(resolve6(openMatesPath)), OPENMATESCLOUD_OVERLAY_DIR));
 }
 function defaultOpenMatesCloudComposeFile(overlayPath) {
-  return resolve6(join11(overlayPath, OPENMATESCLOUD_COMPOSE_FILE));
+  return resolve6(join12(overlayPath, OPENMATESCLOUD_COMPOSE_FILE));
 }
 function planOpenMatesCloudOverlay(input) {
   const deploymentMode = input.deploymentMode ?? "self_host";
@@ -33631,11 +34431,11 @@ function publishServerBackupArchive(sourceDir, archivePath, options = {}) {
 
 // src/serverCaddyUpdate.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { accessSync, constants as constants2, existsSync as existsSync11, mkdirSync as mkdirSync10, mkdtempSync, readFileSync as readFileSync12, renameSync as renameSync5, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname6, join as join12 } from "path";
-var hash = (text4) => createHash17("sha256").update(text4).digest("hex");
+import { dirname as dirname6, join as join13 } from "path";
+var hash = (text4) => createHash18("sha256").update(text4).digest("hex");
 function resolveCaddyProfile(role, explicit, previous) {
   if (explicit === void 0) return previous ?? "self-host";
   if (role !== "upload" || explicit !== "official-upload") throw new Error("caddy_profile_unsupported");
@@ -33829,9 +34629,9 @@ function readCaddyUpdateState(path2, configPath, site) {
 function mergeCaddyRelease(current, previous, target) {
   if (previous === target) return current;
   if (current === previous) return target;
-  const directory = mkdtempSync(join12(tmpdir(), "openmates-caddy-merge-"));
+  const directory = mkdtempSync(join13(tmpdir(), "openmates-caddy-merge-"));
   try {
-    const files = ["current", "previous", "target"].map((name) => join12(directory, name));
+    const files = ["current", "previous", "target"].map((name) => join13(directory, name));
     [current, previous, target].forEach((content, i) => writeFileSync6(files[i], content, { mode: 384 }));
     try {
       return execFileSync4("diff3", ["-m", ...files], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 1e4 });
@@ -33925,7 +34725,7 @@ function caddyHostOperation(input) {
 async function applyCaddyPathUpdate(input) {
   if (!/^[a-f0-9]{40}$/i.test(input.revision)) throw new Error("caddy_release_revision_invalid");
   const current = caddyHostOperation({ action: "read", configPath: input.configPath }).content;
-  const statePath = join12(input.installPath, ".openmates", "caddy", `${input.role}.json`);
+  const statePath = join13(input.installPath, ".openmates", "caddy", `${input.role}.json`);
   const previous = readCaddyUpdateState(statePath, input.configPath, input.site);
   const merged = previous ? { content: mergeCaddyRelease(current, previous.template, input.target), paths: Object.fromEntries([...matchers(input.target, input.site, input.profile === "official-upload")].map(([name, matcher]) => [name, matcher.paths])) } : mergeCaddyPaths({ current, target: input.target, site: input.site, scopeAware: input.profile === "official-upload" });
   if (input.profile === "official-upload") validateOfficialUploadCaddy(merged.content, officialUploadOrigins(input.target));
@@ -34642,9 +35442,9 @@ function signRuntimeWebhookPayload(payload, secret, timestamp, eventId) {
 // src/serverUpdateState.ts
 import { randomBytes as randomBytes8 } from "crypto";
 import { chmodSync as chmodSync6, closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync11, openSync as openSync3, readFileSync as readFileSync13, renameSync as renameSync6, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname7, join as join13 } from "path";
+import { dirname as dirname7, join as join14 } from "path";
 function serverUpdateStatusFile(installPath, role) {
-  return join13(installPath, ".openmates", `${role}-update-status.json`);
+  return join14(installPath, ".openmates", `${role}-update-status.json`);
 }
 function readServerUpdateStatus(installPath, role) {
   const filePath = serverUpdateStatusFile(installPath, role);
@@ -34669,8 +35469,8 @@ function writeServerUpdateStatus(installPath, role, status) {
   chmodSync6(filePath, 384);
 }
 function acquireServerUpdateLock(installPath) {
-  const stateDir2 = join13(installPath, ".openmates");
-  const lockPath = join13(stateDir2, "server-update.lock");
+  const stateDir2 = join14(installPath, ".openmates");
+  const lockPath = join14(stateDir2, "server-update.lock");
   mkdirSync11(stateDir2, { recursive: true, mode: 448 });
   let descriptor;
   try {
@@ -34911,11 +35711,11 @@ async function resolveStableImageTag(fetcher = fetch) {
 
 // src/serverRuntimePaths.ts
 import { chmodSync as chmodSync7, lstatSync as lstatSync3, mkdirSync as mkdirSync12 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function ensureRuntimeMetricsDirectory(installPath) {
   let path2 = installPath;
   for (const part of [".openmates", "runtime-health", "metrics"]) {
-    path2 = join14(path2, part);
+    path2 = join15(path2, part);
     try {
       mkdirSync12(path2, { mode: 448 });
     } catch (error) {
@@ -34932,23 +35732,23 @@ function ensureRuntimeMetricsDirectory(installPath) {
 }
 
 // src/server.ts
-var SOURCE_COMPOSE_FILE = join15("backend", "core", "docker-compose.yml");
+var SOURCE_COMPOSE_FILE = join16("backend", "core", "docker-compose.yml");
 var ROLE_IMAGE_COMPOSE_FILES = {
-  core: join15("backend", "core", "docker-compose.selfhost.yml"),
-  upload: join15("backend", "upload", "docker-compose.yml"),
-  preview: join15("backend", "preview", "docker-compose.preview.yml")
+  core: join16("backend", "core", "docker-compose.selfhost.yml"),
+  upload: join16("backend", "upload", "docker-compose.yml"),
+  preview: join16("backend", "preview", "docker-compose.preview.yml")
 };
 var ROLE_TEMPLATE_FILES = {
-  core: join15("core", "docker-compose.selfhost.yml"),
-  upload: join15("upload", "docker-compose.yml"),
-  preview: join15("preview", "docker-compose.preview.yml")
+  core: join16("core", "docker-compose.selfhost.yml"),
+  upload: join16("upload", "docker-compose.yml"),
+  preview: join16("preview", "docker-compose.preview.yml")
 };
-var CORE_NO_WEBAPP_TEMPLATE_FILE = join15("core", "docker-compose.no-webapp.yml");
-var CORE_PROMTAIL_CONFIG_FILE = join15("backend", "core", "monitoring", "promtail", "promtail-config.yaml");
-var CORE_ALERTMANAGER_CONFIG_FILE = join15("backend", "core", "monitoring", "alertmanager", "alertmanager.yml");
-var CORE_PROMETHEUS_CONFIG_DIR = join15("backend", "core", "monitoring", "prometheus");
-var COMPOSE_OVERRIDE2 = join15("backend", "core", "docker-compose.override.yml");
-var DEFAULT_INSTALL_PATH = join15(homedir6(), "openmates");
+var CORE_NO_WEBAPP_TEMPLATE_FILE = join16("core", "docker-compose.no-webapp.yml");
+var CORE_PROMTAIL_CONFIG_FILE = join16("backend", "core", "monitoring", "promtail", "promtail-config.yaml");
+var CORE_ALERTMANAGER_CONFIG_FILE = join16("backend", "core", "monitoring", "alertmanager", "alertmanager.yml");
+var CORE_PROMETHEUS_CONFIG_DIR = join16("backend", "core", "monitoring", "prometheus");
+var COMPOSE_OVERRIDE2 = join16("backend", "core", "docker-compose.override.yml");
+var DEFAULT_INSTALL_PATH = join16(homedir6(), "openmates");
 var REPO_URL = "https://github.com/glowingkitty/OpenMates.git";
 var ROLE_PROVENANCE_SERVICE = {
   core: "api",
@@ -35038,8 +35838,8 @@ scrape_configs:
       - labels:
           level: log_level
 `;
-var BACKEND_CONFIG_FILE = join15("backend", "config", "backend_config.yml");
-var IMAGE_RUNTIME_CONFIG_FILE = join15("config", "backend_config.yml");
+var BACKEND_CONFIG_FILE = join16("backend", "config", "backend_config.yml");
+var IMAGE_RUNTIME_CONFIG_FILE = join16("config", "backend_config.yml");
 var LOCAL_AI_MODELS_FILE = "local-ai-models.yml";
 var OFF_BY_DEFAULT_FEATURES = /* @__PURE__ */ new Map([
   ["embed:code:application", "Application previews are still unstable"],
@@ -35175,8 +35975,8 @@ function runInteractive(cmd, args, cwd) {
   });
 }
 function beginEngineeringRuntimeOperation(installPath, operationType, services) {
-  const manager = join15(installPath, "scripts", "engineering_control_plane.py");
-  const sharedConfig = join15(homedir6(), ".config", "openmates", "engineering-control-plane.env");
+  const manager = join16(installPath, "scripts", "engineering_control_plane.py");
+  const sharedConfig = join16(homedir6(), ".config", "openmates", "engineering-control-plane.env");
   if (!existsSync13(manager) || !existsSync13(sharedConfig)) return null;
   const requestedBy = process.env.CODEX_THREAD_ID || `openmates-cli:${process.pid}`;
   const args = [
@@ -35201,7 +36001,7 @@ function beginEngineeringRuntimeOperation(installPath, operationType, services)
   return parsed.operation_key;
 }
 function finishEngineeringRuntimeOperation(installPath, operationKey, status) {
-  const manager = join15(installPath, "scripts", "engineering_control_plane.py");
+  const manager = join16(installPath, "scripts", "engineering_control_plane.py");
   execFileSync5(
     "python3",
     [manager, "operation", "update", "--operation-key", operationKey, "--status", status],
@@ -35230,8 +36030,8 @@ function loadConfigForInstallPath(installPath) {
 }
 function getInstallMode(installPath, config = loadConfigForInstallPath(installPath)) {
   if (config?.installMode) return config.installMode;
-  if (existsSync13(join15(installPath, SOURCE_COMPOSE_FILE))) return "source";
-  if (Object.values(ROLE_IMAGE_COMPOSE_FILES).some((composeFile) => existsSync13(join15(installPath, composeFile)))) return "image";
+  if (existsSync13(join16(installPath, SOURCE_COMPOSE_FILE))) return "source";
+  if (Object.values(ROLE_IMAGE_COMPOSE_FILES).some((composeFile) => existsSync13(join16(installPath, composeFile)))) return "image";
   return "source";
 }
 function getServerRole(flags, config) {
@@ -35458,7 +36258,7 @@ function composeArgs(installPath, withOverrides, installMode = getInstallMode(in
     withOverrides,
     installMode,
     role,
-    overrideExists: existsSync13(join15(installPath, COMPOSE_OVERRIDE2)),
+    overrideExists: existsSync13(join16(installPath, COMPOSE_OVERRIDE2)),
     deploymentMode,
     overlayPath,
     overlayComposeFile,
@@ -35466,7 +36266,7 @@ function composeArgs(installPath, withOverrides, installMode = getInstallMode(in
   });
 }
 function ensureGitWorkDirEnv(installPath) {
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   if (!existsSync13(envPath)) return;
   const content = readFileSync14(envPath, "utf-8");
   const lineRegex = /^GIT_WORK_DIR=.*$/m;
@@ -35594,36 +36394,36 @@ async function fetchText(url) {
   return response.text();
 }
 function packagedTemplatePath(role) {
-  return join15(dirname8(new URL(import.meta.url).pathname), "..", "templates", ROLE_TEMPLATE_FILES[role]);
+  return join16(dirname8(new URL(import.meta.url).pathname), "..", "templates", ROLE_TEMPLATE_FILES[role]);
 }
 function packagedNoWebappTemplatePath() {
-  return join15(dirname8(new URL(import.meta.url).pathname), "..", "templates", CORE_NO_WEBAPP_TEMPLATE_FILE);
+  return join16(dirname8(new URL(import.meta.url).pathname), "..", "templates", CORE_NO_WEBAPP_TEMPLATE_FILE);
 }
 function packagedCaddyTemplatePath(role) {
-  return join15(dirname8(new URL(import.meta.url).pathname), "..", "templates", "caddy", role, "Caddyfile");
+  return join16(dirname8(new URL(import.meta.url).pathname), "..", "templates", "caddy", role, "Caddyfile");
 }
 function packagedCoreAlertmanagerTemplatePath() {
-  return join15(dirname8(new URL(import.meta.url).pathname), "..", "templates", "core", "monitoring", "alertmanager", "alertmanager.yml");
+  return join16(dirname8(new URL(import.meta.url).pathname), "..", "templates", "core", "monitoring", "alertmanager", "alertmanager.yml");
 }
 function ensureCoreAlertmanagerRuntimeFile(installPath) {
   const templatePath = packagedCoreAlertmanagerTemplatePath();
   if (!existsSync13(templatePath)) throw new Error(`Packaged Alertmanager config not found: ${templatePath}`);
-  const runtimePath = join15(installPath, CORE_ALERTMANAGER_CONFIG_FILE);
+  const runtimePath = join16(installPath, CORE_ALERTMANAGER_CONFIG_FILE);
   if (fileHash(templatePath) === fileHash(runtimePath)) return;
   mkdirSync13(dirname8(runtimePath), { recursive: true });
   copyFileSync2(templatePath, runtimePath);
 }
 function ensureCorePrometheusRuntimeFiles(installPath) {
-  const packagedDir = join15(dirname8(new URL(import.meta.url).pathname), "..", "templates", "core", "monitoring", "prometheus");
-  const runtimeDir = join15(installPath, CORE_PROMETHEUS_CONFIG_DIR);
+  const packagedDir = join16(dirname8(new URL(import.meta.url).pathname), "..", "templates", "core", "monitoring", "prometheus");
+  const runtimeDir = join16(installPath, CORE_PROMETHEUS_CONFIG_DIR);
   for (const fileName of ["prometheus.yml", "alert_rules.yml"]) {
-    const packagedPath = join15(packagedDir, fileName);
+    const packagedPath = join16(packagedDir, fileName);
     if (!existsSync13(packagedPath)) throw new Error(`Packaged Prometheus file not found: ${packagedPath}`);
   }
   mkdirSync13(runtimeDir, { recursive: true });
   for (const fileName of ["prometheus.yml", "alert_rules.yml"]) {
-    const runtimePath = join15(runtimeDir, fileName);
-    if (!existsSync13(runtimePath)) copyFileSync2(join15(packagedDir, fileName), runtimePath);
+    const runtimePath = join16(runtimeDir, fileName);
+    if (!existsSync13(runtimePath)) copyFileSync2(join16(packagedDir, fileName), runtimePath);
   }
 }
 function readOfficialCloudNoWebappComposeTemplate() {
@@ -35643,19 +36443,19 @@ function readOfficialCloudNoWebappComposeTemplate() {
 }
 function ensureOfficialCloudNoWebappComposeFile(installPath, deploymentMode, role) {
   if (deploymentMode !== "official_cloud" || role !== "core") return;
-  const filePath = join15(installPath, OFFICIAL_CLOUD_NO_WEBAPP_COMPOSE_FILE);
+  const filePath = join16(installPath, OFFICIAL_CLOUD_NO_WEBAPP_COMPOSE_FILE);
   if (existsSync13(filePath)) return;
   mkdirSync13(dirname8(filePath), { recursive: true });
   writeFileSync8(filePath, readOfficialCloudNoWebappComposeTemplate());
 }
 function fileHash(path2) {
   if (!existsSync13(path2)) return null;
-  return createHash18("sha256").update(readFileSync14(path2)).digest("hex");
+  return createHash19("sha256").update(readFileSync14(path2)).digest("hex");
 }
 async function loadSelfHostComposeTemplate(templateRef, role, imageTag, packageVersion = getPackageVersion()) {
   const templateDir = process.env.OPENMATES_SELFHOST_TEMPLATE_DIR;
   if (templateDir) {
-    return readFileSync14(join15(resolve7(templateDir), ROLE_TEMPLATE_FILES[role]), "utf-8");
+    return readFileSync14(join16(resolve7(templateDir), ROLE_TEMPLATE_FILES[role]), "utf-8");
   }
   const packaged = packagedTemplatePath(role);
   const source = resolveTemplateSource({
@@ -35671,24 +36471,24 @@ async function loadSelfHostComposeTemplate(templateRef, role, imageTag, packageV
   return fetchText(`https://raw.githubusercontent.com/glowingkitty/OpenMates/${source.ref}/${source.path}`);
 }
 async function writeImageModeRuntimeFiles(installPath, imageTag, role) {
-  const roleDir = join15(installPath, "backend", role === "core" ? "core" : role);
-  const vaultConfigDir = join15(roleDir, "vault", "config");
+  const roleDir = join16(installPath, "backend", role === "core" ? "core" : role);
+  const vaultConfigDir = join16(roleDir, "vault", "config");
   mkdirSync13(vaultConfigDir, { recursive: true });
-  mkdirSync13(join15(installPath, "config", "providers"), { recursive: true });
-  writeFileSync8(join15(installPath, ROLE_IMAGE_COMPOSE_FILES[role]), await loadSelfHostComposeTemplate(templateRefForImageTag(imageTag, getPackageVersion()), role, imageTag));
+  mkdirSync13(join16(installPath, "config", "providers"), { recursive: true });
+  writeFileSync8(join16(installPath, ROLE_IMAGE_COMPOSE_FILES[role]), await loadSelfHostComposeTemplate(templateRefForImageTag(imageTag, getPackageVersion()), role, imageTag));
   if (role === "core") {
-    writeFileSync8(join15(installPath, OFFICIAL_CLOUD_NO_WEBAPP_COMPOSE_FILE), readOfficialCloudNoWebappComposeTemplate());
+    writeFileSync8(join16(installPath, OFFICIAL_CLOUD_NO_WEBAPP_COMPOSE_FILE), readOfficialCloudNoWebappComposeTemplate());
   }
   if (role === "core") {
     ensureCorePrometheusRuntimeFiles(installPath);
-    const promtailConfigPath = join15(installPath, CORE_PROMTAIL_CONFIG_FILE);
+    const promtailConfigPath = join16(installPath, CORE_PROMTAIL_CONFIG_FILE);
     mkdirSync13(dirname8(promtailConfigPath), { recursive: true });
     writeFileSync8(promtailConfigPath, SELFHOST_PROMTAIL_CONFIG_TEMPLATE);
     ensureCoreAlertmanagerRuntimeFile(installPath);
   }
-  writeFileSync8(join15(vaultConfigDir, "vault.hcl"), VAULT_CONFIG_TEMPLATE);
+  writeFileSync8(join16(vaultConfigDir, "vault.hcl"), VAULT_CONFIG_TEMPLATE);
   ensureImageRuntimeConfig(installPath);
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   let envContent = existsSync13(envPath) ? readFileSync14(envPath, "utf-8") : MINIMAL_ENV_TEMPLATE;
   envContent = setEnvIfEmpty(envContent, "DATABASE_ADMIN_PASSWORD", randomHex(12));
   envContent = setEnvIfEmpty(envContent, "DATABASE_PASSWORD", randomHex(12));
@@ -35705,7 +36505,7 @@ async function writeImageModeRuntimeFiles(installPath, imageTag, role) {
 `);
 }
 function getImageTagFromEnv(installPath, config) {
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   if (existsSync13(envPath)) {
     const envTag = getEnvVar(readFileSync14(envPath, "utf-8"), "OPENMATES_IMAGE_TAG");
     if (envTag) return envTag;
@@ -35740,7 +36540,7 @@ async function waitForServerHealth(installPath, role = "core", options = {}) {
     }
     throw new Error(`Updated ${role} server did not pass health checks in time. Tried ${healthUrl}.`);
   }
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   const envContent = existsSync13(envPath) ? readFileSync14(envPath, "utf-8") : "";
   const urls = deriveSelfHostCliUrls(envContent);
   const apiHealthUrl = `${trailingSlashTrimmed(urls.apiUrl)}/health`;
@@ -35781,7 +36581,7 @@ function hasLlmCredentials(envPath) {
   return false;
 }
 function warnIfMissingLlmCredentials(installPath) {
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   if (!existsSync13(envPath)) {
     console.error(
       "No .env file found. Run 'openmates server install' first, or create .env from .env.example."
@@ -35807,11 +36607,11 @@ function printJson(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 function localModelsOverlayPath(installPath, installMode = getInstallMode(installPath)) {
-  if (installMode === "source") return join15(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
-  return join15(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
+  if (installMode === "source") return join16(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
+  return join16(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
 }
 function imageBackendConfigPath(installPath) {
-  return join15(installPath, IMAGE_RUNTIME_CONFIG_FILE);
+  return join16(installPath, IMAGE_RUNTIME_CONFIG_FILE);
 }
 function ensureImageRuntimeConfig(installPath) {
   const configPath = imageBackendConfigPath(installPath);
@@ -35836,8 +36636,8 @@ function writeLocalModelOverlay(path2, overlay) {
 `);
 }
 function hasLocalAiModels(installPath) {
-  const imagePath = join15(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
-  const sourcePath = join15(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
+  const imagePath = join16(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
+  const sourcePath = join16(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
   return [imagePath, sourcePath].some((path2) => {
     if (!existsSync13(path2)) return false;
     try {
@@ -35880,10 +36680,10 @@ function nowStamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function backupRoot(installPath) {
-  return join15(installPath, "backups");
+  return join16(installPath, "backups");
 }
 function roleBackupDir(installPath, role) {
-  return join15(backupRoot(installPath), role);
+  return join16(backupRoot(installPath), role);
 }
 function persistQuickServerTestOutcome(installPath, role, outcome) {
   const current = readServerUpdateStatus(installPath, role);
@@ -36044,7 +36844,7 @@ function copyIfExists(source, destination) {
   cpSync(source, destination, { recursive: true, force: true });
 }
 function readEnvMap(installPath) {
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   if (!existsSync13(envPath)) return {};
   const values = {};
   for (const line of readFileSync14(envPath, "utf-8").split("\n")) {
@@ -36057,7 +36857,7 @@ function readEnvMap(installPath) {
   return values;
 }
 function envPathForInstall(installPath) {
-  return join15(installPath, ".env");
+  return join16(installPath, ".env");
 }
 function readEnvContent(installPath) {
   const envPath = envPathForInstall(installPath);
@@ -36066,13 +36866,13 @@ function readEnvContent(installPath) {
 function pruneEnvBackups(installPath) {
   const backups = readdirSync6(installPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.startsWith(ENV_BACKUP_PREFIX)).map((entry) => entry.name).sort();
   for (const backup of backups.slice(0, Math.max(0, backups.length - ENV_BACKUP_RETENTION_COUNT))) {
-    rmSync8(join15(installPath, backup), { force: true });
+    rmSync8(join16(installPath, backup), { force: true });
   }
 }
 function backupEnvFile(installPath) {
   const envPath = envPathForInstall(installPath);
   if (!existsSync13(envPath)) return null;
-  const backupPath = join15(installPath, `${ENV_BACKUP_PREFIX}${nowStamp()}`);
+  const backupPath = join16(installPath, `${ENV_BACKUP_PREFIX}${nowStamp()}`);
   copyFileSync2(envPath, backupPath);
   chmodSync8(backupPath, 384);
   pruneEnvBackups(installPath);
@@ -36293,7 +37093,7 @@ function formatSecretPreflight(preflight) {
   return parts.join("; ");
 }
 function hashFile(path2) {
-  const hash2 = createHash18("sha256");
+  const hash2 = createHash19("sha256");
   const fd = openSync4(path2, "r");
   const buffer = Buffer.allocUnsafe(CHECKSUM_BUFFER_BYTES);
   try {
@@ -36311,7 +37111,7 @@ function writeChecksums(rootDir) {
   const lines = [];
   const walk = (dir) => {
     for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-      const path2 = join15(dir, entry.name);
+      const path2 = join16(dir, entry.name);
       if (entry.isDirectory()) {
         walk(path2);
         continue;
@@ -36322,11 +37122,11 @@ function writeChecksums(rootDir) {
     }
   };
   walk(rootDir);
-  writeFileSync8(join15(rootDir, "checksums.sha256"), `${lines.sort().join("\n")}
+  writeFileSync8(join16(rootDir, "checksums.sha256"), `${lines.sort().join("\n")}
 `);
 }
 function verifyChecksums(rootDir) {
-  const checksumsPath = join15(rootDir, "checksums.sha256");
+  const checksumsPath = join16(rootDir, "checksums.sha256");
   if (!existsSync13(checksumsPath)) throw new Error("Backup archive is missing checksums.sha256.");
   for (const line of readFileSync14(checksumsPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
@@ -36337,7 +37137,7 @@ function verifyChecksums(rootDir) {
     if (relative12.startsWith("/") || relative12.split(/[\\/]/).includes("..")) {
       throw new Error(`Unsafe checksum path in backup archive: ${relative12}`);
     }
-    const filePath = join15(rootDir, relative12);
+    const filePath = join16(rootDir, relative12);
     if (!existsSync13(filePath)) throw new Error(`Backup archive is missing checksummed file: ${relative12}`);
     const actual = hashFile(filePath);
     if (actual !== match[1]) throw new Error(`Backup checksum mismatch for ${relative12}.`);
@@ -36347,27 +37147,27 @@ function createServerBackup(installPath, role, options = {}) {
   const plan = planBackup({ role, includeObservability: options.includeObservability });
   const backupDir = roleBackupDir(installPath, role);
   mkdirSync13(backupDir, { recursive: true, mode: 448 });
-  const archivePath = options.output ? resolve7(options.output) : join15(backupDir, options.preUpdate ? `latest-pre-update-${role}.tar.gz` : `openmates-${role}-${nowStamp()}.tar.gz`);
+  const archivePath = options.output ? resolve7(options.output) : join16(backupDir, options.preUpdate ? `latest-pre-update-${role}.tar.gz` : `openmates-${role}-${nowStamp()}.tar.gz`);
   mkdirSync13(dirname8(archivePath), { recursive: true, mode: 448 });
-  const tempDir = mkdtempSync2(join15(backupDir, ".tmp-"));
+  const tempDir = mkdtempSync2(join16(backupDir, ".tmp-"));
   const env = readEnvMap(installPath);
   const manifest = {
     role,
     backup_format_version: BACKUP_FORMAT_VERSION,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     cli_version: getPackageVersion(),
-    image_tag: getEnvVar(existsSync13(join15(installPath, ".env")) ? readFileSync14(join15(installPath, ".env"), "utf-8") : "", "OPENMATES_IMAGE_TAG"),
+    image_tag: getEnvVar(existsSync13(join16(installPath, ".env")) ? readFileSync14(join16(installPath, ".env"), "utf-8") : "", "OPENMATES_IMAGE_TAG"),
     recovery_scope: role === "core" ? "database-and-runtime-only" : "runtime-only",
     include_observability: false,
-    contents: plan.contents.filter((content) => content !== "runtime-env" || existsSync13(join15(installPath, ".env"))).filter((content) => content !== "runtime-config" || existsSync13(join15(installPath, "config")))
+    contents: plan.contents.filter((content) => content !== "runtime-env" || existsSync13(join16(installPath, ".env"))).filter((content) => content !== "runtime-config" || existsSync13(join16(installPath, "config")))
   };
   try {
-    copyIfExists(join15(installPath, ".env"), join15(tempDir, "runtime", ".env"));
-    copyIfExists(join15(installPath, "config"), join15(tempDir, "runtime", "config"));
+    copyIfExists(join16(installPath, ".env"), join16(tempDir, "runtime", ".env"));
+    copyIfExists(join16(installPath, "config"), join16(tempDir, "runtime", "config"));
     if (role === "core") {
       const databaseUser = env.DATABASE_USERNAME || "directus";
       const databaseName = env.DATABASE_NAME || "directus";
-      const dumpFile = openSync4(join15(tempDir, "postgres.sql"), "w");
+      const dumpFile = openSync4(join16(tempDir, "postgres.sql"), "w");
       try {
         const result = spawnSync(
           "docker",
@@ -36382,7 +37182,7 @@ function createServerBackup(installPath, role, options = {}) {
         closeSync4(dumpFile);
       }
     }
-    writeFileSync8(join15(tempDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    writeFileSync8(join16(tempDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
     writeChecksums(tempDir);
     publishServerBackupArchive(tempDir, archivePath);
@@ -36393,7 +37193,7 @@ function createServerBackup(installPath, role, options = {}) {
 }
 function validateExtractedServerBackup(tempDir, role) {
   verifyChecksums(tempDir);
-  const manifestPath = join15(tempDir, "manifest.json");
+  const manifestPath = join16(tempDir, "manifest.json");
   if (!existsSync13(manifestPath)) throw new Error("Backup archive is missing manifest.json.");
   const manifest = JSON.parse(readFileSync14(manifestPath, "utf-8"));
   if (manifest.role !== role) throw new Error(`Backup role '${manifest.role}' does not match requested role '${role}'.`);
@@ -36405,7 +37205,7 @@ function withValidatedServerBackup(installPath, role, file, useBackup, tempRoot
   const archivePath = resolve7(file);
   if (!existsSync13(archivePath)) throw new Error(`Backup file not found: ${archivePath}`);
   mkdirSync13(tempRoot, { recursive: true, mode: 448 });
-  const tempDir = mkdtempSync2(join15(tempRoot, ".restore-"));
+  const tempDir = mkdtempSync2(join16(tempRoot, ".restore-"));
   try {
     execSync(`tar -xzf ${shellQuote(archivePath)} -C ${shellQuote(tempDir)}`, { stdio: "pipe" });
     validateExtractedServerBackup(tempDir, role);
@@ -36417,9 +37217,9 @@ function withValidatedServerBackup(installPath, role, file, useBackup, tempRoot
 function restoreServerBackup(installPath, role, file) {
   withValidatedServerBackup(installPath, role, file, (tempDir) => {
     const env = readEnvMap(installPath);
-    copyIfExists(join15(tempDir, "runtime", ".env"), join15(installPath, ".env"));
-    copyIfExists(join15(tempDir, "runtime", "config"), join15(installPath, "config"));
-    const postgresDump = join15(tempDir, "postgres.sql");
+    copyIfExists(join16(tempDir, "runtime", ".env"), join16(installPath, ".env"));
+    copyIfExists(join16(tempDir, "runtime", "config"), join16(installPath, "config"));
+    const postgresDump = join16(tempDir, "postgres.sql");
     if (role === "core" && existsSync13(postgresDump)) {
       const databaseUser = env.DATABASE_USERNAME || "directus";
       const databaseName = env.DATABASE_NAME || "directus";
@@ -36706,9 +37506,9 @@ async function serverRegister(flags) {
   const installPath = resolveServerPath(
     typeof flags.path === "string" ? flags : { ...flags, path: process.cwd() }
   );
-  const envPath = join15(installPath, ".env");
-  if (!existsSync13(join15(installPath, SOURCE_COMPOSE_FILE))) {
-    throw new Error(`Source Compose file not found: ${join15(installPath, SOURCE_COMPOSE_FILE)}`);
+  const envPath = join16(installPath, ".env");
+  if (!existsSync13(join16(installPath, SOURCE_COMPOSE_FILE))) {
+    throw new Error(`Source Compose file not found: ${join16(installPath, SOURCE_COMPOSE_FILE)}`);
   }
   if (!existsSync13(envPath)) {
     throw new Error(`Runtime env file not found: ${envPath}`);
@@ -36784,7 +37584,7 @@ async function serverInstall(flags) {
     withAlerts: flags["with-alerts"] === true,
     includeWebapp: deploymentMode !== "official_cloud"
   });
-  if (existsSync13(join15(installPath, SOURCE_COMPOSE_FILE)) || Object.values(ROLE_IMAGE_COMPOSE_FILES).some((composeFile) => existsSync13(join15(installPath, composeFile)))) {
+  if (existsSync13(join16(installPath, SOURCE_COMPOSE_FILE)) || Object.values(ROLE_IMAGE_COMPOSE_FILES).some((composeFile) => existsSync13(join16(installPath, composeFile)))) {
     console.error(`OpenMates already exists at ${installPath}.`);
     console.error("Use 'openmates server update' to update, or choose a different --path.");
     process.exit(1);
@@ -36798,7 +37598,7 @@ async function serverInstall(flags) {
       if (!existsSync13(envSource)) {
         throw new Error(`Env file not found: ${envSource}`);
       }
-      copyFileSync2(envSource, join15(installPath, ".env"));
+      copyFileSync2(envSource, join16(installPath, ".env"));
       console.error(`Copied ${envSource} to ${installPath}/.env`);
     }
     const requestedImageTag = typeof flags["image-tag"] === "string" ? flags["image-tag"] : getDefaultImageTag();
@@ -36806,7 +37606,7 @@ async function serverInstall(flags) {
     console.error(`Preparing OpenMates image-mode install at ${installPath}...`);
     await writeImageModeRuntimeFiles(installPath, imageTag, role);
     const overlay2 = writeDeploymentModeEnv(installPath, deploymentMode, requestedOverlayPath);
-    const cliUrls2 = deriveSelfHostCliUrls(readFileSync14(join15(installPath, ".env"), "utf-8"));
+    const cliUrls2 = deriveSelfHostCliUrls(readFileSync14(join16(installPath, ".env"), "utf-8"));
     try {
       exec("docker network create openmates", installPath);
     } catch {
@@ -36834,7 +37634,7 @@ async function serverInstall(flags) {
     if (flags.json === true) {
       printJson({ command: "install", status: "success", path: installPath, mode: "image", imageTag });
     } else {
-      const firstInvite = getEnvVar(readFileSync14(join15(installPath, ".env"), "utf-8"), "SELF_HOST_FIRST_INVITE_CODE");
+      const firstInvite = getEnvVar(readFileSync14(join16(installPath, ".env"), "utf-8"), "SELF_HOST_FIRST_INVITE_CODE");
       console.log(`
 OpenMates installed at ${installPath}`);
       console.log(`Mode: image (${DEFAULT_IMAGE_REGISTRY}, tag ${imageTag})`);
@@ -36876,7 +37676,7 @@ CLI default API: ${cliUrls2.apiUrl}`);
     if (!existsSync13(envSource)) {
       throw new Error(`Env file not found: ${envSource}`);
     }
-    copyFileSync2(envSource, join15(installPath, ".env"));
+    copyFileSync2(envSource, join16(installPath, ".env"));
     console.error(`Copied ${envSource} to ${installPath}/.env`);
   }
   const translationResult = ensureSourceInstallTranslations(installPath, sourcePath);
@@ -36895,7 +37695,7 @@ CLI default API: ${cliUrls2.apiUrl}`);
     console.error("Setup script failed. Check the output above for details.");
     process.exit(setupCode);
   }
-  const envPath = join15(installPath, ".env");
+  const envPath = join16(installPath, ".env");
   const overlay = writeDeploymentModeEnv(installPath, deploymentMode, requestedOverlayPath);
   const cliUrls = deriveSelfHostCliUrls(existsSync13(envPath) ? readFileSync14(envPath, "utf-8") : "");
   saveServerConfig({
@@ -36938,8 +37738,8 @@ async function installContinuousUpdateService(flags) {
   const channel = typeof flags.channel === "string" ? flags.channel : config?.imageChannel ?? "stable";
   const window = typeof flags.window === "string" ? flags.window : "02:00-04:00 UTC";
   const plan = planContinuousUpdateService({ role, channel, window });
-  const servicePath = join15("/etc", "systemd", "system", plan.serviceName);
-  const timerPath = join15("/etc", "systemd", "system", plan.timerName);
+  const servicePath = join16("/etc", "systemd", "system", plan.serviceName);
+  const timerPath = join16("/etc", "systemd", "system", plan.timerName);
   if (flags["dry-run"] === true || flags.json === true) {
     printJson({ command: "update install-service", status: "planned", role, servicePath, timerPath, unit: plan.unit, timer: plan.timer });
     return;
@@ -36979,12 +37779,12 @@ function inspectCmsCacheConsistency(installPath, withOverrides, installMode) {
   });
 }
 function runRuntimeVerification(installPath, role, config) {
-  const envText = existsSync13(join15(installPath, ".env")) ? readFileSync14(join15(installPath, ".env"), "utf-8") : "";
+  const envText = existsSync13(join16(installPath, ".env")) ? readFileSync14(join16(installPath, ".env"), "utf-8") : "";
   const mode = resolveRuntimeDeploymentMode({
     envText,
     overlayExists: existsSync13(config?.openMatesCloudOverlayPath ?? defaultOpenMatesCloudOverlayPath(installPath))
   });
-  const backupPath = join15(roleBackupDir(installPath, role), `latest-pre-update-${role}.tar.gz`);
+  const backupPath = join16(roleBackupDir(installPath, role), `latest-pre-update-${role}.tar.gz`);
   const plan = planRuntimeVerification({ role, deploymentMode: mode.effectiveMode, hasVerifiedBackup: existsSync13(backupPath) });
   const verifierService = { core: "api", upload: "app-uploads", preview: "preview" }[role];
   const installMode = getInstallMode(installPath, config);
@@ -37178,10 +37978,10 @@ async function installRuntimeMonitoringServices(installPath, role) {
       [operationalPlan.watchdogTimerName, operationalPlan.watchdogTimer]
     ] : []
   ].filter((entry) => Boolean(entry[0] && entry[1]));
-  const reportStatePath = join15(installPath, ".openmates", "runtime-health", `${role}-operational-report.json`);
-  const reportMetricsDir = join15(installPath, ".openmates", "runtime-health", "metrics");
-  const startedMetricPath = join15(reportMetricsDir, "operational-report-started.prom");
-  const successMetricPath = join15(reportMetricsDir, "operational-report.prom");
+  const reportStatePath = join16(installPath, ".openmates", "runtime-health", `${role}-operational-report.json`);
+  const reportMetricsDir = join16(installPath, ".openmates", "runtime-health", "metrics");
+  const startedMetricPath = join16(reportMetricsDir, "operational-report-started.prom");
+  const successMetricPath = join16(reportMetricsDir, "operational-report.prom");
   const operationalUnitNames = [
     operationalPlan.digestServiceName,
     operationalPlan.digestTimerName,
@@ -37208,17 +38008,17 @@ async function installRuntimeMonitoringServices(installPath, role) {
       );
     }
   } else {
-    const installedOperationalUnits = operationalUnitNames.filter((name) => existsSync13(join15("/etc", "systemd", "system", name)));
+    const installedOperationalUnits = operationalUnitNames.filter((name) => existsSync13(join16("/etc", "systemd", "system", name)));
     const installedOperationalTimers = installedOperationalUnits.filter((name) => name.endsWith(".timer"));
     if (installedOperationalTimers.length) {
       execFileSync5("systemctl", ["disable", "--now", ...installedOperationalTimers], { stdio: "pipe" });
     }
-    for (const name of installedOperationalUnits) rmSync8(join15("/etc", "systemd", "system", name));
+    for (const name of installedOperationalUnits) rmSync8(join16("/etc", "systemd", "system", name));
     for (const path2 of [reportStatePath, startedMetricPath, successMetricPath]) {
       if (existsSync13(path2)) rmSync8(path2);
     }
   }
-  for (const [name, content] of files) writeFileSync8(join15("/etc", "systemd", "system", name), content, { mode: 420 });
+  for (const [name, content] of files) writeFileSync8(join16("/etc", "systemd", "system", name), content, { mode: 420 });
   execSync("systemctl daemon-reload", { stdio: "pipe" });
   const timers = files.filter(([name]) => name.endsWith(".timer")).map(([name]) => name);
   execSync(`systemctl enable --now ${timers.map(shellQuote).join(" ")}`, { stdio: "pipe" });
@@ -37237,7 +38037,7 @@ function caddyUpdatePlan(installPath, role, config, flags) {
   const configPath = resolve7(typeof flags["caddy-config"] === "string" ? flags["caddy-config"] : "/etc/caddy/Caddyfile");
   const required = role === "core" && getInstallDeploymentMode(installPath, config) === "official_cloud";
   if (!existsSync13(configPath) && required) throw new Error("Managed cloud Caddyfile is missing; update cannot proceed.");
-  const prior = role === "upload" ? readCaddyUpdateState(join15(installPath, ".openmates", "caddy", `${role}.json`), configPath, null) : void 0;
+  const prior = role === "upload" ? readCaddyUpdateState(join16(installPath, ".openmates", "caddy", `${role}.json`), configPath, null) : void 0;
   const profile = resolveCaddyProfile(role, flags["caddy-profile"], prior ? prior.profile ?? "self-host" : void 0);
   if (profile === "official-upload" && !existsSync13(configPath)) throw new Error("caddy_official_upload_host_missing");
   if (role === "upload" && existsSync13(configPath)) {
@@ -37268,7 +38068,7 @@ async function updateServerCaddy(input) {
   if (!revision || !/^[a-f0-9]{40}$/i.test(revision)) throw new Error("caddy_release_revision_invalid");
   let target;
   if (input.mode === "source") {
-    target = readFileSync14(join15(input.installPath, templatePath), "utf8");
+    target = readFileSync14(join16(input.installPath, templatePath), "utf8");
   } else {
     const response = await fetch(`https://raw.githubusercontent.com/glowingkitty/OpenMates/${revision}/${templatePath}`, { signal: AbortSignal.timeout(15e3), redirect: "error" });
     if (!response.ok) throw new Error("caddy_release_template_unavailable");
@@ -37599,7 +38399,7 @@ async function serverUpdate(client2, rest, flags) {
       try {
         await autoInstallRuntimeMonitoringServices(installPath, role);
       } catch (error) {
-        const restoreCommand = safetyPlan.backupName ? `openmates server restore --role ${role} --file ${join15(roleBackupDir(installPath, role), safetyPlan.backupName)}` : null;
+        const restoreCommand = safetyPlan.backupName ? `openmates server restore --role ${role} --file ${join16(roleBackupDir(installPath, role), safetyPlan.backupName)}` : null;
         writeServerUpdateStatus(installPath, role, {
           status: "degraded",
           targetImageTag: target.tag,
@@ -37962,11 +38762,11 @@ async function serverMonitoring(rest, flags) {
     const state2 = await readOperationalReportState(installPath, role);
     const nextState2 = accepted ? { ...state2, incidentOpen: false, incidentOpenedAt: void 0, lastAcceptedReportAt: (/* @__PURE__ */ new Date()).toISOString() } : state2;
     await writeOperationalReportState(installPath, role, nextState2);
-    const metricsDir = join15(installPath, ".openmates", "runtime-health", "metrics");
+    const metricsDir = join16(installPath, ".openmates", "runtime-health", "metrics");
     mkdirSync13(metricsDir, { recursive: true, mode: 448 });
     if (accepted) {
       writeFileSync8(
-        join15(metricsDir, "operational-report.prom"),
+        join16(metricsDir, "operational-report.prom"),
         `operational_report_last_success_timestamp_seconds{environment="${output2.receipts[0]?.environment ?? environment}"} ${Math.floor(Date.now() / 1e3)}
 `,
         { mode: 384 }
@@ -37984,11 +38784,11 @@ async function serverMonitoring(rest, flags) {
       destinationSource: receipt.destination_source,
       fallbackUsed: receipt.fallback_used
     }));
-    const receiptDir = join15(installPath, ".openmates", "runtime-health", "receipts");
+    const receiptDir = join16(installPath, ".openmates", "runtime-health", "receipts");
     mkdirSync13(receiptDir, { recursive: true, mode: 448 });
     const receiptMonth = (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
     for (const receipt of redactedReceipts) {
-      appendFileSync(join15(receiptDir, `${receiptMonth}.jsonl`), `${JSON.stringify(receipt)}
+      appendFileSync(join16(receiptDir, `${receiptMonth}.jsonl`), `${JSON.stringify(receipt)}
 `, { mode: 384 });
     }
     const displayed = { command: "monitoring digest", reportId: output2.report_id, reportSha256: output2.report_sha256, deliveryState: output2.delivery_state, receipts: redactedReceipts };
@@ -38193,7 +38993,7 @@ async function serverFeatures(rest, flags) {
   const installPath = resolveServerPath(flags);
   const installMode = getInstallMode(installPath);
   if (installMode === "image") ensureImageRuntimeConfig(installPath);
-  const configPath = installMode === "image" ? imageBackendConfigPath(installPath) : join15(installPath, BACKEND_CONFIG_FILE);
+  const configPath = installMode === "image" ? imageBackendConfigPath(installPath) : join16(installPath, BACKEND_CONFIG_FILE);
   if (!existsSync13(configPath)) {
     throw new Error(`Backend config not found at ${configPath}. Run 'openmates server install' first or pass --path <dir>.`);
   }
@@ -38443,7 +39243,7 @@ async function serverBackup(rest, flags) {
       console.log("  none");
       return;
     }
-    for (const file of files) console.log(`  ${join15(dir, file)}`);
+    for (const file of files) console.log(`  ${join16(dir, file)}`);
     return;
   }
   requireDocker();
@@ -38990,7 +39790,7 @@ async function handleServer(client2, subcommand, rest, flags) {
 }
 
 // src/codeRunInput.ts
-import { readdir, readFile, stat as stat2 } from "fs/promises";
+import { readdir, readFile as readFile2, stat as stat2 } from "fs/promises";
 import { basename as basename3, relative as relative2, resolve as resolve8 } from "path";
 var CODE_RUN_MAX_FILES = 50;
 var CODE_RUN_MAX_FILE_BYTES = 1e6;
@@ -39036,7 +39836,7 @@ async function buildCodeRunRequestsFromFlags(flags) {
   }
   for (const filePath of toList(flags.file)) {
     const absolute = resolve8(filePath);
-    const buffer = await readFile(absolute);
+    const buffer = await readFile2(absolute);
     const sandboxPath = normalizeCodeRunPath(basename3(filePath));
     addFile({
       path: sandboxPath,
@@ -39051,7 +39851,7 @@ async function buildCodeRunRequestsFromFlags(flags) {
     const dirFiles = await collectDirectoryFiles(root, flags.include, flags.exclude);
     for (const absolute of dirFiles) {
       const sandboxPath = normalizeCodeRunPath(relative2(root, absolute).replace(/\\/g, "/"));
-      const buffer = await readFile(absolute);
+      const buffer = await readFile2(absolute);
       addFile({
         path: sandboxPath,
         content_base64: buffer.toString("base64"),
@@ -81400,10 +82200,10 @@ function buildAssistantFeedbackDecision(rating) {
 }
 
 // src/benchmark.ts
-import { createHash as createHash19, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash20, randomUUID as randomUUID16 } from "crypto";
 import { existsSync as existsSync14, mkdtempSync as mkdtempSync3, readFileSync as readFileSync15, readdirSync as readdirSync7, writeFileSync as writeFileSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname9, join as join16, resolve as resolve9 } from "path";
+import { dirname as dirname9, join as join17, resolve as resolve9 } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_JUDGE_MODEL = "google/gemini-3-flash-preview";
 var DEFAULT_PROMPT_BUDGET_MODEL = "google/gemini-3.5-flash";
@@ -82571,7 +83371,7 @@ function loadProviderPricing() {
   if (!providersDir) return pricing;
   for (const fileName of readdirSync7(providersDir)) {
     if (!fileName.endsWith(".yml")) continue;
-    const filePath = join16(providersDir, fileName);
+    const filePath = join17(providersDir, fileName);
     const text4 = readFileSync15(filePath, "utf-8");
     const provider = parseProviderId(text4) ?? fileName.replace(/\.yml$/, "");
     for (const modelPricing of parseModelPricing(text4, provider)) {
@@ -82626,9 +83426,9 @@ function findProvidersDir() {
   const currentFile = fileURLToPath(import.meta.url);
   let current = dirname9(currentFile);
   for (let index = 0; index < 8; index += 1) {
-    const candidate = join16(current, "backend", "providers");
+    const candidate = join17(current, "backend", "providers");
     if (existsSync14(candidate)) return candidate;
-    const parentCandidate = join16(current, "..", "..", "backend", "providers");
+    const parentCandidate = join17(current, "..", "..", "backend", "providers");
     if (existsSync14(parentCandidate)) return resolve9(parentCandidate);
     const next = dirname9(current);
     if (next === current) break;
@@ -82834,14 +83634,14 @@ function hashPromptBudgetCorpus(cases) {
   return stableHash(cases.map((benchmarkCase) => ({ id: benchmarkCase.id, turns: benchmarkCase.turns })));
 }
 function stableHash(value) {
-  return createHash19("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash20("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function defaultImageFixturePath() {
-  const fixtureDir = join16(dirname9(fileURLToPath(import.meta.url)), "..", "fixtures");
-  const fixturePath = join16(fixtureDir, "brandenburger-tor.png");
+  const fixtureDir = join17(dirname9(fileURLToPath(import.meta.url)), "..", "fixtures");
+  const fixturePath = join17(fixtureDir, "brandenburger-tor.png");
   if (existsSync14(fixturePath)) return fixturePath;
-  const tempDir = mkdtempSync3(join16(tmpdir3(), "openmates-benchmark-"));
-  const tempPath = join16(tempDir, "brandenburger-tor.svg");
+  const tempDir = mkdtempSync3(join17(tmpdir3(), "openmates-benchmark-"));
+  const tempPath = join17(tempDir, "brandenburger-tor.svg");
   writeFileSync9(tempPath, FIXTURE_IMAGE_SVG, "utf-8");
   return tempPath;
 }
@@ -83521,7 +84321,7 @@ var APP_GRADIENTS = {
 var PRIMARY_GRADIENT = { "start": "#4867cd", "end": "#5a85eb" };
 
 // src/tuiProjectsWorkspace.ts
-import { createHash as createHash20, randomBytes as randomBytes10, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash21, randomBytes as randomBytes10, randomUUID as randomUUID17 } from "crypto";
 
 // src/tuiForms.ts
 function formValue(form, name) {
@@ -83697,7 +84497,7 @@ async function loadTuiProject(client2, id) {
     client2.listProjectSources(id, context)
   ]);
   const folderIds = itemsResponse.folders.map((folder) => String(folder.folder_id ?? "")).filter(Boolean);
-  const folderByHash = new Map(folderIds.map((folderId) => [createHash20("sha256").update(folderId).digest("hex"), folderId]));
+  const folderByHash = new Map(folderIds.map((folderId) => [createHash21("sha256").update(folderId).digest("hex"), folderId]));
   project.folders = await Promise.all(itemsResponse.folders.filter((folder) => typeof folder.folder_id === "string" && folder.folder_id).map(async (folder) => {
     const parentHash = typeof folder.hashed_parent_folder_id === "string" ? folder.hashed_parent_folder_id : typeof folder.parent_folder_id === "string" && folderByHash.has(folder.parent_folder_id) ? folder.parent_folder_id : void 0;
     return {
@@ -83957,7 +84757,7 @@ async function submitProjectForm(client2, form) {
     encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: focus }), key),
     key_wrappers: wrapping.teamId ? [{
       key_type: "team",
-      hashed_team_id: createHash20("sha256").update(wrapping.teamId).digest("hex"),
+      hashed_team_id: createHash21("sha256").update(wrapping.teamId).digest("hex"),
       team_key_epoch: 1,
       encrypted_project_key: await encryptBytesWithAesGcm(key, wrapping.key),
       wrapper_version: 1,
@@ -88020,13 +88820,13 @@ function clamp(value, min, max) {
 }
 
 // src/codexTaskBridge.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync16, readdirSync as readdirSync8 } from "fs";
-import { isAbsolute as isAbsolute4, join as join17, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute4, join as join18, resolve as resolve10 } from "path";
 import lockfile5 from "proper-lockfile";
 function startCodexTaskBridges(roots, snapshots, stateRoot, notice) {
-  const configPath = join17(stateRoot, "codex-adapter.json");
+  const configPath = join18(stateRoot, "codex-adapter.json");
   const children = [];
   if (existsSync15(configPath)) {
     const config = JSON.parse(readFileSync16(configPath, "utf8"));
@@ -88063,13 +88863,13 @@ async function flushCodexChatDeletions(client2, teamId, stateRoot, notice) {
   const session = client2.getSession();
   const scope2 = [session.apiUrl, session.hashedEmail, teamId || "personal"];
   const account = JSON.stringify(scope2);
-  const directory = join17(stateRoot, "codex-chat-deletions", createHash21("sha256").update(account).digest("hex"));
+  const directory = join18(stateRoot, "codex-chat-deletions", createHash22("sha256").update(account).digest("hex"));
   if (!existsSync15(directory)) return;
   const release2 = await lockfile5.lock(directory, { retries: 0, stale: 24e4 });
   try {
     let attempts = 0;
     for (const name of readdirSync8(directory).filter((name2) => /^[a-f0-9]{64}\.json$/.test(name2)).sort()) {
-      const path2 = join17(directory, name);
+      const path2 = join18(directory, name);
       const record7 = JSON.parse(readFileSync16(path2, "utf8"));
       if (record7.state !== "pending") continue;
       if (attempts++ >= 3) break;
@@ -88097,18 +88897,18 @@ async function flushCodexChatDeletions(client2, teamId, stateRoot, notice) {
 }
 
 // src/taskCommandDelivery.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { existsSync as existsSync16, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import lockfile6 from "proper-lockfile";
 async function flushTaskCommands(client2, teamId, root = resolveStateDir(), onNotice) {
   const session = client2.getSession();
   const scope2 = [session.apiUrl, session.hashedEmail, teamId || "personal"];
-  const directory = join18(root, "task-command-delivery", createHash22("sha256").update(JSON.stringify(scope2)).digest("hex"));
+  const directory = join19(root, "task-command-delivery", createHash23("sha256").update(JSON.stringify(scope2)).digest("hex"));
   if (!existsSync16(directory)) return;
   const release2 = await lockfile6.lock(directory, { retries: 0, stale: 24e4 });
   try {
-    const records = readdirSync9(directory).filter((name) => /^[a-f0-9]{64}\.json$/.test(name)).map((name) => ({ path: join18(directory, name), command: JSON.parse(readFileSync17(join18(directory, name), "utf8")) })).sort((a, b) => a.command.created_at - b.command.created_at);
+    const records = readdirSync9(directory).filter((name) => /^[a-f0-9]{64}\.json$/.test(name)).map((name) => ({ path: join19(directory, name), command: JSON.parse(readFileSync17(join19(directory, name), "utf8")) })).sort((a, b) => a.command.created_at - b.command.created_at);
     let attempted = 0;
     for (const { path: path2, command } of records) {
       if (command.state !== "pending") continue;
@@ -88214,8 +89014,8 @@ import {
   writeFileSync as writeFileSync13
 } from "fs";
 import { spawn as spawn7 } from "child_process";
-import { createHash as createHash28 } from "crypto";
-import { extname as extname4, join as join25, resolve as resolve16, relative as relative11 } from "path";
+import { createHash as createHash29 } from "crypto";
+import { extname as extname4, join as join26, resolve as resolve16, relative as relative11 } from "path";
 
 // src/projectSourceRootPolicy.ts
 import { existsSync as existsSync17, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
@@ -88249,7 +89049,7 @@ function isEqualOrInside(parent, candidate) {
 }
 
 // src/projectPathPolicy.ts
-import { createHash as createHash23, randomBytes as randomBytes12 } from "crypto";
+import { createHash as createHash24, randomBytes as randomBytes12 } from "crypto";
 import {
   chmodSync as chmodSync9,
   closeSync as closeSync5,
@@ -88269,7 +89069,7 @@ import {
   unlinkSync,
   writeSync
 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute5, join as join19, relative as relative4, resolve as resolve12 } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute5, join as join20, relative as relative4, resolve as resolve12 } from "path";
 var DEFAULT_MAX_IGNORE_FILES = 128;
 var DEFAULT_MAX_IGNORE_BYTES = 1024 * 1024;
 var MAX_POLICY_ENTRIES = 5e4;
@@ -88362,7 +89162,7 @@ function loadProjectPathPolicy(sourceRoot, options = {}) {
 function findGitPolicyRoot(sourceRoot) {
   let current = sourceRoot;
   while (true) {
-    if (existsSync18(join19(current, ".git"))) return current;
+    if (existsSync18(join20(current, ".git"))) return current;
     const parent = dirname11(current);
     if (parent === current) return sourceRoot;
     current = parent;
@@ -88392,7 +89192,7 @@ function collectIgnoreFiles(policyRoot, sourceRoot, limits) {
     if (parent === current || !isInside2(policyRoot, parent)) throw new Error("Source root is outside its Git policy root");
     current = parent;
   }
-  for (const directory of chain.reverse()) add(join19(directory, ".gitignore"));
+  for (const directory of chain.reverse()) add(join20(directory, ".gitignore"));
   for (const target of limits.targetPaths) {
     const normalized = target === "." ? "" : normalizeSourceRelativePath(target);
     const absolute = normalized ? resolve12(sourceRoot, normalized) : sourceRoot;
@@ -88406,7 +89206,7 @@ function collectIgnoreFiles(policyRoot, sourceRoot, limits) {
       directory = dirname11(directory);
     }
     for (const ancestor of ancestors.reverse()) {
-      const ignorePath = join19(ancestor, ".gitignore");
+      const ignorePath = join20(ancestor, ".gitignore");
       if (!files.some((file) => file.path === normalizeRelative(policyRoot, ignorePath))) add(ignorePath);
     }
   }
@@ -88419,7 +89219,7 @@ function collectIgnoreFiles(policyRoot, sourceRoot, limits) {
     for (const entry of readdirSync10(directory, { withFileTypes: true })) {
       if (++entries > limits.maxEntries) throw new Error("Project path policy scan exceeds its entry limit");
       if (entry.name === ".git" || entry.isSymbolicLink() || !entry.isDirectory()) continue;
-      const child = join19(directory, entry.name);
+      const child = join20(directory, entry.name);
       const canonical = realpathSync3(child);
       if (!isInside2(sourceRoot, canonical) || seen.has(canonical)) continue;
       const sourceRelative = normalizeRelative(sourceRoot, child);
@@ -88427,7 +89227,7 @@ function collectIgnoreFiles(policyRoot, sourceRoot, limits) {
       if (limits.privatePolicy.isPrivate(sourceRelative, true) || currentPolicy.isIgnored(policyRelative, true)) continue;
       seen.add(canonical);
       const before = files.length;
-      add(join19(child, ".gitignore"));
+      add(join20(child, ".gitignore"));
       if (files.length !== before) currentPolicy = createProjectPathPolicy({ ignoreFiles: files, privatePaths: [] });
       directories.push(child);
     }
@@ -88440,10 +89240,10 @@ function updateStickyPrivatePaths(sourceRoot, additions, stateDirectory) {
     throw new Error("Project path policy state must stay outside the source root");
   }
   const key = sha2563(realpathSync3(sourceRoot));
-  const path2 = join19(stateRoot, `${key}.json`);
+  const path2 = join20(stateRoot, `${key}.json`);
   if (additions.length === 0 && !existsSync18(path2)) return [];
   preparePrivateDirectory(stateRoot);
-  const lock = join19(stateRoot, `${key}.lock`);
+  const lock = join20(stateRoot, `${key}.lock`);
   try {
     mkdirSync14(lock, { mode: 448 });
   } catch (error) {
@@ -88530,7 +89330,7 @@ function isInside2(root, candidate) {
   return relation === "" || !relation.startsWith("..") && !isAbsolute5(relation);
 }
 function sha2563(value) {
-  return createHash23("sha256").update(value).digest("hex");
+  return createHash24("sha256").update(value).digest("hex");
 }
 function stableJson2(value) {
   return JSON.stringify(value, (_key, item) => {
@@ -88540,7 +89340,7 @@ function stableJson2(value) {
 }
 
 // src/remoteFileWrites.ts
-import { createHash as createHash24, randomBytes as randomBytes13 } from "crypto";
+import { createHash as createHash25, randomBytes as randomBytes13 } from "crypto";
 import {
   chmodSync as chmodSync10,
   closeSync as closeSync7,
@@ -88560,7 +89360,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { basename as basename5, dirname as dirname12, isAbsolute as isAbsolute6, join as join21, relative as relative5, resolve as resolve13 } from "path";
+import { basename as basename5, dirname as dirname12, isAbsolute as isAbsolute6, join as join22, relative as relative5, resolve as resolve13 } from "path";
 import lockfile7 from "proper-lockfile";
 
 // src/projectFileRisk.ts
@@ -88632,7 +89432,7 @@ function matchesAdditionalPrivatePattern(path2, patterns) {
 // src/remoteCommandSourceLock.ts
 import { closeSync as closeSync6, constants as constants4, lstatSync as lstatSync5, mkdirSync as mkdirSync15, openSync as openSync6, realpathSync as realpathSync4, statSync as statSync4 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { spawn as spawn4, spawnSync as spawnSync2 } from "child_process";
 var RemoteProjectSourceLockError = class extends Error {
   constructor(message) {
@@ -88683,15 +89483,15 @@ async function acquireRemoteProjectFileEditLock(sourceRoot, options = {}) {
   let abortListener = null;
   await new Promise((resolvePromise, reject) => {
     let stderr2 = "";
-    const onError = (error) => fail3(`Failed to start Project lock holder: ${error.message}`);
-    const onExit = (code, signal) => fail3(`Project lock holder exited before acquisition (${signal ?? code}): ${stderr2.trim()}`);
+    const onError = (error) => fail4(`Failed to start Project lock holder: ${error.message}`);
+    const onExit = (code, signal) => fail4(`Project lock holder exited before acquisition (${signal ?? code}): ${stderr2.trim()}`);
     const cleanup = () => {
       if (timer) clearTimeout(timer);
       if (abortListener && options.signal) options.signal.removeEventListener("abort", abortListener);
       child.removeListener("error", onError);
       child.removeListener("exit", onExit);
     };
-    const fail3 = (message) => {
+    const fail4 = (message) => {
       cleanup();
       child.kill("SIGKILL");
       reject(new RemoteProjectSourceLockError(message));
@@ -88702,13 +89502,13 @@ async function acquireRemoteProjectFileEditLock(sourceRoot, options = {}) {
     child.once("error", onError);
     child.once("exit", onExit);
     child.stdout.once("data", (chunk) => {
-      if (chunk[0] !== LOCK_READY_BYTE) return fail3("Project lock holder returned an invalid readiness signal");
+      if (chunk[0] !== LOCK_READY_BYTE) return fail4("Project lock holder returned an invalid readiness signal");
       cleanup();
       resolvePromise();
     });
-    timer = setTimeout(() => fail3(`Timed out waiting ${timeoutMs}ms for the Project file-edit lock`), timeoutMs);
+    timer = setTimeout(() => fail4(`Timed out waiting ${timeoutMs}ms for the Project file-edit lock`), timeoutMs);
     if (options.signal) {
-      abortListener = () => fail3("Project lock acquisition was canceled");
+      abortListener = () => fail4("Project lock acquisition was canceled");
       options.signal.addEventListener("abort", abortListener, { once: true });
     }
   });
@@ -88769,9 +89569,9 @@ function remoteProjectSourceLockPath(sourceRoot) {
   if (!stat3.isDirectory()) throw new RemoteProjectSourceLockError("Project source root must be a directory");
   const uid = typeof process.getuid === "function" ? process.getuid() : null;
   if (uid === null) throw new RemoteProjectSourceLockError("Project source locks require a numeric user identity");
-  const directory = join20(tmpdir4(), `openmates-project-source-locks-${uid}`);
+  const directory = join21(tmpdir4(), `openmates-project-source-locks-${uid}`);
   preparePrivateDirectory2(directory, uid);
-  const lockPath = join20(directory, "source-writes.lock");
+  const lockPath = join21(directory, "source-writes.lock");
   const descriptor = openSync6(lockPath, constants4.O_CREAT | constants4.O_RDWR | constants4.O_NOFOLLOW, 384);
   closeSync6(descriptor);
   const lockStat = lstatSync5(lockPath);
@@ -88802,10 +89602,10 @@ var RemoteFileMutationError = class extends Error {
   }
 };
 var MAX_FILE_BYTES2 = 200 * 1024;
-var LOCK_ROOT = join21(tmpdir5(), `openmates-remote-file-locks-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
-var DEFAULT_JOURNAL_ROOT = join21(tmpdir5(), `openmates-remote-file-journal-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
+var LOCK_ROOT = join22(tmpdir5(), `openmates-remote-file-locks-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
+var DEFAULT_JOURNAL_ROOT = join22(tmpdir5(), `openmates-remote-file-journal-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
 function sha256ProjectFile(content) {
-  return createHash24("sha256").update(content).digest("hex");
+  return createHash25("sha256").update(content).digest("hex");
 }
 async function executeRemoteFileMutation(options) {
   const mutation = validateMutation(options.mutation);
@@ -88820,7 +89620,7 @@ async function executeRemoteFileMutation(options) {
   }
   const scopeDigest = sha256ProjectFile(options.operationScope);
   const payloadDigest = sha256ProjectFile(stableJson3(mutation));
-  const journalPath = join21(journalRoot, scopeDigest, `${sha256ProjectFile(`${options.operationScope}\0${mutation.operation_id}`)}.json`);
+  const journalPath = join22(journalRoot, scopeDigest, `${sha256ProjectFile(`${options.operationScope}\0${mutation.operation_id}`)}.json`);
   preparePrivateDirectory3(dirname12(journalPath));
   await options.authorize();
   const existingJournal = readJournal(journalPath);
@@ -88985,7 +89785,7 @@ function openPinnedParent(root, path2) {
 function readPinnedFile(parent) {
   let descriptor;
   try {
-    descriptor = openSync7(join21(parent.procPath, parent.targetName), constants5.O_RDONLY | constants5.O_NOFOLLOW);
+    descriptor = openSync7(join22(parent.procPath, parent.targetName), constants5.O_RDONLY | constants5.O_NOFOLLOW);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     if (error.code === "ELOOP") {
@@ -89058,8 +89858,8 @@ function assertPreviewStillCurrent(mutation, before, current) {
 }
 function createPinnedFile(parent, content) {
   const temp = temporaryName();
-  const tempPath = join21(parent.procPath, temp);
-  const targetPath = join21(parent.procPath, parent.targetName);
+  const tempPath = join22(parent.procPath, temp);
+  const targetPath = join22(parent.procPath, parent.targetName);
   let descriptor;
   try {
     descriptor = openSync7(tempPath, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | constants5.O_NOFOLLOW, 438);
@@ -89083,7 +89883,7 @@ function createPinnedFile(parent, content) {
   }
 }
 function replacePinnedFile(parent, expected, content) {
-  const tempPath = join21(parent.procPath, temporaryName());
+  const tempPath = join22(parent.procPath, temporaryName());
   let descriptor;
   try {
     descriptor = openSync7(tempPath, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | constants5.O_NOFOLLOW, expected.mode);
@@ -89096,7 +89896,7 @@ function replacePinnedFile(parent, expected, content) {
     if (!nearWrite || nearWrite.hash !== expected.hash || nearWrite.dev !== expected.dev || nearWrite.ino !== expected.ino) {
       throw new RemoteFileMutationError("file_changed", "Project file changed at the final write boundary");
     }
-    renameSync8(tempPath, join21(parent.procPath, parent.targetName));
+    renameSync8(tempPath, join22(parent.procPath, parent.targetName));
     fsyncSync3(parent.descriptor);
   } catch (error) {
     if (descriptor !== void 0) closeSync7(descriptor);
@@ -89123,7 +89923,7 @@ ${body}${hasFinalNewline ? "" : "\\n"}`;
 }
 async function acquirePathLock(parentIdentity, path2) {
   preparePrivateDirectory3(LOCK_ROOT);
-  const target = join21(LOCK_ROOT, sha256ProjectFile(`${parentIdentity}\0${basename5(path2)}`));
+  const target = join22(LOCK_ROOT, sha256ProjectFile(`${parentIdentity}\0${basename5(path2)}`));
   preparePrivateDirectory3(target);
   try {
     return await lockfile7.lock(target, {
@@ -89493,13 +90293,13 @@ import { existsSync as existsSync23, realpathSync as realpathSync10, statSync as
 import { basename as basename7, dirname as dirname13, relative as relative10, resolve as resolve15 } from "path";
 
 // src/remoteCommandRuntime.ts
-import { createHash as createHash26, randomUUID as randomUUID21 } from "crypto";
+import { createHash as createHash27, randomUUID as randomUUID21 } from "crypto";
 import { spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync21, lstatSync as lstatSync9, readdirSync as readdirSync12, realpathSync as realpathSync7, statSync as statSync6 } from "fs";
-import { isAbsolute as isAbsolute8, join as join22, relative as relative7, resolve as resolve14, sep } from "path";
+import { isAbsolute as isAbsolute8, join as join23, relative as relative7, resolve as resolve14, sep } from "path";
 
 // src/remoteCommandAppArmor.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 import { spawn as spawn5 } from "child_process";
 import { lstatSync as lstatSync8, readFileSync as readFileSync19, realpathSync as realpathSync6, statSync as statSync5 } from "fs";
 import { isAbsolute as isAbsolute7, relative as relative6 } from "path";
@@ -89716,7 +90516,7 @@ function hasControl2(value) {
   });
 }
 function sha2564(value) {
-  return createHash25("sha256").update(value).digest("hex");
+  return createHash26("sha256").update(value).digest("hex");
 }
 
 // src/remoteCommandRuntime.ts
@@ -90142,7 +90942,7 @@ function createRemoteCommandPreflight(request) {
       error instanceof Error ? error.message : "Project source root boundary cannot be established"
     );
   }
-  const cwd = request.policy.cwd === "." ? root : realpath(join22(root, request.policy.cwd));
+  const cwd = request.policy.cwd === "." ? root : realpath(join23(root, request.policy.cwd));
   if (!isInside5(root, cwd) || !statSync6(cwd).isDirectory()) throw new RemoteCommandError("invalid_request", "Command cwd escapes the Project root");
   const canonicalPolicy = { ...request.policy, argv: [...request.policy.argv], cwd: relative7(root, cwd).split(sep).join("/") || "." };
   const toolchains = request.toolchain_paths.map(canonicalDirectory);
@@ -90260,7 +91060,7 @@ function prepareSandboxLaunch(preflight, authority, capability, network, appArmo
   args.push(preflight.policy.source_access === "read_write" ? "--bind" : "--ro-bind", preflight.source_root, "/project");
   if (preflight.policy.source_access === "read_write") {
     for (const protectedPath of preflight.protected_project_paths) {
-      args.push("--ro-bind", join22(preflight.source_root, protectedPath.path), `/project/${protectedPath.path}`);
+      args.push("--ro-bind", join23(preflight.source_root, protectedPath.path), `/project/${protectedPath.path}`);
     }
   }
   for (const masked of preflight.masked_project_paths) {
@@ -90394,13 +91194,13 @@ function discoverProjectPathProtection(root, policy) {
   try {
     while (directories.length) {
       const parent = directories.pop();
-      for (const entry of readdirSync12(join22(root, parent), { withFileTypes: true })) {
+      for (const entry of readdirSync12(join23(root, parent), { withFileTypes: true })) {
         visited += 1;
         if (visited > MAX_PROJECT_MASK_SCAN_ENTRIES) {
           throw new RemoteCommandError("confinement_unavailable", `Project credential scan exceeds ${MAX_PROJECT_MASK_SCAN_ENTRIES} entries`);
         }
         const path2 = parent ? `${parent}/${entry.name}` : entry.name;
-        const fullPath = join22(root, path2);
+        const fullPath = join23(root, path2);
         const stat3 = lstatSync9(fullPath);
         const kind = entry.isDirectory() ? "directory" : "file";
         let masked = policy ? policy.isPrivate(path2, kind === "directory") || path2.toLowerCase() === ".git/config" : classifyProjectFileReadRisk(path2).isHighRisk || path2.toLowerCase() === ".git/config";
@@ -90557,7 +91357,7 @@ function stableJson4(value) {
   return JSON.stringify(value);
 }
 function sha2565(value) {
-  return createHash26("sha256").update(value).digest("hex");
+  return createHash27("sha256").update(value).digest("hex");
 }
 function deepFreeze(value) {
   if (value && typeof value === "object") {
@@ -90572,7 +91372,7 @@ import { lookup as dnsLookup } from "dns/promises";
 import { chmodSync as chmodSync11, mkdtempSync as mkdtempSync4, realpathSync as realpathSync8, rmSync as rmSync10, statSync as statSync7, writeFileSync as writeFileSync11 } from "fs";
 import { isIP as isIP2, createConnection, createServer } from "net";
 import { tmpdir as tmpdir6 } from "os";
-import { isAbsolute as isAbsolute9, join as join23, relative as relative8 } from "path";
+import { isAbsolute as isAbsolute9, join as join24, relative as relative8 } from "path";
 var DEFAULT_BRIDGE_PORT = 43117;
 var MAX_CONNECT_HEADER_BYTES = 8 * 1024;
 var CONNECT_HEADER_TIMEOUT_MS = 1e4;
@@ -90648,8 +91448,8 @@ async function prepareRemoteHttpsConnectNetworkConfinement(claim, preflight, opt
     throw capabilityError(`HTTPS network profiles require the trusted Node runtime in an approved toolchain (${nodeExecutable})`);
   }
   const controlDirectory = createPrivateControlDirectory(preflight, options.controlRoots);
-  const socketPath = join23(controlDirectory, "proxy.sock");
-  const bridgePath = join23(controlDirectory, "bridge.mjs");
+  const socketPath = join24(controlDirectory, "proxy.sock");
+  const bridgePath = join24(controlDirectory, "bridge.mjs");
   writeFileSync11(bridgePath, BRIDGE_SOURCE, { encoding: "utf8", mode: 320, flag: "wx" });
   const activeSockets = /* @__PURE__ */ new Set();
   const server2 = createServer((client2) => {
@@ -90778,7 +91578,7 @@ function createPrivateControlDirectory(preflight, configuredRoots) {
     try {
       if (!isAbsolute9(candidate) || !statSync7(candidate).isDirectory()) continue;
       const root = realpathSync8(candidate);
-      const directory = mkdtempSync4(join23(root, "openmates-command-network-"));
+      const directory = mkdtempSync4(join24(root, "openmates-command-network-"));
       chmodSync11(directory, 448);
       const exposed = preflight.source_root === directory || isInside6(preflight.source_root, directory) || preflight.toolchain_paths.some((path2) => isInside6(path2, directory)) || preflight.writable_targets.some((target) => isInside6(target.host_path, directory));
       if (!exposed) return directory;
@@ -90835,9 +91635,9 @@ function capabilityError(message) {
 }
 
 // src/remoteCommandResourceGrants.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import { chmodSync as chmodSync12, existsSync as existsSync22, lstatSync as lstatSync10, mkdirSync as mkdirSync18, readFileSync as readFileSync20, realpathSync as realpathSync9, renameSync as renameSync9, statSync as statSync8, writeFileSync as writeFileSync12 } from "fs";
-import { isAbsolute as isAbsolute10, join as join24, relative as relative9 } from "path";
+import { isAbsolute as isAbsolute10, join as join25, relative as relative9 } from "path";
 var STORE_FILE = "remote-command-resource-grants.json";
 var ID = /^[a-z][a-z0-9-]{0,63}$/;
 var ENV = /^[A-Z_][A-Z0-9_]{0,127}$/;
@@ -90930,7 +91730,7 @@ function resolveRemoteCommandResourceGrants(context) {
   return { writable_targets, network_profiles, credential_profiles };
 }
 function definitionDigest(kind, definition) {
-  return createHash27("sha256").update(JSON.stringify(["openmates-command-resource-v1", kind, definition])).digest("hex");
+  return createHash28("sha256").update(JSON.stringify(["openmates-command-resource-v1", kind, definition])).digest("hex");
 }
 function upsert(grant) {
   validateIdentity(grant.project_id, grant.source_id, grant.profile_id);
@@ -90938,7 +91738,7 @@ function upsert(grant) {
   writeStore([...others, grant]);
 }
 function readStore() {
-  const path2 = join24(resolveStateDir(), STORE_FILE);
+  const path2 = join25(resolveStateDir(), STORE_FILE);
   if (!existsSync22(path2)) return [];
   const stat3 = lstatSync10(path2);
   if (!stat3.isFile() || stat3.isSymbolicLink() || (stat3.mode & 63) !== 0) throw new Error("Remote command resource grant store is not private");
@@ -90950,7 +91750,7 @@ function writeStore(grants) {
   const directory = resolveStateDir();
   mkdirSync18(directory, { recursive: true, mode: 448 });
   chmodSync12(directory, 448);
-  const path2 = join24(directory, STORE_FILE);
+  const path2 = join25(directory, STORE_FILE);
   if (existsSync22(path2) && lstatSync10(path2).isSymbolicLink()) throw new Error("Remote command resource grant store cannot be a symbolic link");
   const temporary = `${path2}.${process.pid}.tmp`;
   writeFileSync12(temporary, `${JSON.stringify({ version: 1, grants }, null, 2)}
@@ -91933,7 +92733,7 @@ function discoverRemoteAccessRepositories(roots) {
     }
     for (const entry of entries) {
       if (entry.name === ".git" || entry.isSymbolicLink() || !entry.isDirectory()) continue;
-      visit(join25(directory, entry.name), approvedRoot);
+      visit(join26(directory, entry.name), approvedRoot);
     }
   };
   for (const root of roots) visit(root, root);
@@ -91951,7 +92751,7 @@ function remoteAccessHostingCandidates(roots, explicitPath, discover = discoverR
   };
 }
 function remoteAccessSourceType(rootPath) {
-  const gitMarker = join25(rootPath, ".git");
+  const gitMarker = join26(rootPath, ".git");
   return existsSync24(gitMarker) ? "local_git_repository" : "local_folder";
 }
 function listRemoteAccessDirectory(options) {
@@ -92008,7 +92808,7 @@ function listRemoteAccessDirectory(options) {
           remainingChildSummaryEntries -= 1;
           const childPath = `${folderPath}/${child.name}`;
           if (child.name.startsWith(".") || child.isSymbolicLink() || !child.isFile() && !child.isDirectory() || childPolicy.isIgnored(childPath, child.isDirectory()) || childPolicy.isPrivate(childPath, child.isDirectory())) continue;
-          const fileStat = child.isFile() ? lstatSync11(join25(absoluteFolder, child.name)) : null;
+          const fileStat = child.isFile() ? lstatSync11(join26(absoluteFolder, child.name)) : null;
           if (fileStat && fileStat.nlink > 1) continue;
           if (child.isDirectory()) childFolderCount += 1;
           else {
@@ -92029,7 +92829,7 @@ function listRemoteAccessDirectory(options) {
   const compareNames = (a, b) => a.localeCompare(b) || (a < b ? -1 : a > b ? 1 : 0);
   for (const entry of readdirSync13(directory, { withFileTypes: true }).sort((a, b) => compareNames(a.name, b.name))) {
     if (cursor !== void 0 && compareNames(entry.name, cursor) <= 0) continue;
-    const entryPath = relative11(root, join25(directory, entry.name)).replace(/\\/g, "/");
+    const entryPath = relative11(root, join26(directory, entry.name)).replace(/\\/g, "/");
     if (entry.name.startsWith(".") || entry.isSymbolicLink() || policy.isIgnored(entryPath, entry.isDirectory()) || policy.isPrivate(entryPath, entry.isDirectory())) {
       excluded += 1;
       continue;
@@ -92038,7 +92838,7 @@ function listRemoteAccessDirectory(options) {
       excluded += 1;
       continue;
     }
-    const fileStat = entry.isFile() ? lstatSync11(join25(directory, entry.name)) : void 0;
+    const fileStat = entry.isFile() ? lstatSync11(join26(directory, entry.name)) : void 0;
     if (fileStat && fileStat.nlink > 1) {
       excluded += 1;
       continue;
@@ -92100,7 +92900,7 @@ function readRemoteAccessTextFile(options) {
       truncated,
       sizeBytes: stats.size,
       lineCount: countTextLines(content),
-      expected_base: truncated ? null : createHash28("sha256").update(bytes2.subarray(0, bytesRead)).digest("hex")
+      expected_base: truncated ? null : createHash29("sha256").update(bytes2.subarray(0, bytesRead)).digest("hex")
     };
   } catch (error) {
     const code = error.code;
@@ -92150,7 +92950,7 @@ function readRemoteAccessImageChunk(options) {
       mime_type: mimeType,
       size_bytes: stats.size,
       offset: options.offset,
-      content_hash: createHash28("sha256").update(bytes2).digest("hex")
+      content_hash: createHash29("sha256").update(bytes2).digest("hex")
     };
   } catch (error) {
     if (error.code === "ELOOP") throw new Error("Remote source path is a symbolic link");
@@ -92198,8 +92998,8 @@ function readRemoteAccessFileChunk(options) {
       content_base64: bytes2.toString("base64"),
       size_bytes: stats.size,
       offset: options.offset,
-      file_identity: createHash28("sha256").update(`${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`).digest("hex"),
-      chunk_hash: createHash28("sha256").update(bytes2).digest("hex")
+      file_identity: createHash29("sha256").update(`${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`).digest("hex"),
+      chunk_hash: createHash29("sha256").update(bytes2).digest("hex")
     };
   } catch (error) {
     if (error.code === "ELOOP") throw new Error("Remote source path is a symbolic link");
@@ -92307,13 +93107,13 @@ async function runRemoteAccessBridge(options) {
     for (const binding of options.bindings) {
       const projectId = binding.source.projectId;
       if (caches.has(projectId)) continue;
-      const cache = new ProjectTaskCache(options.taskCacheRoot ?? join25(resolveStateDir(), "project-task-cache"), accountScope, projectId);
+      const cache = new ProjectTaskCache(options.taskCacheRoot ?? join26(resolveStateDir(), "project-task-cache"), accountScope, projectId);
       releases.push(await lockfile8.lock(cache.directory, { retries: 0, stale: 12e4 }));
       caches.set(projectId, cache);
     }
     codexBridges = startCodexTaskBridges(
       options.bindings.map((item) => item.source.rootPath),
-      [...caches.values()].map((cache) => join25(cache.directory, "snapshot.json")),
+      [...caches.values()].map((cache) => join26(cache.directory, "snapshot.json")),
       resolveStateDir(),
       (status) => options.onTaskSync?.({ projectId: "", directory: "", status })
     );
@@ -92672,7 +93472,7 @@ function waitForAbort2(signal, timeoutMs) {
 }
 function resolveRemoteCachePath(sourceId, homeDirectory) {
   assertSafeSourceId(sourceId);
-  return join25(remoteAccessStateDirectory(homeDirectory), "remote-cache", sourceId);
+  return join26(remoteAccessStateDirectory(homeDirectory), "remote-cache", sourceId);
 }
 function startRemoteAccessSource(input) {
   assertSafeSourceId(input.sourceId);
@@ -92822,7 +93622,7 @@ function searchRemoteSourceWithoutRg(request, sourceRoot, targetPath, policy) {
         continue;
       }
       for (const entry of entries) {
-        const absolutePath = join25(directory, entry.name);
+        const absolutePath = join26(directory, entry.name);
         const relativePath = relative11(root, absolutePath).replace(/\\/g, "/");
         if (entry.name === ".git" || entry.isSymbolicLink() || policy.isIgnored(relativePath, entry.isDirectory()) || policy.isPrivate(relativePath, entry.isDirectory())) {
           excluded += 1;
@@ -92952,15 +93752,15 @@ function searchRemoteFileNamesWithoutRg(request, sourceRoot, targetPath, policy,
             enumerationTruncated = true;
             break;
           }
-          const path2 = relative11(sourceRoot, join25(absolute, entry.name)).replace(/\\/g, "/");
+          const path2 = relative11(sourceRoot, join26(absolute, entry.name)).replace(/\\/g, "/");
           const isDirectory = entry.isDirectory();
-          if (skipPriority && priorityAbsolute === join25(absolute, entry.name)) continue;
+          if (skipPriority && priorityAbsolute === join26(absolute, entry.name)) continue;
           if (entry.name.startsWith(".") || entry.isSymbolicLink() || !entry.isFile() && !isDirectory || policy.isIgnored(path2, isDirectory) || policy.isPrivate(path2, isDirectory)) {
             excluded += 1;
             continue;
           }
-          if (isDirectory) pending.push(join25(absolute, entry.name));
-          else if (lstatSync11(join25(absolute, entry.name)).nlink > 1) {
+          if (isDirectory) pending.push(join26(absolute, entry.name));
+          else if (lstatSync11(join26(absolute, entry.name)).nlink > 1) {
             excluded += 1;
             continue;
           }
@@ -93165,7 +93965,7 @@ function collectSearchPathMetadata(sourceRoot, targetPath, policy, collectDirect
         throw new Error("Remote source search alias scan exceeded its bounded file limit");
       }
       if (entry.name === ".git" || entry.isSymbolicLink()) continue;
-      const absolute = join25(directory, entry.name);
+      const absolute = join26(directory, entry.name);
       const path2 = relative11(sourceRoot, absolute).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         if (!policy.isIgnored(path2, true) && !policy.isPrivate(path2, true) && (!collectDirectories || !entry.name.startsWith("."))) {
@@ -93242,7 +94042,7 @@ function resolveApprovedPath(sourceRoot, relativePath) {
   const relation = relative11(sourceRoot, lexical);
   let current = sourceRoot;
   for (const part of relation.split(/[\\/]/).filter(Boolean)) {
-    current = join25(current, part);
+    current = join26(current, part);
     if (lstatSync11(current).isSymbolicLink()) throw new Error("Remote source path is a symbolic link");
   }
   const canonical = realpathSync11(lexical);
@@ -93306,7 +94106,7 @@ function remoteAccessStateDirectory(homeDirectory) {
   return homeDirectory === void 0 ? resolveStateDir() : resolveStateDir({ homeDir: homeDirectory, stateDir: "", profile: "" });
 }
 function remoteAccessStorePath(homeDirectory) {
-  return join25(remoteAccessStateDirectory(homeDirectory), "remote-sources.json");
+  return join26(remoteAccessStateDirectory(homeDirectory), "remote-sources.json");
 }
 function saveRemoteAccessSources(sources, homeDirectory) {
   const filePath = remoteAccessStorePath(homeDirectory);
@@ -93390,11 +94190,11 @@ function inheritedInstaller(executable, args) {
 import { spawnSync as spawnSync5 } from "child_process";
 import { readFileSync as readFileSync22, mkdirSync as mkdirSync20, writeFileSync as writeFileSync14, renameSync as renameSync10 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname14, basename as basename8, join as join26 } from "path";
+import { dirname as dirname14, basename as basename8, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_NAME = "openmates";
 function channelFile() {
-  return join26(homedir7(), ".openmates", "updates.json");
+  return join27(homedir7(), ".openmates", "updates.json");
 }
 function parseChannel(value) {
   if (value === "dev") return "dev";
@@ -93764,7 +94564,7 @@ import { execFileSync as execFileSync6 } from "child_process";
 import { createSign, randomUUID as randomUUID22 } from "crypto";
 import { chmodSync as chmodSync14, existsSync as existsSync25, mkdirSync as mkdirSync22, readFileSync as readFileSync23 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join27, resolve as resolve17 } from "path";
+import { join as join28, resolve as resolve17 } from "path";
 var REVOLUT_BUSINESS_CERTIFICATE_DOCS_URL = "https://developer.revolut.com/docs/guides/manage-accounts/get-started/make-your-first-api-request#generate-a-private-and-a-public-certificate";
 var REVOLUT_BUSINESS_DEFAULT_SANDBOX_REDIRECT_URI = "https://app.dev.openmates.org/oauth/revolut-business/callback";
 var REVOLUT_BUSINESS_DEFAULT_PRODUCTION_REDIRECT_URI = "https://openmates.org/oauth/revolut-business/callback";
@@ -93774,7 +94574,7 @@ var REVOLUT_BUSINESS_AUDIENCE = "https://revolut.com";
 var CERTIFICATE_DAYS = "1825";
 var RSA_BITS = "2048";
 function defaultRevolutBusinessCertificateDir(environment) {
-  return join27(homedir8(), ".openmates", "revolut-business", environment);
+  return join28(homedir8(), ".openmates", "revolut-business", environment);
 }
 function defaultRevolutBusinessRedirectUri(environment) {
   return environment === "sandbox" ? REVOLUT_BUSINESS_DEFAULT_SANDBOX_REDIRECT_URI : REVOLUT_BUSINESS_DEFAULT_PRODUCTION_REDIRECT_URI;
@@ -93797,7 +94597,7 @@ async function exchangeRevolutBusinessAuthorizationCode(options) {
   if (!clientId) throw new Error("Missing Revolut Business client ID.");
   const code = extractRevolutBusinessAuthorizationCode(options.codeOrRedirectUrl);
   if (!code) throw new Error("Missing Revolut Business authorization code.");
-  const privateKeyPem = options.privateKeyPem ?? readFileSync23(options.privateKeyPath ?? join27(defaultRevolutBusinessCertificateDir(environment), "privatecert.pem"), "utf8");
+  const privateKeyPem = options.privateKeyPem ?? readFileSync23(options.privateKeyPath ?? join28(defaultRevolutBusinessCertificateDir(environment), "privatecert.pem"), "utf8");
   const redirectUri = (options.redirectUri ?? defaultRevolutBusinessRedirectUri(environment)).trim();
   const clientAssertion = generateRevolutBusinessClientAssertion({ clientId, privateKeyPem, redirectUri });
   const response = await fetch(environment === "sandbox" ? "https://sandbox-b2b.revolut.com/api/1.0/auth/token" : "https://b2b.revolut.com/api/1.0/auth/token", {
@@ -93852,8 +94652,8 @@ function generateRevolutBusinessCertificate(options = {}) {
   if (!redirectUri.startsWith("https://")) throw new Error("Revolut OAuth redirect URI must start with https://.");
   mkdirSync22(outputDir, { recursive: true, mode: 448 });
   chmodSync14(outputDir, 448);
-  const privateKeyPath = join27(outputDir, "privatecert.pem");
-  const publicCertificatePath = join27(outputDir, "publiccert.cer");
+  const privateKeyPath = join28(outputDir, "privatecert.pem");
+  const publicCertificatePath = join28(outputDir, "publiccert.cer");
   if (!options.overwrite && (existsSync25(privateKeyPath) || existsSync25(publicCertificatePath))) {
     throw new Error(`Revolut certificate files already exist in ${outputDir}. Re-run with --overwrite to replace them.`);
   }
@@ -95548,7 +96348,7 @@ async function handlePlans(client2, subcommand, rest, flags, redactor) {
     if (action === "diff") throw new Error("Revision diffs are reviewed in the authenticated web review page; use submit-for-review to print its URL.");
     if (action !== "submit-for-review") throw new Error("Usage: openmates plans revisions list|submit-for-review|status|diff <plan-id>");
     const snapshot2 = JSON.stringify(planToJson(plan));
-    const revision = await client2.submitPlanRevision(plan.planId, { fingerprint: createHash29("sha256").update(snapshot2).digest("hex"), encrypted_snapshot: await encryptPlanAssumptionSources(plan, masterKey, snapshot2), created_at: nowSeconds3() });
+    const revision = await client2.submitPlanRevision(plan.planId, { fingerprint: createHash30("sha256").update(snapshot2).digest("hex"), encrypted_snapshot: await encryptPlanAssumptionSources(plan, masterKey, snapshot2), created_at: nowSeconds3() });
     const reviewUrl = `${deriveAppUrl(client2.apiUrl)}/plans/${plan.planId}/review?revision=${revision.revision_id}`;
     if (flags.json === true) printJson2({ revision, review_url: reviewUrl });
     else console.log(`Plan revision submitted for web review: ${reviewUrl}`);
@@ -96468,7 +97268,7 @@ async function handleProjects(client2, subcommand, rest, flags, redactor) {
       encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: defaultFocus }), projectKey),
       key_wrappers: wrapping.teamId ? [{
         key_type: "team",
-        hashed_team_id: createHash29("sha256").update(wrapping.teamId).digest("hex"),
+        hashed_team_id: createHash30("sha256").update(wrapping.teamId).digest("hex"),
         team_key_epoch: 1,
         encrypted_project_key: await encryptBytesWithAesGcm(projectKey, wrapping.key),
         wrapper_version: 1,
@@ -97844,7 +98644,7 @@ async function createEncryptedRemoteAccessProject(client2, name, rootPath, write
     encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: defaultFocus }), projectKey),
     key_wrappers: wrapping.teamId ? [{
       key_type: "team",
-      hashed_team_id: createHash29("sha256").update(wrapping.teamId).digest("hex"),
+      hashed_team_id: createHash30("sha256").update(wrapping.teamId).digest("hex"),
       team_key_epoch: 1,
       encrypted_project_key: await encryptBytesWithAesGcm(projectKey, wrapping.key),
       wrapper_version: 1,
@@ -97918,7 +98718,7 @@ function readRootProjectInstructions(rootPath) {
       return left.localeCompare(right);
     });
     const source = matchingNames[0];
-    if (source) return { instructions: readFileSync24(join28(rootPath, source), "utf8"), source };
+    if (source) return { instructions: readFileSync24(join29(rootPath, source), "utf8"), source };
   }
   return null;
 }
@@ -98817,31 +99617,31 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
       } catch {
       }
     }
-    const { mkdir: mkdir3, writeFile: writeFile2 } = await import("fs/promises");
-    const { join: join29 } = await import("path");
+    const { mkdir: mkdir4, writeFile: writeFile3 } = await import("fs/promises");
+    const { join: join30 } = await import("path");
     if (useZip) {
-      const tmpDir = join29(outputDir, `.${filenameBase}_tmp`);
-      await mkdir3(tmpDir, { recursive: true });
-      await writeFile2(join29(tmpDir, `${filenameBase}.yml`), yamlContent);
-      await writeFile2(join29(tmpDir, `${filenameBase}.md`), mdContent);
+      const tmpDir = join30(outputDir, `.${filenameBase}_tmp`);
+      await mkdir4(tmpDir, { recursive: true });
+      await writeFile3(join30(tmpDir, `${filenameBase}.yml`), yamlContent);
+      await writeFile3(join30(tmpDir, `${filenameBase}.md`), mdContent);
       if (codeEmbeds.length > 0) {
         for (const ce of codeEmbeds) {
           const fpath = ce.filePath ?? ce.filename ?? `${ce.embedId.slice(0, 8)}.${getExtForLang(ce.language)}`;
-          const fullPath = join29(tmpDir, "code", fpath);
-          await mkdir3(fullPath.substring(0, fullPath.lastIndexOf("/")), {
+          const fullPath = join30(tmpDir, "code", fpath);
+          await mkdir4(fullPath.substring(0, fullPath.lastIndexOf("/")), {
             recursive: true
           });
-          await writeFile2(fullPath, ce.content);
+          await writeFile3(fullPath, ce.content);
         }
       }
       if (transcriptEmbeds.length > 0) {
-        const tDir = join29(tmpDir, "transcripts");
-        await mkdir3(tDir, { recursive: true });
+        const tDir = join30(tmpDir, "transcripts");
+        await mkdir4(tDir, { recursive: true });
         for (const te of transcriptEmbeds) {
-          await writeFile2(join29(tDir, te.filename), te.content);
+          await writeFile3(join30(tDir, te.filename), te.content);
         }
       }
-      const zipPath = join29(outputDir, `${filenameBase}.zip`);
+      const zipPath = join30(outputDir, `${filenameBase}.zip`);
       const { execSync: execSync2 } = await import("child_process");
       try {
         execSync2(`cd "${tmpDir}" && zip -r "${zipPath}" .`, { stdio: "pipe" });
@@ -98856,29 +99656,29 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
         );
       }
     } else {
-      const chatDir = join29(outputDir, filenameBase);
-      await mkdir3(chatDir, { recursive: true });
+      const chatDir = join30(outputDir, filenameBase);
+      await mkdir4(chatDir, { recursive: true });
       const written = [];
-      await writeFile2(join29(chatDir, `${filenameBase}.yml`), yamlContent);
+      await writeFile3(join30(chatDir, `${filenameBase}.yml`), yamlContent);
       written.push(`${filenameBase}.yml`);
-      await writeFile2(join29(chatDir, `${filenameBase}.md`), mdContent);
+      await writeFile3(join30(chatDir, `${filenameBase}.md`), mdContent);
       written.push(`${filenameBase}.md`);
       if (codeEmbeds.length > 0) {
         for (const ce of codeEmbeds) {
           const fpath = ce.filePath ?? ce.filename ?? `${ce.embedId.slice(0, 8)}.${getExtForLang(ce.language)}`;
-          const fullPath = join29(chatDir, "code", fpath);
-          await mkdir3(fullPath.substring(0, fullPath.lastIndexOf("/")), {
+          const fullPath = join30(chatDir, "code", fpath);
+          await mkdir4(fullPath.substring(0, fullPath.lastIndexOf("/")), {
             recursive: true
           });
-          await writeFile2(fullPath, ce.content);
+          await writeFile3(fullPath, ce.content);
           written.push(`code/${fpath}`);
         }
       }
       if (transcriptEmbeds.length > 0) {
-        const tDir = join29(chatDir, "transcripts");
-        await mkdir3(tDir, { recursive: true });
+        const tDir = join30(chatDir, "transcripts");
+        await mkdir4(tDir, { recursive: true });
         for (const te of transcriptEmbeds) {
-          await writeFile2(join29(tDir, te.filename), te.content);
+          await writeFile3(join30(tDir, te.filename), te.content);
           written.push(`transcripts/${te.filename}`);
         }
       }
@@ -98914,7 +99714,7 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
       printJson2({
         chat_id: chat.id,
         title: chat.title,
-        output_dir: useZip ? join29(outputDir, `${filenameBase}.zip`) : join29(outputDir, filenameBase),
+        output_dir: useZip ? join30(outputDir, `${filenameBase}.zip`) : join30(outputDir, filenameBase),
         files,
         code_embeds: codeEmbeds.length,
         transcript_embeds: transcriptEmbeds.length
@@ -99235,7 +100035,7 @@ function normalizeApiKeyLoadedChat(payload) {
   const messages = rawMessages.map((message) => {
     const messageId = String(message.client_message_id ?? message.message_id ?? message.id ?? "");
     const directEmbedIds = Array.isArray(message.embedIds) ? message.embedIds : Array.isArray(message.embed_ids) ? message.embed_ids : [];
-    const hashedMessageId = messageId ? createHash29("sha256").update(messageId).digest("hex") : null;
+    const hashedMessageId = messageId ? createHash30("sha256").update(messageId).digest("hex") : null;
     const matchedEmbedIds = hashedMessageId ? rawEmbeds.filter((embed) => embed.hashed_message_id === hashedMessageId && !embed.parent_embed_id).map((embed) => String(embed.embed_id ?? embed.id ?? "")).filter(Boolean) : [];
     return {
       id: messageId,
@@ -101381,8 +102181,8 @@ function printAccountExportBundle(bundle, flags) {
 }
 var ACCOUNT_IMPORT_SOURCES = /* @__PURE__ */ new Set(["openmates", "chatgpt", "claude", "gemini", "opencode", "other"]);
 async function parseAccountImportFile(parserFormat, file, flags = {}) {
-  const { readFile: readFile2 } = await import("fs/promises");
-  const payload = await readFile2(file);
+  const { readFile: readFile3 } = await import("fs/promises");
+  const payload = await readFile3(file);
   const requestedSource = typeof flags.source === "string" ? flags.source : parserFormat;
   if (!ACCOUNT_IMPORT_SOURCES.has(requestedSource)) throw new Error(`Unsupported account import source: ${requestedSource}`);
   const selectedSource = requestedSource;
@@ -101762,13 +102562,13 @@ function parseYamlScalar(value) {
   return trimmed;
 }
 async function saveDownloadedDocument(document, output) {
-  const { mkdir: mkdir3, writeFile: writeFile2 } = await import("fs/promises");
-  const { join: join29, basename: basename10, dirname: dirname17 } = await import("path");
+  const { mkdir: mkdir4, writeFile: writeFile3 } = await import("fs/promises");
+  const { join: join30, basename: basename10, dirname: dirname17 } = await import("path");
   const target = typeof output === "string" ? output : ".";
   const filename = basename10(document.filename || "document.pdf");
-  const filePath = target.endsWith(".pdf") ? target : join29(target, filename);
-  await mkdir3(dirname17(filePath), { recursive: true });
-  await writeFile2(filePath, document.data);
+  const filePath = target.endsWith(".pdf") ? target : join30(target, filename);
+  await mkdir4(dirname17(filePath), { recursive: true });
+  await writeFile3(filePath, document.data);
   return filePath;
 }
 function printMates(json) {
@@ -102233,7 +103033,7 @@ async function promptPlainText(question) {
   }
 }
 async function writeSecretFile(filePath, content, force = false) {
-  const { mkdir: mkdir3, writeFile: writeFile2, stat: stat3 } = await import("fs/promises");
+  const { mkdir: mkdir4, writeFile: writeFile3, stat: stat3 } = await import("fs/promises");
   const { dirname: dirname17 } = await import("path");
   try {
     await stat3(filePath);
@@ -102244,8 +103044,8 @@ async function writeSecretFile(filePath, content, force = false) {
     }
     if (error instanceof Error && !("code" in error)) throw error;
   }
-  await mkdir3(dirname17(filePath), { recursive: true });
-  await writeFile2(filePath, content, { mode: 384 });
+  await mkdir4(dirname17(filePath), { recursive: true });
+  await writeFile3(filePath, content, { mode: 384 });
   return filePath;
 }
 async function generateProvisioningPassword() {
@@ -102611,8 +103411,8 @@ async function handleSettings(client2, subcommand, rest, flags) {
   if (matches(tokens, ["account", "import-chat"])) {
     const file = rest[1];
     if (!file) throw new Error("Missing import file. Example: openmates settings account import-chat ./chat.yml");
-    const { readFile: readFile2 } = await import("fs/promises");
-    const content = await readFile2(file, "utf-8");
+    const { readFile: readFile3 } = await import("fs/promises");
+    const content = await readFile3(file, "utf-8");
     await printSettingsMutationResult(
       client2.settingsPost("import-chat", parseChatImportPayload(content)),
       flags
@@ -106341,19 +107141,19 @@ async function handleDocs(client2, subcommand, rest, flags) {
     return;
   }
   if (subcommand === "download") {
-    const { writeFile: writeFile2, mkdir: mkdir3 } = await import("fs/promises");
-    const { join: join29, dirname: dirname17 } = await import("path");
+    const { writeFile: writeFile3, mkdir: mkdir4 } = await import("fs/promises");
+    const { join: join30, dirname: dirname17 } = await import("path");
     if (flags.all === true) {
       const outputDir = typeof flags.output === "string" ? flags.output : "./openmates-docs";
       const tree = await client2.listDocs();
       const slugs = collectSlugs(tree);
-      await mkdir3(outputDir, { recursive: true });
+      await mkdir4(outputDir, { recursive: true });
       let count = 0;
       for (const slug2 of slugs) {
         const content2 = await client2.getDoc(slug2);
-        const filePath = join29(outputDir, `${slug2}.md`);
-        await mkdir3(dirname17(filePath), { recursive: true });
-        await writeFile2(filePath, content2, "utf-8");
+        const filePath = join30(outputDir, `${slug2}.md`);
+        await mkdir4(dirname17(filePath), { recursive: true });
+        await writeFile3(filePath, content2, "utf-8");
         count++;
         process.stderr.write(`\r  Downloaded ${count}/${slugs.length}`);
       }
@@ -106372,7 +107172,7 @@ async function handleDocs(client2, subcommand, rest, flags) {
     }
     const content = await client2.getDoc(slug);
     const filename = typeof flags.output === "string" ? flags.output : `${slug.split("/").pop()}.md`;
-    await writeFile2(filename, content, "utf-8");
+    await writeFile3(filename, content, "utf-8");
     console.log(`Saved to ${filename}`);
     return;
   }