@pyxmate/memory 1.23.1 → 1.24.0

package/dist/cli/pyx-mem.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "../chunk-6EEEOV6B.mjs";
 import {
   PERSISTENT_MEMORY_SECTION,
   buildDesignGuide
@@ -10,7 +11,15 @@ import {
   TAXONOMY_MAX_SAMPLE_TOPICS,
   TAXONOMY_MAX_TOP_ENTITIES
 } from "../chunk-KZKGRND2.mjs";
-import "../chunk-C46EE5BH.mjs";
+import {
+  HOSTED_FILE_INGEST_PROTOCOL,
+  HOSTED_FILE_INGEST_RETRYABLE_CODES,
+  parseHostedFileIngestAuthorization,
+  parseHostedFileIngestCommitResult,
+  parseHostedFileIngestJobView,
+  parseHostedFileIngestPublishResult,
+  requireHostedFileIngestFilename
+} from "../chunk-VXXRCAKS.mjs";
 
 // src/cli/exit-codes.ts
 var EXIT = {
@@ -174,9 +183,9 @@ function parseEndpoint(input) {
   return normalized.length <= MAX_ENDPOINT_CHARS ? normalized : null;
 }
 function boundLabel(value, maxChars) {
-  let label = value.replace(/\p{Cc}/gu, "").slice(0, maxChars);
-  while (JSON.stringify(label).length - 2 > maxChars) label = label.slice(0, -1);
-  return label;
+  let label2 = value.replace(/\p{Cc}/gu, "").slice(0, maxChars);
+  while (JSON.stringify(label2).length - 2 > maxChars) label2 = label2.slice(0, -1);
+  return label2;
 }
 function isTrustedAuthorizationUrl(authorizationUrl, endpoint, requestId) {
   const url = parseSafeUrl(authorizationUrl);
@@ -820,8 +829,8 @@ import { randomUUID as randomUUID2 } from "crypto";
 // src/mcp/errors.ts
 var RUN_LOGIN = "Run: pyx-mem login";
 var RUN_DOCTOR = "Run: pyx-mem doctor";
-function mcpText(text, isError = false) {
-  return { isError, content: [{ type: "text", text }] };
+function mcpText(text2, isError = false) {
+  return { isError, content: [{ type: "text", text: text2 }] };
 }
 function mcpMissingCredentials() {
   return mcpText(`pyx-memory credentials are not configured.
@@ -890,25 +899,36 @@ function createHttpClient(credentials, fetchImpl = fetch) {
     }
     return headers;
   }
-  async function send(url, method, headers, body) {
+  async function send(url, method, headers, body, deadline = {}) {
+    const { timeoutMs, signal } = deadline;
     const ctl = new AbortController();
-    const timer = setTimeout(() => ctl.abort(), DEFAULT_TIMEOUT_MS);
-    let res;
+    const timer = setTimeout(
+      () => timeoutMs === void 0 ? ctl.abort() : ctl.abort(
+        new DOMException(`no complete response within ${timeoutMs / 1e3} s`, "TimeoutError")
+      ),
+      timeoutMs ?? DEFAULT_TIMEOUT_MS
+    );
     try {
-      res = await fetchImpl(url, { method, headers, body, signal: ctl.signal });
-    } catch (err) {
-      return {
-        ok: false,
-        result: mcpUnreachable(baseUrl, err instanceof Error ? err.message : String(err))
-      };
+      let res;
+      try {
+        res = await fetchImpl(url, {
+          method,
+          headers,
+          body,
+          signal: signal ? AbortSignal.any([ctl.signal, signal]) : ctl.signal
+        });
+      } catch (err) {
+        return {
+          ok: false,
+          result: mcpUnreachable(baseUrl, err instanceof Error ? err.message : String(err))
+        };
+      } finally {
+        if (timeoutMs === void 0) clearTimeout(timer);
+      }
+      return await readResponse(res);
     } finally {
       clearTimeout(timer);
     }
-    if (res.status === 401 || res.status === 403) {
-      return { ok: false, status: res.status, result: mcpAuthFailed(res.status) };
-    }
-    const text = await res.text().catch(() => "");
-    return parseHttpResponse(res, text);
   }
   return {
     async requestJson(input) {
@@ -919,49 +939,123 @@ function createHttpClient(credentials, fetchImpl = fetch) {
         hasBody ? "application/json" : void 0,
         input.idempotencyKey
       );
-      return send(url, input.method, headers, hasBody ? JSON.stringify(input.body) : void 0);
+      return send(
+        url,
+        input.method,
+        headers,
+        hasBody ? JSON.stringify(input.body) : void 0,
+        input
+      );
     },
     async requestMultipart(input) {
       const url = buildUrl(input.path);
       const headers = buildHeaders(input.scope, void 0, input.idempotencyKey);
       const form = await input.formData();
       return send(url, "POST", headers, form);
+    },
+    async requestBytes(input) {
+      const headers = buildHeaders(input.scope, "application/octet-stream", input.idempotencyKey);
+      for (const [name, value] of Object.entries(input.headers)) headers.set(name, value);
+      return send(buildUrl(input.path), input.method, headers, input.body, input);
     }
   };
 }
-function parseHttpResponse(res, text) {
+async function readResponse(res) {
+  if (res.status === 401 || res.status === 403) {
+    return { ok: false, status: res.status, result: mcpAuthFailed(res.status) };
+  }
+  let text2;
+  try {
+    text2 = await res.text();
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      status: res.status,
+      result: mcpEnvelopeError(
+        `Failed to read pyx-memory response (HTTP ${res.status}): ${reason}`
+      )
+    };
+  }
+  return parseHttpResponse(res, text2);
+}
+function parseHttpResponse(res, text2) {
+  if (res.ok && res.headers.get("content-type")?.includes("application/x-ndjson")) {
+    return parseNdjsonOutcome(res.status, text2);
+  }
+  const parsed = parseJsonText(text2);
+  const gateway = parsed.ok ? gatewayError(parsed.value) : void 0;
+  const failure2 = {
+    ok: false,
+    status: res.status,
+    code: parsed.ok ? extractEnvelopeCode(parsed.value) : void 0,
+    retryAfter: res.headers.get("retry-after") ?? void 0
+  };
   if (res.status >= 500) {
-    return { ok: false, status: res.status, result: mcpServerError(res.status, text) };
+    return { ...failure2, result: mcpServerError(res.status, gateway?.message ?? text2) };
   }
-  const parsed = parseJsonText(text);
   if (!parsed.ok) {
     if (!res.ok) {
-      return {
-        ok: false,
-        status: res.status,
-        result: mcpHttpError(res.status, text || "no body")
-      };
+      return { ...failure2, result: mcpHttpError(res.status, text2 || "no body") };
     }
-    return { ok: true, status: res.status, data: text };
+    return { ok: true, status: res.status, data: text2 };
   }
   if (!res.ok) {
-    const message = extractEnvelopeError(parsed.value) ?? text ?? `HTTP ${res.status}`;
-    return { ok: false, status: res.status, result: mcpHttpError(res.status, message) };
+    const message = extractEnvelopeError(parsed.value) ?? gateway?.message ?? text2 ?? `HTTP ${res.status}`;
+    return { ...failure2, result: mcpHttpError(res.status, message) };
   }
   const envelopeError = extractEnvelopeError(parsed.value);
   if (envelopeError) {
-    return { ok: false, status: res.status, result: mcpEnvelopeError(envelopeError) };
+    return { ...failure2, result: mcpEnvelopeError(envelopeError) };
   }
   return { ok: true, status: res.status, data: parsed.value };
 }
-function parseJsonText(text) {
-  if (text.length === 0) return { ok: true, value: void 0 };
+function parseNdjsonOutcome(status, text2) {
+  for (const line of text2.split("\n")) {
+    if (!line.trim()) continue;
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        status,
+        result: mcpEnvelopeError(`pyx-memory sent an invalid NDJSON line: ${reason}`)
+      };
+    }
+    if (frame?.type === "result") return { ok: true, status, data: frame };
+    if (frame?.type === "error") {
+      return { ok: false, status, result: mcpEnvelopeError(JSON.stringify(frame)) };
+    }
+  }
+  return {
+    ok: false,
+    status,
+    result: mcpEnvelopeError("File ingest stream ended without a server result")
+  };
+}
+function parseJsonText(text2) {
+  if (text2.length === 0) return { ok: true, value: void 0 };
   try {
-    return { ok: true, value: JSON.parse(text) };
+    return { ok: true, value: JSON.parse(text2) };
   } catch {
     return { ok: false };
   }
 }
+function gatewayError(parsed) {
+  if (parsed === null || typeof parsed !== "object") return void 0;
+  const error = parsed.error;
+  if (error === null || typeof error !== "object") return void 0;
+  const { code, message } = error;
+  return typeof code === "string" && typeof message === "string" ? { code, message } : void 0;
+}
+function extractEnvelopeCode(parsed) {
+  if (parsed === null || typeof parsed !== "object") return void 0;
+  const obj = parsed;
+  if (obj.success === false && typeof obj.code === "string") return obj.code;
+  return gatewayError(parsed)?.code;
+}
 function extractEnvelopeError(parsed) {
   if (parsed === null || typeof parsed !== "object") return null;
   const obj = parsed;
@@ -1240,9 +1334,9 @@ async function readApiKeySecret() {
   }
   return readSingleLineFromStdin();
 }
-async function promptMasked(label) {
+async function promptMasked(label2) {
   const { stdin, stdout } = process;
-  stdout.write(label);
+  stdout.write(label2);
   const hadRawMode = typeof stdin.setRawMode === "function";
   if (!hadRawMode) {
     const value = await readSingleLineFromStdin();
@@ -1250,7 +1344,7 @@ async function promptMasked(label) {
 `);
     return value;
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const previousEncoding = stdin.readableEncoding;
     stdin.setEncoding("utf8");
     stdin.setRawMode(true);
@@ -1268,7 +1362,7 @@ async function promptMasked(label) {
         if (ch === "\n" || ch === "\r") {
           cleanup();
           stdout.write("\n");
-          resolve3(buf.trim());
+          resolve4(buf.trim());
           return;
         }
         if (ch === "") {
@@ -1439,7 +1533,7 @@ p { margin: 0; color: #a9adb8; font-size: 16px; line-height: 1.65; }
 @media (prefers-reduced-motion: reduce) { .continue .symbol { animation: none; } }
 `;
 var PAGE_CSP = `default-src 'none'; style-src 'sha256-${createHash2("sha256").update(STYLES).digest("base64")}'; base-uri 'none'; form-action 'none'`;
-var page = (state, title, text, icon) => `<!doctype html>
+var page = (state, title, text2, icon) => `<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
@@ -1453,7 +1547,7 @@ var page = (state, title, text, icon) => `<!doctype html>
 <section class="card" aria-labelledby="title">
 <div class="symbol" aria-hidden="true"><svg width="30" height="30" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round">${icon}</svg></div>
 <h1 id="title">${title}</h1>
-<p>${text}</p>
+<p>${text2}</p>
 <p class="note">You can close this tab.</p>
 </section>
 </main>
@@ -1490,8 +1584,8 @@ async function startCallbackServer() {
   let expected = null;
   let settle2 = () => {
   };
-  const result = new Promise((resolve3) => {
-    settle2 = resolve3;
+  const result = new Promise((resolve4) => {
+    settle2 = resolve4;
   });
   function accept(method, host, rawUrl) {
     if (method !== "GET" || expected === null || host !== `127.0.0.1:${port}`) return null;
@@ -1526,9 +1620,9 @@ async function startCallbackServer() {
   });
   server.requestTimeout = 5e3;
   server.headersTimeout = 5e3;
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve3);
+    server.listen(0, "127.0.0.1", resolve4);
   });
   const port = server.address().port;
   return {
@@ -1859,7 +1953,7 @@ async function cleanupPendingAfterFailure(keychain) {
 async function logoutCommand(opts = {}) {
   const keychain = opts.keychain ?? getLifecycleKeychain();
   const api = createCliLoginApi(opts.fetchImpl);
-  const fail = (failure2, exit) => {
+  const fail2 = (failure2, exit) => {
     if (opts.json) process.stdout.write(`${JSON.stringify(failure2)}
 `);
     else process.stderr.write(`Error: ${failure2.message}
@@ -1868,19 +1962,19 @@ async function logoutCommand(opts = {}) {
   };
   try {
     const result = await withLifecycleLock(keychain, (lockLost) => logout(lockLost));
-    return result === BUSY ? fail(lifecycleFailure("busy", false), EXIT.BUSY) : result;
+    return result === BUSY ? fail2(lifecycleFailure("busy", false), EXIT.BUSY) : result;
   } catch (err) {
     const pending = await cleanupPendingAfterFailure(keychain);
     if (err instanceof KeychainError) {
-      return fail(lifecycleFailure("credential_store_unavailable", pending, err), err.exit);
+      return fail2(lifecycleFailure("credential_store_unavailable", pending, err), err.exit);
     }
     if (err instanceof LockLostError) {
-      return fail(lifecycleFailure("lock_lost", pending), EXIT.DOCTOR_FAIL);
+      return fail2(lifecycleFailure("lock_lost", pending), EXIT.DOCTOR_FAIL);
     }
     if (err instanceof JournalInvalidError) {
-      return fail(lifecycleFailure("journal_invalid", true), EXIT.DOCTOR_FAIL);
+      return fail2(lifecycleFailure("journal_invalid", true), EXIT.DOCTOR_FAIL);
     }
-    return fail(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
+    return fail2(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
   }
   async function logout(lockLost) {
     const journal = await loadJournal(keychain);
@@ -1902,7 +1996,7 @@ async function logoutCommand(opts = {}) {
     }
     const cleanupPending = !isEmpty(await settle(keychain, api, journal, lockLost));
     if (await keychain.read() !== null) {
-      return fail(lifecycleFailure("credential_changed", cleanupPending), EXIT.DOCTOR_FAIL);
+      return fail2(lifecycleFailure("credential_changed", cleanupPending), EXIT.DOCTOR_FAIL);
     }
     if (lockLost()) throw new LockLostError();
     const convergence = convergenceSeconds(journal);
@@ -1961,7 +2055,7 @@ async function signOutJournal(keychain) {
 }
 async function loginRecoveryCommand(opts = {}) {
   const keychain = opts.keychain ?? getLifecycleKeychain();
-  const fail = (failure2, exit) => {
+  const fail2 = (failure2, exit) => {
     if (opts.json) process.stdout.write(`${JSON.stringify(failure2)}
 `);
     else process.stderr.write(`Error: ${failure2.message}
@@ -1980,9 +2074,9 @@ async function loginRecoveryCommand(opts = {}) {
       if (lockLost()) throw new LockLostError();
       return settled;
     });
-    if (journal === BUSY) return fail(lifecycleFailure("busy", true), EXIT.BUSY);
+    if (journal === BUSY) return fail2(lifecycleFailure("busy", true), EXIT.BUSY);
     if (!isEmpty(journal)) {
-      return fail(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
+      return fail2(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
     }
     const convergence = convergenceSeconds(journal);
     const report4 = {
@@ -1997,16 +2091,16 @@ async function loginRecoveryCommand(opts = {}) {
     return EXIT.OK;
   } catch (err) {
     if (err instanceof JournalInvalidError) {
-      return fail(lifecycleFailure("journal_invalid", true), EXIT.DOCTOR_FAIL);
+      return fail2(lifecycleFailure("journal_invalid", true), EXIT.DOCTOR_FAIL);
     }
     const pending = await cleanupPendingAfterFailure(keychain);
     if (err instanceof KeychainError) {
-      return fail(lifecycleFailure("credential_store_unavailable", pending, err), err.exit);
+      return fail2(lifecycleFailure("credential_store_unavailable", pending, err), err.exit);
     }
     if (err instanceof LockLostError) {
-      return fail(lifecycleFailure("lock_lost", pending), EXIT.DOCTOR_FAIL);
+      return fail2(lifecycleFailure("lock_lost", pending), EXIT.DOCTOR_FAIL);
     }
-    return fail(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
+    return fail2(lifecycleFailure("cleanup_pending", true), EXIT.CLEANUP_PENDING);
   }
 }
 
@@ -2029,9 +2123,9 @@ function createReadCredentials(providerFactory) {
 }
 
 // src/mcp/proxy-server.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
-import { readFile, stat } from "fs/promises";
-import { basename, isAbsolute, resolve } from "path";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "crypto";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -2043,12 +2137,563 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/mcp/file-ingest-intents.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir2, readdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DELIVERED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_FILE_INGEST_INTENT_DIR = join2(homedir2(), ".pyx-memory", "file-ingests");
+function parseIntent(raw, file) {
+  const value = JSON.parse(raw);
+  const fp = value?.fingerprint;
+  if (value?.version !== 1 || typeof value.jobId !== "string" || typeof value.endpoint !== "string" || typeof value.delivered !== "boolean" || typeof value.createdAt !== "string" || typeof value.updatedAt !== "string" || typeof fp?.path !== "string" || typeof fp.byteLength !== "number" || typeof fp.sha256 !== "string") {
+    throw new Error(`file ingest intent ${file} is not a version 1 record; remove it to continue`);
+  }
+  return value;
+}
+async function readIntents(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  return Promise.all(
+    names.filter((name) => name.endsWith(".json")).map(async (name) => {
+      const file = join2(dir, name);
+      return { file, intent: parseIntent(await readFile(file, "utf8"), file) };
+    })
+  );
+}
+function createFileIngestIntentStore(dir = DEFAULT_FILE_INGEST_INTENT_DIR) {
+  return {
+    async findUndelivered(endpoint, path, namespaceId) {
+      const records = await readIntents(dir);
+      const prunedBefore = Date.now() - DELIVERED_RETENTION_MS;
+      await Promise.all(
+        records.filter(({ intent }) => intent.delivered && Date.parse(intent.updatedAt) < prunedBefore).map(({ file }) => rm(file, { force: true }))
+      );
+      return records.map(({ intent }) => intent).filter(
+        (intent) => !intent.delivered && intent.endpoint === endpoint && intent.fingerprint.path === path && intent.fingerprint.namespaceId === namespaceId
+      ).sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+    },
+    async save(intent) {
+      await mkdir2(dir, { recursive: true, mode: 448 });
+      const file = join2(dir, `${intent.jobId}.json`);
+      const temp = join2(dir, `.${intent.jobId}.${randomUUID3()}.tmp`);
+      await writeFile(temp, `${JSON.stringify(intent)}
+`, { mode: 384, flag: "wx" });
+      await rename(temp, file);
+    }
+  };
+}
+
+// src/mcp/hosted-file-ingest.ts
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
+import { createReadStream, openAsBlob } from "fs";
+import { stat } from "fs/promises";
+import { basename, isAbsolute, resolve } from "path";
+import { setTimeout as delay } from "timers/promises";
+function parseHostedFileIngestDescriptor(meta) {
+  if (meta === null || typeof meta !== "object") return void 0;
+  const value = meta[HOSTED_FILE_INGEST_PROTOCOL.metaKey];
+  if (value === null || typeof value !== "object") return void 0;
+  const { protocolVersion, endpoint, maxBytes } = value;
+  if (protocolVersion !== HOSTED_FILE_INGEST_PROTOCOL.version || typeof endpoint !== "string" || // Same-origin absolute path only: the keychain bearer goes with every request.
+  !endpoint.startsWith("/") || endpoint.startsWith("//") || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+    return void 0;
+  }
+  return { endpoint, maxBytes };
+}
+function toMicrocents(cents) {
+  const microcents = typeof cents === "number" && cents >= 0 ? Math.round(cents * 1e6) : Number.NaN;
+  return Number.isSafeInteger(microcents) ? String(microcents) : void 0;
+}
+function parseArgs(args) {
+  const { path, description, namespaceId, maxCostCents, cancel } = args;
+  const maxCostMicrocents = maxCostCents === void 0 ? void 0 : toMicrocents(maxCostCents);
+  if (typeof path !== "string" || path.length === 0) {
+    return "`path` must be a non-empty local file path.";
+  }
+  if (description !== void 0 && typeof description !== "string") {
+    return "`description` must be a string.";
+  }
+  if (namespaceId !== void 0 && (typeof namespaceId !== "string" || namespaceId.length === 0)) {
+    return "`namespaceId` must be a non-empty string.";
+  }
+  if (cancel !== void 0 && typeof cancel !== "boolean") return "`cancel` must be a boolean.";
+  if (maxCostCents !== void 0 && maxCostMicrocents === void 0) {
+    return "`maxCostCents` must be a non-negative number of cents.";
+  }
+  return {
+    path: isAbsolute(path) ? path : resolve(path),
+    description: description || null,
+    namespaceId: namespaceId ?? null,
+    maxCostMicrocents,
+    cancel: cancel === true
+  };
+}
+var CATALOG_STEPS = /* @__PURE__ */ new Set(["begin", "prepare", "commit", "publish"]);
+var DEADLINE_MS = {
+  begin: 15e3,
+  authorize: 15e3,
+  cancel: 15e3,
+  upload: 12e4,
+  prepare: 9e4,
+  commit: 16e4,
+  publish: 6e4
+};
+var RETRY_BUDGET_MS = 5 * 6e4;
+var DEFAULT_RETRY_AFTER_S = 2;
+var MAX_RETRY_AFTER_S = 30;
+var RESUME = "Call this tool again with the same arguments to resume the job.";
+var NEW_IMPORT = "Call this tool again to start a new import.";
+var NEXT_BY_CODE = /* @__PURE__ */ new Map([
+  [
+    "runtime_upgrade_required",
+    "The pyx-memory instance needs a runtime upgrade before file ingest can continue; call this tool again with the same arguments once it is upgraded."
+  ],
+  [
+    "file_ingest_job_limit",
+    "Your plan allows no more unfinished imports on this instance: finish or cancel another one (cancel: true with its path), then call this tool again with the same arguments."
+  ],
+  [
+    "file_ingest_disabled",
+    "Hosted file ingest is switched off on the server; call this tool again with the same arguments later to resume."
+  ],
+  [
+    "file_too_large",
+    "The file exceeds your plan's file-size cap: upgrade the plan and call again with the same arguments, or call with cancel: true to drop this import."
+  ],
+  [
+    "file_ingest_cancel_requested",
+    "The job is being cancelled: call this tool with cancel: true to confirm."
+  ]
+]);
+var ENDED_CODES = /* @__PURE__ */ new Set(["file_ingest_cancelled", "file_ingest_expired"]);
+var COST_CODES = /* @__PURE__ */ new Set([
+  "file_ingest_authorization_required",
+  "file_ingest_ceiling_exceeded",
+  "file_ingest_quota_paused",
+  "file_ingest_limit_exceeded"
+]);
+function nextAfter(res) {
+  if (res.status === 402) {
+    return "The wallet balance is too low: top up, then call this tool again with the same arguments to resume.";
+  }
+  return NEXT_BY_CODE.get(res.code ?? "") ?? RESUME;
+}
+var errorText = (err) => err instanceof Error ? err.message : String(err);
+var text = (result) => result.content.map((part) => part.text).join("\n");
+var fail = (result) => ({ ok: false, result });
+var refuse = (message) => fail(mcpText(message, true));
+var label = (intent) => `${basename(intent.fingerprint.path)} (job ${intent.jobId})`;
+async function hashFile(path) {
+  const hash = createHash4("sha256");
+  let byteLength = 0;
+  for await (const chunk of createReadStream(path)) {
+    hash.update(chunk);
+    byteLength += chunk.length;
+  }
+  return { byteLength, sha256: hash.digest("hex") };
+}
+async function matchIntent(intent, args, size) {
+  const fp = intent.fingerprint;
+  const changed = args.description !== fp.description || typeof size === "number" && (size !== fp.byteLength || (await hashFile(args.path)).sha256 !== fp.sha256);
+  if (!changed) return { ok: true, value: intent };
+  return refuse(
+    `${args.path} no longer matches ${label(intent)}: its content or description changed since that import started.
+Call this tool with cancel: true to abandon job ${intent.jobId}, then call again to import the file as it is now.`
+  );
+}
+function isRetryable(res) {
+  return res.status === 429 || res.status === 503 || HOSTED_FILE_INGEST_RETRYABLE_CODES.includes(res.code ?? "");
+}
+async function pause(ms, signal) {
+  await delay(ms, void 0, { signal }).catch((err) => {
+    if (!signal?.aborted) throw err;
+  });
+}
+function retryAfterMs(header) {
+  const value = header?.trim() ?? "";
+  const seconds = /^\d+$/.test(value) ? Number(value) : DEFAULT_RETRY_AFTER_S;
+  return Math.min(seconds, MAX_RETRY_AFTER_S) * 1e3;
+}
+function formatCents(microcents, decimals) {
+  const step = 10n ** BigInt(6 - decimals);
+  const units = (BigInt(microcents) + step - 1n) / step;
+  const scale = 10n ** BigInt(decimals);
+  return `${units / scale}.${String(units % scale).padStart(decimals, "0")}`;
+}
+function unwrapEnvelope(body) {
+  if (body === null || typeof body !== "object" || body.success !== true) {
+    throw new Error("the response is not a {success: true, data} envelope");
+  }
+  return body.data;
+}
+function createHostedFileIngestDriver(credentials, guard, intents, fetchImpl = fetch) {
+  const http = createHttpClient(credentials, fetchImpl);
+  const origin = new URL(credentials.endpoint).origin;
+  const stopped = (call, step, detail, next = RESUME) => mcpText(`Import of ${label(call.intent)} stopped at ${step}: ${detail}
+${next}`, true);
+  const interrupted = (call) => refuse(`The call was cancelled; ${label(call.intent)} keeps its progress.
+${RESUME}`);
+  const published = (call, publication) => mcpText(
+    `Ingested ${call.filename}: ${publication.entryCount} chunks stored (replaced ${publication.retiredCount}). job ${call.intent.jobId}`
+  );
+  async function record(call, state) {
+    if (call.intent.lastState === state) return;
+    call.intent.lastState = state;
+    call.intent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await intents.save(call.intent);
+  }
+  async function deliver(call, result) {
+    call.intent.delivered = true;
+    call.intent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await intents.save(call.intent);
+    return result;
+  }
+  function accept(call, step, body, parse) {
+    try {
+      return { ok: true, value: parse(unwrapEnvelope(body)) };
+    } catch (err) {
+      return fail(stopped(call, step, `invalid server response: ${errorText(err)}`));
+    }
+  }
+  async function exchange(call, step, attempt, parse) {
+    for (; ; ) {
+      await guard();
+      const res = await attempt(randomUUID4());
+      if (call.signal?.aborted) return interrupted(call);
+      if (res.ok) return accept(call, step, res.data, parse);
+      const waitMs = retryAfterMs(res.retryAfter);
+      if (!isRetryable(res) || Date.now() + waitMs > call.retryUntil)
+        return refused(call, step, res);
+      await pause(waitMs, call.signal);
+    }
+  }
+  function post(call, step, route, body, parse) {
+    const { namespaceId } = call.intent.fingerprint;
+    const scoped = CATALOG_STEPS.has(step) && namespaceId !== null;
+    return exchange(
+      call,
+      step,
+      (idempotencyKey) => http.requestJson({
+        method: "POST",
+        path: `${call.descriptor.endpoint}${route}`,
+        body: scoped ? { ...body, namespaceId } : body,
+        idempotencyKey,
+        timeoutMs: DEADLINE_MS[step],
+        signal: call.signal
+      }),
+      parse
+    );
+  }
+  async function upload(call, job) {
+    const token = job.upload?.token;
+    if (token === void 0) {
+      return fail(stopped(call, "upload", "the server issued no upload token"));
+    }
+    const { path, byteLength, sha256 } = call.intent.fingerprint;
+    let body;
+    try {
+      const current = await hashFile(path);
+      body = await openAsBlob(path);
+      if (current.sha256 !== sha256 || current.byteLength !== byteLength || body.size !== byteLength) {
+        throw new Error("it changed since the import started");
+      }
+    } catch (err) {
+      return fail(
+        stopped(
+          call,
+          "upload",
+          `cannot send ${path}: ${errorText(err)}`,
+          `Restore the file and call again to resume, or call with cancel: true to abandon job ${call.intent.jobId}.`
+        )
+      );
+    }
+    return exchange(
+      call,
+      "upload",
+      (idempotencyKey) => http.requestBytes({
+        method: "PUT",
+        path: `${call.descriptor.endpoint}/${call.intent.jobId}/content`,
+        body,
+        headers: { [HOSTED_FILE_INGEST_PROTOCOL.uploadTokenHeader]: token },
+        idempotencyKey,
+        timeoutMs: DEADLINE_MS.upload,
+        signal: call.signal
+      }),
+      parseHostedFileIngestJobView
+    );
+  }
+  async function refused(call, step, res) {
+    const detail = res.code === void 0 ? text(res.result) : `${text(res.result)} (${res.code})`;
+    if (CATALOG_STEPS.has(step) && COST_CODES.has(res.code ?? "")) {
+      return fail(await costRefusal(call, step, detail));
+    }
+    if (step === "prepare" && res.status === 422 || ENDED_CODES.has(res.code ?? "")) {
+      return fail(await deliver(call, stopped(call, step, detail, NEW_IMPORT)));
+    }
+    return { ok: false, status: res.status, result: stopped(call, step, detail, nextAfter(res)) };
+  }
+  async function costRefusal(call, step, detail) {
+    const auth = await post(
+      call,
+      "authorize",
+      `/${call.intent.jobId}/authorize`,
+      {},
+      parseHostedFileIngestAuthorization
+    );
+    if (!auth.ok) return stopped(call, step, detail);
+    await record(call, auth.value.state);
+    const { ceilingMicrocents, estimateMicrocents, settledMicrocents } = auth.value;
+    const cents = (microcents) => microcents === null ? "unknown" : `${formatCents(microcents, 2)} cents`;
+    return await authorizationStop(call, step, auth.value) ?? stopped(
+      call,
+      step,
+      `${detail}. The spending ceiling is ${cents(ceilingMicrocents)}, the estimated total ${cents(estimateMicrocents)}; charged so far ${formatCents(settledMicrocents, 4)} cents.`,
+      `Call this tool again with the same arguments and a maxCostCents above ${cents(ceilingMicrocents)} to continue.`
+    );
+  }
+  async function authorizationStop(call, step, auth, entryCount) {
+    const charged = `Charged so far: ${formatCents(auth.settledMicrocents, 4)} cents.`;
+    const chunks = entryCount === void 0 ? "its chunks" : `its ${entryCount} chunks`;
+    const stop = (detail, next) => stopped(call, step, `${detail} ${charged}`, next);
+    const resume = `call this tool again with the same arguments and maxCostCents of at least ${auth.estimateMicrocents === null ? "the estimate" : formatCents(auth.estimateMicrocents, 2)} to resume`;
+    switch (auth.state) {
+      case "quota_paused":
+        return stop(
+          `the project's memory quota has no room for ${chunks}.`,
+          `Free memory space or upgrade the plan, then ${resume}.`
+        );
+      case "limit_exceeded":
+        return stop(
+          "the document exceeds the plan limits for extracted text or chunks.",
+          `Upgrade the plan, then ${resume}; or call with cancel: true to abandon job ${call.intent.jobId}.`
+        );
+      case "cancel_requested":
+        return stop(
+          "the job is being cancelled.",
+          "Call this tool with cancel: true to confirm the cancellation."
+        );
+      case "cancelled":
+      case "expired":
+      case "failed":
+        return deliver(call, stop(`the job is ${auth.state}.`, NEW_IMPORT));
+    }
+    if (auth.authorized) return void 0;
+    if (auth.estimateMicrocents === null) {
+      return stop("the server has no cost estimate for the job yet.", RESUME);
+    }
+    const estimate = formatCents(auth.estimateMicrocents, 2);
+    const ceiling = auth.ceilingMicrocents === null ? "" : ` The current ceiling is ${formatCents(auth.ceilingMicrocents, 2)} cents.`;
+    return stop(
+      `storing ${chunks} needs your approval: the estimated cost is ${estimate} cents.${ceiling}`,
+      `Call this tool again with the same arguments and maxCostCents of at least ${estimate} to continue.`
+    );
+  }
+  async function commitPages(call, job, manifest) {
+    const committed = new Set(job.committedPages);
+    for (const page2 of manifest.pages) {
+      if (committed.has(page2.pageIndex)) continue;
+      const commit = await post(
+        call,
+        "commit",
+        `/${call.intent.jobId}/commit`,
+        { manifestSha256: manifest.manifestSha256, page: page2 },
+        parseHostedFileIngestCommitResult
+      );
+      if (!commit.ok) return commit.result;
+    }
+    return void 0;
+  }
+  async function finish(call, job, maxCostMicrocents) {
+    const manifest = job.manifest;
+    if (!manifest) return stopped(call, "prepare", "the prepared job has no manifest");
+    const auth = await post(
+      call,
+      "authorize",
+      `/${call.intent.jobId}/authorize`,
+      maxCostMicrocents === void 0 ? {} : { maxCostMicrocents },
+      parseHostedFileIngestAuthorization
+    );
+    if (!auth.ok) return auth.result;
+    await record(call, auth.value.state);
+    const halted = await authorizationStop(call, "authorize", auth.value, manifest.entryCount) ?? await commitPages(call, job, manifest);
+    if (halted) return halted;
+    const publish = await post(
+      call,
+      "publish",
+      `/${call.intent.jobId}/publish`,
+      { manifestSha256: manifest.manifestSha256, entryCount: manifest.entryCount },
+      parseHostedFileIngestPublishResult
+    );
+    if (!publish.ok) return publish.result;
+    await record(call, "published");
+    return deliver(call, published(call, publish.value));
+  }
+  async function ended(call, job) {
+    if (job.state === "published") {
+      return job.publication ? deliver(call, published(call, job.publication)) : stopped(call, "begin", "the published job has no publication result");
+    }
+    const what = job.state === "failed" ? `failed: ${job.error ? `${job.error.message} (${job.error.code})` : "no reason given"}` : `is ${job.state}.`;
+    return deliver(call, mcpText(`Import of ${label(call.intent)} ${what}
+${NEW_IMPORT}`, true));
+  }
+  async function ingest(call, maxCostMicrocents) {
+    const { fingerprint, jobId } = call.intent;
+    let next = await post(
+      call,
+      "begin",
+      "",
+      {
+        jobId,
+        filename: call.filename,
+        byteLength: fingerprint.byteLength,
+        sha256: fingerprint.sha256,
+        ...fingerprint.description === null ? {} : { description: fingerprint.description }
+      },
+      parseHostedFileIngestJobView
+    );
+    while (next.ok) {
+      const job = next.value;
+      await record(call, job.state);
+      switch (job.state) {
+        case "awaiting_upload":
+          next = await upload(call, job);
+          break;
+        case "uploaded":
+          next = await post(call, "prepare", `/${jobId}/prepare`, {}, parseHostedFileIngestJobView);
+          break;
+        case "prepared":
+          return finish(call, job, maxCostMicrocents);
+        default:
+          return ended(call, job);
+      }
+    }
+    return next.result;
+  }
+  async function cancel(call) {
+    const res = await post(
+      call,
+      "cancel",
+      `/${call.intent.jobId}/cancel`,
+      {},
+      parseHostedFileIngestAuthorization
+    );
+    if (!res.ok) {
+      if (res.status !== 404) return res.result;
+      return deliver(
+        call,
+        mcpText(`The server has no ${label(call.intent)}; nothing to cancel.
+${NEW_IMPORT}`, true)
+      );
+    }
+    const { state, settledMicrocents } = res.value;
+    await record(call, state);
+    const charged = `Charged: ${formatCents(settledMicrocents, 4)} cents.`;
+    switch (state) {
+      case "cancelled":
+        return deliver(
+          call,
+          mcpText(`Cancelled ${label(call.intent)}. ${charged}
+${NEW_IMPORT}`, true)
+        );
+      case "published":
+      case "expired":
+      case "failed":
+        return deliver(
+          call,
+          mcpText(
+            `${label(call.intent)} was already ${state}; nothing to cancel. ${charged}
+${NEW_IMPORT}`,
+            true
+          )
+        );
+      default:
+        return mcpText(
+          `Cancel of ${label(call.intent)} is ${state}: it stops once outstanding work settles. ${charged}
+Call this tool with cancel: true again to confirm.`,
+          true
+        );
+    }
+  }
+  async function openIntent(descriptor, args, existing) {
+    const size = await stat(args.path).then(
+      (info) => info.size,
+      (err) => err
+    );
+    if (existing) return matchIntent(existing, args, size);
+    if (typeof size !== "number") return refuse(`Failed to read ${args.path}: ${size.message}.`);
+    if (size === 0) return refuse(`${args.path} is empty.`);
+    if (size > descriptor.maxBytes) {
+      return refuse(`File too large: ${size} bytes > ${descriptor.maxBytes} cap.`);
+    }
+    try {
+      requireHostedFileIngestFilename(basename(args.path), "the file name");
+    } catch (err) {
+      return refuse(`Cannot import ${args.path}: ${errorText(err)}.`);
+    }
+    const { byteLength, sha256 } = await hashFile(args.path);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const intent = {
+      version: 1,
+      jobId: randomUUID4(),
+      endpoint: origin,
+      fingerprint: {
+        path: args.path,
+        byteLength,
+        sha256,
+        description: args.description,
+        namespaceId: args.namespaceId
+      },
+      lastState: null,
+      delivered: false,
+      createdAt: now,
+      updatedAt: now
+    };
+    await intents.save(intent);
+    return { ok: true, value: intent };
+  }
+  return async (descriptor, rawArgs, signal) => {
+    const args = parseArgs(rawArgs);
+    if (typeof args === "string") return mcpText(args, true);
+    let intent;
+    const callOn = (value) => ({
+      descriptor,
+      intent: value,
+      filename: basename(value.fingerprint.path),
+      signal,
+      retryUntil: Date.now() + RETRY_BUDGET_MS
+    });
+    try {
+      await guard();
+      const existing = await intents.findUndelivered(origin, args.path, args.namespaceId);
+      if (args.cancel) {
+        if (!existing) return mcpText(`No hosted import of ${args.path} to cancel.`, true);
+        intent = existing;
+        return await cancel(callOn(intent));
+      }
+      const opened = await openIntent(descriptor, args, existing);
+      if (!opened.ok) return opened.result;
+      intent = opened.value;
+      return await ingest(callOn(intent), args.maxCostMicrocents);
+    } catch (err) {
+      return mcpText(intent ? `${errorText(err)}
+job ${intent.jobId}` : errorText(err), true);
+    }
+  };
+}
+
 // src/mcp/tools/shared.ts
 var LOCAL_UPLOAD_META_KEY = "pyx.dev/local-upload";
 
 // src/mcp/proxy-server.ts
 var REMOTE_MCP_PATH = "/mcp";
-function createMcpIdempotentFetch(fetchImpl = fetch, sessionNonce = randomUUID3()) {
+function createMcpIdempotentFetch(fetchImpl = fetch, sessionNonce = randomUUID5()) {
   const wrapped = async (input, init) => {
     const upstream = input instanceof Request ? input : new Request(String(input), init);
     const method = init?.method ?? upstream.method;
@@ -2058,7 +2703,7 @@ function createMcpIdempotentFetch(fetchImpl = fetch, sessionNonce = randomUUID3(
       if (typeof body !== "string") {
         throw new Error("remote MCP POST body must be text for stable request idempotency");
       }
-      const key = createHash4("sha256").update("pyx-mcp-idempotency-v1\0").update(sessionNonce).update("\0").update(body).digest("hex");
+      const key = createHash5("sha256").update("pyx-mcp-idempotency-v1\0").update(sessionNonce).update("\0").update(body).digest("hex");
       headers.set("Idempotency-Key", `mcp-${key}`);
     }
     return fetchImpl(input, { ...init, method, headers, body });
@@ -2111,10 +2756,10 @@ async function readCappedLocalFile(rawPath, descriptor) {
       result: mcpText(`\`${descriptor.pathArg}\` must be a non-empty local file path.`, true)
     };
   }
-  const abs = isAbsolute(rawPath) ? rawPath : resolve(rawPath);
+  const abs = isAbsolute2(rawPath) ? rawPath : resolve2(rawPath);
   try {
     if (typeof descriptor.maxBytes === "number") {
-      const info = await stat(abs);
+      const info = await stat2(abs);
       if (info.size > descriptor.maxBytes) {
         return {
           ok: false,
@@ -2122,7 +2767,7 @@ async function readCappedLocalFile(rawPath, descriptor) {
         };
       }
     }
-    return { ok: true, bytes: await readFile(abs), name: basename(abs) };
+    return { ok: true, bytes: await readFile2(abs), name: basename2(abs) };
   } catch (err) {
     return {
       ok: false,
@@ -2160,7 +2805,7 @@ function createLocalFileUploader(credentials, readCredentials, fetchImpl = fetch
     }
   };
 }
-function createProxyServer(client, version, uploadLocalFile) {
+function createProxyServer(client, version, uploadLocalFile, hostedFileIngest) {
   const caps = client.getServerCapabilities();
   const server = new Server(client.getServerVersion() ?? { name: "pyx-memory", version }, {
     capabilities: {
@@ -2173,39 +2818,48 @@ function createProxyServer(client, version, uploadLocalFile) {
     },
     instructions: client.getInstructions()
   });
-  const localUploads = /* @__PURE__ */ new Map();
+  const bridges = /* @__PURE__ */ new Map();
+  const bridging = uploadLocalFile !== void 0 || hostedFileIngest !== void 0;
+  const bridgeOf = (meta) => {
+    const hosted = hostedFileIngest ? parseHostedFileIngestDescriptor(meta) : void 0;
+    if (hosted) return { kind: "hosted", descriptor: hosted };
+    const local = uploadLocalFile ? extractLocalUpload(meta) : void 0;
+    return local ? { kind: "local", descriptor: local } : void 0;
+  };
   let listedOnce = false;
-  const refreshFromList = (result) => {
-    const tools = result.tools;
-    if (Array.isArray(tools)) {
-      listedOnce = true;
-      for (const tool of tools) {
-        const descriptor = uploadLocalFile ? extractLocalUpload(tool._meta) : void 0;
-        if (descriptor) localUploads.set(tool.name, descriptor);
-        else localUploads.delete(tool.name);
-      }
+  let listingsStarted = 0;
+  let listingApplied = 0;
+  const listAndRefresh = async (params) => {
+    const listing = ++listingsStarted;
+    const result = await client.listTools(params);
+    const { tools, nextCursor } = result;
+    if (!Array.isArray(tools) || listing < listingApplied) return result;
+    listingApplied = listing;
+    listedOnce = true;
+    if (params?.cursor === void 0 && nextCursor === void 0) bridges.clear();
+    for (const tool of tools) {
+      const bridge = bridgeOf(tool._meta);
+      if (bridge) bridges.set(tool.name, bridge);
+      else bridges.delete(tool.name);
     }
     return result;
   };
   if (caps?.tools) {
-    server.setRequestHandler(
-      ListToolsRequestSchema,
-      async (req) => refreshFromList(await client.listTools(req.params))
-    );
-    server.setRequestHandler(CallToolRequestSchema, async (req) => {
-      if (uploadLocalFile && !listedOnce) {
+    server.setRequestHandler(ListToolsRequestSchema, (req) => listAndRefresh(req.params));
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
+      if (bridging && !listedOnce) {
         try {
-          refreshFromList(await client.listTools());
+          await listAndRefresh();
         } catch {
         }
       }
-      const descriptor = uploadLocalFile ? localUploads.get(req.params.name) : void 0;
-      if (uploadLocalFile && descriptor) {
-        const result = await uploadLocalFile(
-          descriptor,
-          req.params.arguments ?? {}
-        );
-        return result;
+      const bridge = bridges.get(req.params.name);
+      const args = req.params.arguments ?? {};
+      if (bridge?.kind === "hosted" && hostedFileIngest) {
+        return await hostedFileIngest(bridge.descriptor, args, extra.signal);
+      }
+      if (bridge?.kind === "local" && uploadLocalFile) {
+        return await uploadLocalFile(bridge.descriptor, args);
       }
       return client.callTool(req.params);
     });
@@ -2223,7 +2877,7 @@ function createProxyServer(client, version, uploadLocalFile) {
   return server;
 }
 async function runMcpProxyServer(opts) {
-  const version = opts.version ?? (true ? "1.23.1" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.24.0" : "0.0.0-dev");
   const read = await opts.readCredentials();
   if (!read.ok) {
     throw new Error(
@@ -2232,12 +2886,11 @@ async function runMcpProxyServer(opts) {
   }
   const { endpoint, apiKey } = read.credentials;
   const url = new URL(`${endpoint.replace(/\/+$/, "")}${REMOTE_MCP_PATH}`);
+  const guard = createCredentialGuard(opts.readCredentials, read.credentials);
   const client = new McpClient({ name: "pyx-mem-proxy", version }, { capabilities: {} });
   const clientTransport = new StreamableHTTPClientTransport(url, {
     requestInit: { headers: { Authorization: `Bearer ${apiKey}` } },
-    fetch: createMcpIdempotentFetch(
-      createGuardedFetch(createCredentialGuard(opts.readCredentials, read.credentials))
-    )
+    fetch: createMcpIdempotentFetch(createGuardedFetch(guard))
   });
   try {
     await client.connect(clientTransport);
@@ -2251,11 +2904,12 @@ async function runMcpProxyServer(opts) {
     const server = createProxyServer(
       client,
       version,
-      createLocalFileUploader(read.credentials, opts.readCredentials)
+      createLocalFileUploader(read.credentials, opts.readCredentials),
+      createHostedFileIngestDriver(read.credentials, guard, createFileIngestIntentStore())
     );
     const transport = new StdioServerTransport();
-    const closed = new Promise((resolve3) => {
-      transport.onclose = () => resolve3();
+    const closed = new Promise((resolve4) => {
+      transport.onclose = () => resolve4();
     });
     process.stdin.once("end", () => void transport.close());
     await server.connect(transport);
@@ -2270,8 +2924,8 @@ async function runMcpProxyServer(opts) {
 // src/cli/commands/mcp-install.ts
 import { spawnSync as nodeSpawnSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 
 // src/cli/commands/mcp-install-merge.ts
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
@@ -2384,12 +3038,12 @@ function recordsEqual(a, b) {
   }
   return true;
 }
-function indent(text) {
-  return text.split("\n").map((line) => `  ${line}`).join("\n");
+function indent(text2) {
+  return text2.split("\n").map((line) => `  ${line}`).join("\n");
 }
 
 // src/cli/commands/memory-rules-merge.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import {
   chmodSync,
   existsSync as existsSync2,
@@ -2586,7 +3240,7 @@ function writeMemoryRulesFile(opts) {
   const parent = dirname3(target);
   if (!existsSync2(parent)) mkdirSync2(parent, { recursive: true });
   const mode = fileExists ? statSync(target).mode & 511 : 420;
-  const tmpPath = `${target}.${process.pid}.${randomUUID4()}.tmp`;
+  const tmpPath = `${target}.${process.pid}.${randomUUID6()}.tmp`;
   try {
     writeFileSync2(tmpPath, merged.content, { mode });
     chmodSync(tmpPath, mode);
@@ -2671,7 +3325,7 @@ function mcpInstallCodexCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
-  const home = opts._homeDir ?? homedir2();
+  const home = opts._homeDir ?? homedir3();
   const codexHome = (opts._env ?? process.env).CODEX_HOME;
   const probe = spawnSync("codex", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
@@ -2702,7 +3356,7 @@ Restart Codex CLI to make the tools available. No API key was written to config.
   return EXIT.OK;
 }
 function printCodexManualInstructions(home, remote, codexHome) {
-  const configPath = join2(codexHome ?? join2(home, ".codex"), "config.toml");
+  const configPath = join3(codexHome ?? join3(home, ".codex"), "config.toml");
   process.stdout.write(
     [
       "The `codex` CLI is not on PATH, or the install command failed.",
@@ -2725,8 +3379,8 @@ function printCodexManualInstructions(home, remote, codexHome) {
 function mcpInstallCursorCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
-  const home = opts._homeDir ?? homedir2();
-  const filePath = scope === "project" ? join2(process.cwd(), ".cursor", "mcp.json") : join2(home, ".cursor", "mcp.json");
+  const home = opts._homeDir ?? homedir3();
+  const filePath = scope === "project" ? join3(process.cwd(), ".cursor", "mcp.json") : join3(home, ".cursor", "mcp.json");
   return writeJsonAndReport(filePath, "Cursor", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallClineCommand(opts = {}) {
@@ -2757,8 +3411,8 @@ function mcpInstallContinueCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
   const remote = opts.remote ?? false;
-  const home = opts._homeDir ?? homedir2();
-  const yamlPath = join2(home, ".continue", "mcpServers", `${SERVER_NAME}.yaml`);
+  const home = opts._homeDir ?? homedir3();
+  const yamlPath = join3(home, ".continue", "mcpServers", `${SERVER_NAME}.yaml`);
   process.stdout.write(
     [
       "Continue uses YAML config. The recommended way to add an MCP server is a",
@@ -2789,8 +3443,8 @@ function mcpInstallContinueCommand(opts = {}) {
 function mcpInstallWindsurfCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
-  const home = opts._homeDir ?? homedir2();
-  const filePath = join2(home, ".codeium", "windsurf", "mcp_config.json");
+  const home = opts._homeDir ?? homedir3();
+  const filePath = join3(home, ".codeium", "windsurf", "mcp_config.json");
   return writeJsonAndReport(filePath, "Windsurf", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallGeminiCliCommand(opts = {}) {
@@ -2798,7 +3452,7 @@ function mcpInstallGeminiCliCommand(opts = {}) {
   if (!validateScope(scope)) return EXIT.USAGE;
   const remote = opts.remote ?? false;
   const spawnSync = opts._spawnSync ?? nodeSpawnSync;
-  const home = opts._homeDir ?? homedir2();
+  const home = opts._homeDir ?? homedir3();
   const probe = spawnSync("gemini", ["--version"], { stdio: "pipe" });
   if (probe.error || probe.status !== 0) {
     return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI", mcpEntry(remote));
@@ -2819,13 +3473,13 @@ Restart Gemini CLI to make the tools available. No API key was written to settin
   return EXIT.OK;
 }
 function geminiConfigPath(home, scope) {
-  return scope === "project" ? join2(process.cwd(), ".gemini", "settings.json") : join2(home, ".gemini", "settings.json");
+  return scope === "project" ? join3(process.cwd(), ".gemini", "settings.json") : join3(home, ".gemini", "settings.json");
 }
 function mcpInstallPiCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
-  const home = opts._homeDir ?? homedir2();
-  const filePath = scope === "user" ? join2(home, ".pi", "agent", "mcp.json") : join2(process.cwd(), ".pi", "mcp.json");
+  const home = opts._homeDir ?? homedir3();
+  const filePath = scope === "user" ? join3(home, ".pi", "agent", "mcp.json") : join3(process.cwd(), ".pi", "mcp.json");
   return writeJsonAndReport(filePath, "Pi", mcpEntry(opts.remote ?? false), {
     prereq: "pi has no native MCP support \u2014 install the third-party adapter once:\n  pi install npm:pi-mcp-adapter"
   });
@@ -2833,8 +3487,8 @@ function mcpInstallPiCommand(opts = {}) {
 function mcpInstallOhMyPiCommand(opts = {}) {
   const scope = opts.scope ?? "user";
   if (!validateScope(scope)) return EXIT.USAGE;
-  const home = opts._homeDir ?? homedir2();
-  const filePath = scope === "user" ? join2(home, ".omp", "agent", "mcp.json") : join2(process.cwd(), ".omp", "mcp.json");
+  const home = opts._homeDir ?? homedir3();
+  const filePath = scope === "user" ? join3(home, ".omp", "agent", "mcp.json") : join3(process.cwd(), ".omp", "mcp.json");
   return writeJsonAndReport(filePath, "oh-my-pi", mcpEntry(opts.remote ?? false));
 }
 function mcpInstallOpenClawCommand(opts = {}) {
@@ -2942,7 +3596,7 @@ function rulesFilePath(target, opts) {
   const spec = RULES_FILE_TARGETS[target];
   const env = opts._env ?? (opts._homeDir === void 0 ? process.env : {});
   const configDir = spec.envDir ? env[spec.envDir] : void 0;
-  return configDir ? join2(configDir, spec.file) : join2(opts._homeDir ?? homedir2(), ...spec.dir, spec.file);
+  return configDir ? join3(configDir, spec.file) : join3(opts._homeDir ?? homedir3(), ...spec.dir, spec.file);
 }
 function installMemoryRules(opts) {
   const filePath = rulesFilePath(opts.target, opts);
@@ -3006,8 +3660,8 @@ async function syncMemoryRulesFromServer(client, opts = {}) {
     );
   }
 }
-function isRulesSection(text) {
-  return text.startsWith("## Persistent Memory\n") && Buffer.byteLength(text, "utf8") <= MAX_SERVER_RULES_BYTES && !text.includes("<!-- pyx-memory:") && !/^\s*(```|~~~)/m.test(text);
+function isRulesSection(text2) {
+  return text2.startsWith("## Persistent Memory\n") && Buffer.byteLength(text2, "utf8") <= MAX_SERVER_RULES_BYTES && !text2.includes("<!-- pyx-memory:") && !/^\s*(```|~~~)/m.test(text2);
 }
 function validateScope(scope) {
   if (VALID_SCOPES.has(scope)) return true;
@@ -3140,7 +3794,7 @@ function boundedLabel(value, fallback, maxChars) {
 
 // src/cli/commands/scaffold.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
-import { basename as basename2, join as join3, resolve as resolve2 } from "path";
+import { basename as basename3, join as join4, resolve as resolve3 } from "path";
 var SERVER_IMAGE = "ghcr.io/pyx-corp/pyx-memory-v1:latest";
 var DOCKER_COMPOSE = `services:
   pyx-memory:
@@ -3263,17 +3917,17 @@ function resolveTarget(args) {
     process.stderr.write("Error: --name requires a non-empty directory name.\n");
     return null;
   }
-  const targetDir = trimmedName ? resolve2(cwd, trimmedName) : cwd;
-  const appName = trimmedName || basename2(resolve2(cwd));
+  const targetDir = trimmedName ? resolve3(cwd, trimmedName) : cwd;
+  const appName = trimmedName || basename3(resolve3(cwd));
   return { targetDir, appName };
 }
 function buildFiles(targetDir, appName) {
   return [
-    { path: join3(targetDir, "docker-compose.yml"), contents: DOCKER_COMPOSE },
-    { path: join3(targetDir, ".env.example"), contents: ENV_EXAMPLE },
-    { path: join3(targetDir, "memory.ts"), contents: MEMORY_TS },
+    { path: join4(targetDir, "docker-compose.yml"), contents: DOCKER_COMPOSE },
+    { path: join4(targetDir, ".env.example"), contents: ENV_EXAMPLE },
+    { path: join4(targetDir, "memory.ts"), contents: MEMORY_TS },
     {
-      path: join3(targetDir, "PYX_MEMORY_DESIGN_GUIDE.md"),
+      path: join4(targetDir, "PYX_MEMORY_DESIGN_GUIDE.md"),
       contents: buildDesignGuide({ appName })
     }
   ];
@@ -3290,7 +3944,7 @@ function scaffoldCommand(args = {}) {
   const created = [];
   const skipped = [];
   for (const file of buildFiles(target.targetDir, target.appName)) {
-    const relativePath = basename2(file.path);
+    const relativePath = basename3(file.path);
     if (existsSync4(file.path)) {
       skipped.push(relativePath);
       continue;
@@ -3511,7 +4165,7 @@ Notes:
 
 // src/cli/parser.ts
 var COMMANDS_WITH_SUBCOMMAND = /* @__PURE__ */ new Set(["mcp"]);
-function parseArgs(argv) {
+function parseArgs2(argv) {
   const flags = /* @__PURE__ */ Object.create(null);
   const positional = [];
   let i = 0;
@@ -3642,7 +4296,7 @@ function runLogin(parsed) {
   });
 }
 async function main() {
-  const parsed = parseArgs(process.argv.slice(2));
+  const parsed = parseArgs2(process.argv.slice(2));
   if (parsed.flags.help === true || parsed.flags.h === true) {
     process.stdout.write(HELP_TEXT);
     return EXIT.OK;