@ametyst/cli 0.3.5 → 0.3.7

package/dist/index.js

@@ -106446,7 +106446,12 @@ function loadConfig() {
       // pbi-wallet-3 — projected, or the cached stance would survive exactly one
       // process and then vanish (the whitelist warning above).
       ...typeof p.requireWalletPassphrase === "boolean" ? { requireWalletPassphrase: p.requireWalletPassphrase } : {},
-      ...typeof p.requireWalletPassphraseObservedAt === "string" ? { requireWalletPassphraseObservedAt: p.requireWalletPassphraseObservedAt } : {}
+      ...typeof p.requireWalletPassphraseObservedAt === "string" ? { requireWalletPassphraseObservedAt: p.requireWalletPassphraseObservedAt } : {},
+      // The workspace binding — projected, or a switch could never be detected:
+      // the key would survive exactly one process and then vanish (the whitelist
+      // warning above), making every login look like a first binding.
+      ...typeof p.workspaceId === "string" ? { workspaceId: p.workspaceId } : {},
+      ...typeof p.workspaceIdObservedAt === "string" ? { workspaceIdObservedAt: p.workspaceIdObservedAt } : {}
     };
   } catch {
     return null;
@@ -111782,7 +111787,8 @@ __export(core_exports, {
   reencryptPlaintextVault: () => reencryptPlaintextVault,
   safeVaultErrorMessage: () => safeVaultErrorMessage,
   saveWallet: () => saveWallet,
-  wipeVault: () => wipeVault
+  wipeVault: () => wipeVault,
+  writeSecretFileAtomic: () => writeSecretFileAtomic
 });
 import {
   chmodSync as chmodSync2,
@@ -111873,8 +111879,11 @@ function writeAllSync(fd, buf) {
 }
 function writeVaultFileAtomic(contents) {
   ensureDirectories();
-  const dir = dirname5(VAULT_PATH);
-  const tmp = join5(dir, `.wallet.json.tmp-${process.pid}-${randomBytes3(8).toString("hex")}`);
+  writeSecretFileAtomic(VAULT_PATH, contents);
+}
+function writeSecretFileAtomic(path2, contents) {
+  const dir = dirname5(path2);
+  const tmp = join5(dir, `.${basename3(path2)}.tmp-${process.pid}-${randomBytes3(8).toString("hex")}`);
   let fd;
   try {
     fd = openSync(tmp, "wx", 384);
@@ -111883,7 +111892,7 @@ function writeVaultFileAtomic(contents) {
     fsyncSync(fd);
     closeSync(fd);
     fd = void 0;
-    renameSync(tmp, VAULT_PATH);
+    renameSync(tmp, path2);
     fsyncDir(dir);
   } catch (e) {
     if (fd !== void 0) {
@@ -112013,6 +112022,236 @@ var init_core = __esm({
   }
 });
 
+// src/wallet/grant-keystore.ts
+var grant_keystore_exports = {};
+__export(grant_keystore_exports, {
+  GRANT_ENTRY_FORMAT: () => GRANT_ENTRY_FORMAT,
+  MissingGrantKeyError: () => MissingGrantKeyError,
+  buildGrantVault: () => buildGrantVault,
+  createGrantKeyIssuer: () => createGrantKeyIssuer,
+  deleteGrantEntry: () => deleteGrantEntry,
+  ensureGrantsDir: () => ensureGrantsDir,
+  generateGrantKey: () => generateGrantKey,
+  grantEntryPath: () => grantEntryPath,
+  grantsDir: () => grantsDir,
+  hasGrantSigningKey: () => hasGrantSigningKey,
+  isMissingGrantKeyError: () => isMissingGrantKeyError,
+  listGrantAddresses: () => listGrantAddresses,
+  listGrantEntries: () => listGrantEntries,
+  missingGrantKeyMessage: () => missingGrantKeyMessage,
+  normalizeGrantAddress: () => normalizeGrantAddress,
+  parseGrantEntry: () => parseGrantEntry,
+  persistGrantKey: () => persistGrantKey,
+  readGrantEntry: () => readGrantEntry,
+  recordGrantRowId: () => recordGrantRowId,
+  resolveGrantSigningKey: () => resolveGrantSigningKey
+});
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync4, unlinkSync as unlinkSync5 } from "fs";
+import { join as join6 } from "path";
+function grantsDir() {
+  return join6(WALLETS_DIR, "grants");
+}
+function resolveDir(dir) {
+  return dir ?? grantsDir();
+}
+function ensureGrantsDir(dir) {
+  const target = resolveDir(dir);
+  if (target === grantsDir()) ensureDirectories();
+  if (!existsSync7(target)) mkdirSync6(target, { mode: 448, recursive: true });
+  return target;
+}
+function normalizeGrantAddress(address) {
+  if (typeof address !== "string" || !ADDRESS_RE2.test(address)) {
+    throw new Error(`Not a 0x-hex EOA address: ${JSON.stringify(address)}`);
+  }
+  return address.toLowerCase();
+}
+function grantEntryPath(address, dir) {
+  return join6(resolveDir(dir), `${normalizeGrantAddress(address)}.json`);
+}
+function generateGrantKey() {
+  const derived = derivePlaintextWallet(generatePrivateKey());
+  return { address: derived.address.toLowerCase(), privateKey: derived.privateKey };
+}
+function buildGrantVault(address, privateKey, options) {
+  if (options.encrypted) {
+    if (!options.passphrase) {
+      throw new Error(
+        "Refusing to store a session key unencrypted: this machine's wallet is passphrase-protected but no passphrase is in memory. Call start_session({ passphrase }) first."
+      );
+    }
+    return JSON.parse(importWallet(privateKey, options.passphrase));
+  }
+  return JSON.parse(serializePlaintextVault(address, privateKey));
+}
+function persistGrantKey(params, dir) {
+  const address = normalizeGrantAddress(params.address);
+  const target = ensureGrantsDir(dir);
+  const entry = {
+    format: GRANT_ENTRY_FORMAT,
+    address,
+    createdAt: params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceId: params.workspaceId ?? null,
+    policyId: params.policyId ?? null,
+    backendWalletRowId: params.backendWalletRowId ?? null,
+    vault: buildGrantVault(address, params.privateKey, {
+      encrypted: params.encrypted,
+      passphrase: params.passphrase
+    })
+  };
+  writeSecretFileAtomic(join6(target, `${address}.json`), JSON.stringify(entry, null, 2));
+  return entry;
+}
+function parseGrantEntry(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const p = parsed;
+  if (p.format !== GRANT_ENTRY_FORMAT) return null;
+  if (typeof p.address !== "string" || !ADDRESS_RE2.test(p.address)) return null;
+  if (p.vault === null || typeof p.vault !== "object" || Array.isArray(p.vault)) return null;
+  return {
+    format: GRANT_ENTRY_FORMAT,
+    address: p.address.toLowerCase(),
+    createdAt: typeof p.createdAt === "string" ? p.createdAt : "",
+    workspaceId: typeof p.workspaceId === "string" ? p.workspaceId : null,
+    policyId: typeof p.policyId === "number" ? p.policyId : null,
+    backendWalletRowId: typeof p.backendWalletRowId === "string" ? p.backendWalletRowId : null,
+    vault: p.vault
+  };
+}
+function readGrantEntry(address, dir) {
+  let path2;
+  try {
+    path2 = grantEntryPath(address, dir);
+  } catch {
+    return null;
+  }
+  try {
+    return parseGrantEntry(readFileSync7(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listGrantEntries(dir) {
+  const target = resolveDir(dir);
+  let names;
+  try {
+    names = readdirSync4(target);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    let raw;
+    try {
+      raw = readFileSync7(join6(target, name), "utf-8");
+    } catch {
+      continue;
+    }
+    const entry = parseGrantEntry(raw);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+function listGrantAddresses(options = {}, dir) {
+  const active = options.workspaceId ?? null;
+  return listGrantEntries(dir).filter((e) => active === null || e.workspaceId === null || e.workspaceId === active).map((e) => e.address);
+}
+function recordGrantRowId(address, rowId, dir) {
+  const entry = readGrantEntry(address, dir);
+  if (!entry) return false;
+  try {
+    const next = { ...entry, backendWalletRowId: rowId ?? null };
+    writeSecretFileAtomic(grantEntryPath(address, dir), JSON.stringify(next, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteGrantEntry(address, dir) {
+  try {
+    unlinkSync5(grantEntryPath(address, dir));
+  } catch {
+  }
+}
+function missingGrantKeyMessage(address) {
+  return `no local key for grant address ${address} \u2014 this machine cannot sign for that grant. Run requestAccess again to mint a fresh session key and have your admin approve it.`;
+}
+function isMissingGrantKeyError(err) {
+  return err instanceof MissingGrantKeyError;
+}
+function hasGrantSigningKey(params) {
+  let address;
+  try {
+    address = normalizeGrantAddress(params.address);
+  } catch {
+    return false;
+  }
+  if (readGrantEntry(address, params.dir)) return true;
+  return typeof params.vaultAddress === "string" && params.vaultAddress.toLowerCase() === address;
+}
+function resolveGrantSigningKey(params) {
+  const address = normalizeGrantAddress(params.address);
+  const entry = readGrantEntry(address, params.dir);
+  if (entry) {
+    return readVaultPrivateKey(JSON.stringify(entry.vault), params.passphrase);
+  }
+  const vaultAddress = params.vaultAddress;
+  if (params.vaultJson && typeof vaultAddress === "string" && vaultAddress.toLowerCase() === address) {
+    return readVaultPrivateKey(params.vaultJson, params.passphrase);
+  }
+  throw new MissingGrantKeyError(address);
+}
+function createGrantKeyIssuer(options) {
+  return {
+    issue({ policyId }) {
+      const { address, privateKey } = generateGrantKey();
+      persistGrantKey(
+        {
+          address,
+          privateKey,
+          encrypted: options.encrypted,
+          passphrase: options.passphrase,
+          workspaceId: options.workspaceId ?? null,
+          policyId
+        },
+        options.dir
+      );
+      return address;
+    },
+    recordRow(address, rowId) {
+      recordGrantRowId(address, rowId, options.dir);
+    }
+  };
+}
+var GRANT_ENTRY_FORMAT, ADDRESS_RE2, MissingGrantKeyError;
+var init_grant_keystore = __esm({
+  "src/wallet/grant-keystore.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_accounts();
+    init_paths();
+    init_core();
+    init_plaintext_vault();
+    GRANT_ENTRY_FORMAT = "grant-key-v1";
+    ADDRESS_RE2 = /^0x[0-9a-fA-F]{40}$/;
+    MissingGrantKeyError = class extends Error {
+      grantAddress;
+      constructor(address) {
+        super(missingGrantKeyMessage(address));
+        this.name = "MissingGrantKeyError";
+        this.grantAddress = address;
+      }
+    };
+  }
+});
+
 // src/commands/init-claim.ts
 var init_claim_exports = {};
 __export(init_claim_exports, {
@@ -112026,7 +112265,7 @@ __export(init_claim_exports, {
   vaultBackupPath: () => vaultBackupPath,
   vaultBackupSuffix: () => vaultBackupSuffix
 });
-import { chmodSync as chmodSync3, constants as fsConstants, copyFileSync as copyFileSync3, existsSync as existsSync7 } from "fs";
+import { chmodSync as chmodSync3, constants as fsConstants, copyFileSync as copyFileSync3, existsSync as existsSync8 } from "fs";
 import { createDecipheriv as createDecipheriv2 } from "crypto";
 function claimErrorMessage(failure) {
   switch (failure.kind) {
@@ -112169,7 +112408,7 @@ function vaultBackupPath(vaultPath, at) {
   return `${vaultPath}.bak-${vaultBackupSuffix(at)}`;
 }
 function backupVaultFile(vaultPath, at = /* @__PURE__ */ new Date()) {
-  if (!existsSync7(vaultPath)) return null;
+  if (!existsSync8(vaultPath)) return null;
   const target = vaultBackupPath(vaultPath, at);
   try {
     copyFileSync3(vaultPath, target, fsConstants.COPYFILE_EXCL);
@@ -112197,13 +112436,13 @@ var init_version5 = __esm({
   "src/version.ts"() {
     "use strict";
     init_esm_shims();
-    CLI_VERSION = true ? "0.3.5" : "0.0.0-dev";
+    CLI_VERSION = true ? "0.3.7" : "0.0.0-dev";
   }
 });
 
 // src/connections/catalog.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 function declaredVerbsHeader() {
   return SUPPORTED_HTTP_METHODS.join(",");
 }
@@ -112459,8 +112698,8 @@ function parseConnectorsResponseDetailed(body, onWarn = warnToStderr) {
 function readCachedCatalogStatus() {
   let raw;
   try {
-    if (!existsSync8(CONNECTOR_CACHE_PATH)) return { state: "absent" };
-    raw = JSON.parse(readFileSync7(CONNECTOR_CACHE_PATH, "utf-8"));
+    if (!existsSync9(CONNECTOR_CACHE_PATH)) return { state: "absent" };
+    raw = JSON.parse(readFileSync8(CONNECTOR_CACHE_PATH, "utf-8"));
   } catch (e) {
     return { state: "unreadable", reason: e instanceof Error ? e.message : String(e) };
   }
@@ -112496,8 +112735,8 @@ function readMirrorRowsFromDisk() {
 }
 function readMirrorContainer() {
   try {
-    if (!existsSync8(CONNECTOR_CACHE_PATH)) return { state: "absent" };
-    const raw = JSON.parse(readFileSync7(CONNECTOR_CACHE_PATH, "utf-8"));
+    if (!existsSync9(CONNECTOR_CACHE_PATH)) return { state: "absent" };
+    const raw = JSON.parse(readFileSync8(CONNECTOR_CACHE_PATH, "utf-8"));
     if (!isRecord(raw)) {
       return { state: "unreadable", reason: "the mirror's top level is not an object" };
     }
@@ -112511,8 +112750,8 @@ function readMirrorContainer() {
 }
 function readMirrorFetchedAt() {
   try {
-    if (!existsSync8(CONNECTOR_CACHE_PATH)) return "";
-    const raw = JSON.parse(readFileSync7(CONNECTOR_CACHE_PATH, "utf-8"));
+    if (!existsSync9(CONNECTOR_CACHE_PATH)) return "";
+    const raw = JSON.parse(readFileSync8(CONNECTOR_CACHE_PATH, "utf-8"));
     if (!isRecord(raw)) return "";
     return typeof raw.fetchedAt === "string" ? raw.fetchedAt : "";
   } catch {
@@ -112763,7 +113002,7 @@ var init_catalog = __esm({
     SOURCE_OPERATORS = ["provider", "third_party", "ametyst"];
     SOURCE_PREFERENCE_RULES = ["official-mcp"];
     CONNECTOR_FEED_PATH = "/api/v1/virtual-wallets/capabilities/connectors";
-    CONNECTOR_CACHE_PATH = join6(AMETYST_DIR, "connectors.json");
+    CONNECTOR_CACHE_PATH = join7(AMETYST_DIR, "connectors.json");
     CatalogUnavailableError = class extends Error {
       constructor(reason, message) {
         super(message);
@@ -113501,15 +113740,15 @@ var init_call2 = __esm({
 });
 
 // src/connections/engine-store.ts
-import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync11, mkdirSync as mkdirSync7, openSync as openSync2 } from "fs";
-import { dirname as dirname7, join as join16 } from "path";
+import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync12, mkdirSync as mkdirSync8, openSync as openSync2 } from "fs";
+import { dirname as dirname7, join as join17 } from "path";
 function connectionsDbPath() {
-  return join16(AMETYST_DIR, CONNECTIONS_DB_FILENAME);
+  return join17(AMETYST_DIR, CONNECTIONS_DB_FILENAME);
 }
 function ensureOwnerOnlyFile(path2) {
   if (path2 === IN_MEMORY_DB) return;
-  mkdirSync7(dirname7(path2), { recursive: true, mode: DIR_MODE });
-  if (!existsSync11(path2)) closeSync2(openSync2(path2, "a", CONNECTIONS_DB_FILE_MODE));
+  mkdirSync8(dirname7(path2), { recursive: true, mode: DIR_MODE });
+  if (!existsSync12(path2)) closeSync2(openSync2(path2, "a", CONNECTIONS_DB_FILE_MODE));
   chmodSync4(path2, CONNECTIONS_DB_FILE_MODE);
 }
 function sqliteWasmDriver(db, raw) {
@@ -114718,6 +114957,44 @@ function hostNudges(rows) {
 
 // src/commands/login.ts
 init_resolve();
+
+// src/config/workspace-binding.ts
+init_esm_shims();
+init_config();
+function workspaceKeyFrom(profile) {
+  const name = profile?.companyName;
+  if (typeof name !== "string") return null;
+  const trimmed = name.trim().toLowerCase();
+  return trimmed === "" ? null : trimmed;
+}
+function isWorkspaceSwitch(previous, next) {
+  if (previous === null || next === null) return false;
+  return previous !== next;
+}
+function readBoundWorkspace() {
+  const config = loadConfig();
+  const key = config?.workspaceId;
+  return typeof key === "string" && key.trim() !== "" ? key : null;
+}
+function recordBoundWorkspace(key, observedAt) {
+  const config = loadConfig();
+  if (!config) return false;
+  const { apiKey: _injected, apiKeySource: _src, ...persisted } = config;
+  saveConfig({ ...persisted, workspaceId: key, workspaceIdObservedAt: observedAt });
+  return true;
+}
+function workspaceSwitchNotice(previous, next) {
+  return `Workspace changed: "${previous}" -> "${next}". Dropping the cached session and wallet binding from the previous workspace \u2014 its session keys are kept on disk (they stay signable if you switch back) but are no longer selected here.`;
+}
+function applyObservedWorkspace(profile, observedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const key = workspaceKeyFrom(profile);
+  const previous = readBoundWorkspace();
+  const switched = isWorkspaceSwitch(previous, key);
+  if (key !== null && key !== previous) recordBoundWorkspace(key, observedAt);
+  return { key, previous, switched };
+}
+
+// src/commands/login.ts
 function lastObservedStanceLine(config) {
   const observed = config?.requireWalletPassphrase;
   if (typeof observed !== "boolean") {
@@ -114779,6 +115056,10 @@ async function loginCommand(options) {
   if (observedStance !== void 0) {
     setRequireWalletPassphrase(observedStance, (/* @__PURE__ */ new Date()).toISOString());
   }
+  const workspace = applyObservedWorkspace(profile);
+  if (workspace.switched && workspace.previous && workspace.key) {
+    console.log(workspaceSwitchNotice(workspace.previous, workspace.key));
+  }
   const stance = resolveWalletPassphraseStance(observedStance, config.requireWalletPassphrase);
   const who = profile ? `Logged in as ${profile.employeeName} @ ${profile.companyName ?? "(no company)"}.` : "Logged in.";
   console.log(who);
@@ -114926,8 +115207,9 @@ async function fetchAvailablePolicies(client, apiKey) {
   const response = await client.getPoliciesFromVirtualWalletsManager(apiKey);
   return normalizePoliciesResponse(response);
 }
-async function submitAccessRequest(client, apiKey, eoaAddress, policyId) {
-  return client.createVirtualWallet(
+async function submitRotatedAccessRequest(client, apiKey, policyId, issuer) {
+  const eoaAddress = await issuer.issue({ policyId });
+  const result = await client.createVirtualWallet(
     apiKey,
     CLI_WALLET_NAME,
     CLI_WALLET_URL,
@@ -114935,6 +115217,11 @@ async function submitAccessRequest(client, apiKey, eoaAddress, policyId) {
     policyId,
     eoaAddress
   );
+  try {
+    issuer.recordRow?.(eoaAddress, result?.id ? String(result.id) : void 0);
+  } catch {
+  }
+  return { ...result, eoaAddress };
 }
 function pickDefaultPolicyIndex(policies) {
   const i = policies.findIndex(
@@ -115133,6 +115420,7 @@ async function freshWalletRecovery(apiKey, options) {
     }
   }
   let address;
+  let vaultPassphrase;
   if (options.noPassphrase) {
     const wallet = createPlaintextWallet();
     persistPlaintextVault(wallet.address, wallet.privateKey);
@@ -115153,6 +115441,7 @@ New wallet created. Address: ${address}`);
       process.exit(1);
       return false;
     }
+    vaultPassphrase = passphrase;
     const keystoreJson = createWallet(passphrase);
     persistVault(keystoreJson);
     address = getWalletAddress(keystoreJson);
@@ -115201,8 +115490,15 @@ Create one in the Ametyst web app (admin panel \u2192 policies), then re-run 'am
     process.exit(1);
     return false;
   }
+  let grantAddress;
   try {
-    await submitAccessRequest(client, apiKey, address, policyId);
+    const { createGrantKeyIssuer: createGrantKeyIssuer2 } = await Promise.resolve().then(() => (init_grant_keystore(), grant_keystore_exports));
+    const submitted = await submitRotatedAccessRequest(client, apiKey, policyId, createGrantKeyIssuer2({
+      encrypted: !options.noPassphrase,
+      passphrase: vaultPassphrase,
+      workspaceId: readBoundWorkspace()
+    }));
+    grantAddress = submitted.eoaAddress;
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.error(`
@@ -115214,8 +115510,9 @@ Could not submit the authorization request (${msg}).`);
   const policyName = typeof chosen.name === "string" && chosen.name ? chosen.name : `policy ${policyId}`;
   console.log(`
 Authorization request sent \u2014 PENDING approval.
-  Wallet:  ${address}
-  Policy:  ${policyName} (id ${policyId})
+  Wallet:       ${address}
+  Session key:  ${grantAddress}
+  Policy:       ${policyName} (id ${policyId})
 
 Next step: approve the request in the Ametyst web app admin panel (check your
 notifications there). Once it's approved, you're done \u2014 run 'ametyst status' to
@@ -115437,14 +115734,19 @@ function isNewerGrant(candidate, incumbent) {
   }
   return candidateIdUsable && !incumbentIdUsable;
 }
-function selectNewestApprovedWallet(wallets, eoaAddress) {
+function selectNewestApprovedWalletAmong(wallets, addresses) {
   if (!Array.isArray(wallets)) return void 0;
-  const eoa = nonEmptyLowerCase(eoaAddress);
-  if (!eoa) return void 0;
+  const candidates = /* @__PURE__ */ new Set();
+  for (const address of addresses ?? []) {
+    const normalized = nonEmptyLowerCase(address);
+    if (normalized) candidates.add(normalized);
+  }
+  if (candidates.size === 0) return void 0;
   let newest;
   for (const wallet of wallets) {
     if (wallet?.status !== "approved") continue;
-    if (nonEmptyLowerCase(wallet?.address) !== eoa) continue;
+    const rowAddress = nonEmptyLowerCase(wallet?.address);
+    if (!rowAddress || !candidates.has(rowAddress)) continue;
     if (newest === void 0 || isNewerGrant(wallet, newest)) newest = wallet;
   }
   return newest;
@@ -115454,7 +115756,60 @@ function findCurrentApprovedWallet(wallets, eoaAddress, pendingWalletId) {
   if (pendingWalletId) {
     return wallets.find((w) => String(w?.id) === String(pendingWalletId) && w?.status === "approved");
   }
-  return selectNewestApprovedWallet(wallets, eoaAddress);
+  return selectNewestApprovedWalletAmong(
+    wallets,
+    Array.isArray(eoaAddress) ? eoaAddress : eoaAddress === void 0 ? [] : [eoaAddress]
+  );
+}
+
+// src/mcp-server/signer-binding.ts
+init_esm_shims();
+var BINDING_DERIVED_KEYS = [
+  "virtualWalletKernelAccountClient",
+  "permissionPlugin",
+  "kernelDomain",
+  "policyPrecheckPassed"
+];
+function nonEmpty(value2) {
+  return typeof value2 === "string" && value2.trim() !== "" ? value2 : void 0;
+}
+function sameAddress(a, b) {
+  return String(a ?? "").toLowerCase() === String(b ?? "").toLowerCase();
+}
+function signerBindingMoved(state, row) {
+  const rowId = row?.id != null ? String(row.id) : void 0;
+  const rowAddress = nonEmpty(row?.address);
+  if (state.virtualWalletId && rowId && state.virtualWalletId !== rowId) return true;
+  if (state.signerAddress && rowAddress && !sameAddress(state.signerAddress, rowAddress)) return true;
+  return false;
+}
+function bindSignerToGrantRow(state, row) {
+  const changed = signerBindingMoved(state, row);
+  if (changed) {
+    for (const key of BINDING_DERIVED_KEYS) delete state[key];
+  }
+  const rowAddress = nonEmpty(row?.address);
+  if (rowAddress) state.signerAddress = rowAddress;
+  const rowWalletAddress = nonEmpty(row?.walletAddress) ?? nonEmpty(row?.kernelAccountAddress);
+  const rowPaymentManagerAddress = nonEmpty(row?.paymentManagerAddress);
+  const rowPolicyId = row?.policyAssociated != null ? String(row.policyAssociated) : void 0;
+  const rowId = row?.id != null ? String(row.id) : void 0;
+  if (changed) {
+    state.walletAddress = rowWalletAddress;
+    state.paymentManagerAddress = rowPaymentManagerAddress;
+    state.policyId = rowPolicyId;
+    state.policyOnchainPermissions = nonEmpty(row?.policyOnchainPermissions);
+  } else {
+    state.walletAddress = rowWalletAddress ?? state.walletAddress;
+    state.paymentManagerAddress = rowPaymentManagerAddress ?? state.paymentManagerAddress;
+    state.policyId = rowPolicyId ?? state.policyId;
+    state.policyOnchainPermissions = nonEmpty(row?.policyOnchainPermissions) ?? state.policyOnchainPermissions;
+  }
+  if (rowId) state.virtualWalletId = rowId;
+  if (row?.policyName != null) state.policyName = String(row.policyName);
+  if (row?.policyValidUntil != null) state.policyValidUntil = BigInt(row.policyValidUntil);
+  state.authorizationStatus = "approved";
+  return { changed, signerAddress: state.signerAddress };
 }
 
 // src/mcp-server/start-session.ts
@@ -115594,7 +115949,10 @@ async function runStartSession(ctx, timing = new TimingCollector("start_session"
   let activeWallet;
   let grantChanged = false;
   try {
-    activeWallet = selectNewestApprovedWallet(wallets, ctx.eoaAddress);
+    activeWallet = selectNewestApprovedWalletAmong(wallets, [
+      ctx.eoaAddress,
+      ...ctx.candidateAddresses ?? []
+    ]);
     if (activeWallet) {
       const newestId = String(activeWallet.id);
       const rowWalletAddress = activeWallet.walletAddress || activeWallet.kernelAccountAddress;
@@ -115614,6 +115972,9 @@ async function runStartSession(ctx, timing = new TimingCollector("start_session"
         policyId = rowPolicyId ?? policyId;
       }
       virtualWalletId = newestId;
+      if (typeof activeWallet.address === "string" && activeWallet.address.trim() !== "") {
+        credentials.signerAddress = activeWallet.address;
+      }
       credentials.walletAddress = walletAddress;
       credentials.virtualWalletId = virtualWalletId;
       credentials.paymentManagerAddress = paymentManagerAddress;
@@ -115646,7 +116007,8 @@ async function runStartSession(ctx, timing = new TimingCollector("start_session"
   if (walletAddress && virtualWalletId && paymentManagerAddress && policyId) {
     let privateKey = null;
     try {
-      privateKey = readVaultPrivateKey(ctx.walletKeystoreJson, ctx.passphrase);
+      const signerAddress = credentials.signerAddress ?? ctx.eoaAddress;
+      privateKey = ctx.resolveSigningKey && signerAddress ? ctx.resolveSigningKey(signerAddress) : readVaultPrivateKey(ctx.walletKeystoreJson, ctx.passphrase);
       const { virtualWalletsManagers: virtualWalletsManagers2, financialAccounts: financialAccounts2 } = ctx.sdk;
       const walletData = await virtualWalletsManagers2.getVirtualWalletDataByApiKey(
         ctx.apiKey,
@@ -115761,11 +116123,11 @@ function clearWalletScopedCredentials(target) {
     delete target[key];
   }
 }
-function sameAddress(a, b) {
+function sameAddress2(a, b) {
   return String(a ?? "").toLowerCase() === String(b ?? "").toLowerCase();
 }
 function mergeStartSessionCredentials(target, patch, responseKey, options = {}) {
-  const walletChanged = patch.eoaAddress !== void 0 && !sameAddress(patch.eoaAddress, target.eoaAddress);
+  const walletChanged = patch.eoaAddress !== void 0 && !sameAddress2(patch.eoaAddress, target.eoaAddress);
   if (walletChanged || options.grantChanged) {
     clearWalletScopedCredentials(target);
   }
@@ -116946,13 +117308,13 @@ init_local_state();
 // src/mcp-server/materialize-task.ts
 init_esm_shims();
 init_paths();
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join9 } from "path";
 
 // src/loops/state-docs.ts
 init_esm_shims();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 
 // src/loops/shipback.ts
 init_esm_shims();
@@ -117385,12 +117747,12 @@ function docMergeRefusal(boot, fresh, next, cleanAppend) {
 async function shipBackStateDocs(sdk, apiKey, slug, dir, boot) {
   const outcomes = [];
   for (const doc of boot) {
-    const path2 = join7(dir, doc.filename);
-    if (!existsSync9(path2)) {
+    const path2 = join8(dir, doc.filename);
+    if (!existsSync10(path2)) {
       outcomes.push({ key: doc.key, outcome: "unchanged" });
       continue;
     }
-    const materialized = readFileSync8(path2, "utf-8");
+    const materialized = readFileSync9(path2, "utf-8");
     const reread = await readScoped(sdk, apiKey, slug, doc.key, doc.scope);
     const fresh = reread.status === "ok" ? reread.body : reread.status === "absent" && doc.body === "" ? "" : void 0;
     if (fresh === void 0) {
@@ -117460,20 +117822,20 @@ var TASK_DEFINITION_FILES = [
 ];
 function materializeTask(task, runId) {
   const dir = loopFireDir(task.slug, runId);
-  mkdirSync6(dir, { recursive: true, mode: 448 });
+  mkdirSync7(dir, { recursive: true, mode: 448 });
   const files = {};
   const skipped = [];
   for (const [label2, filename, field] of TASK_DEFINITION_FILES) {
     const body = task[field];
     if (typeof body === "string" && body.length > 0) {
-      writeFileSync8(join8(dir, filename), body, { mode: 384 });
+      writeFileSync8(join9(dir, filename), body, { mode: 384 });
       files[label2] = filename;
     } else {
       skipped.push(label2);
     }
   }
   writeFileSync8(
-    join8(dir, "STATUS.md"),
+    join9(dir, "STATUS.md"),
     `# STATUS \u2014 ${task.slug}
 
 task_id: ${task.id}
@@ -117504,7 +117866,7 @@ async function materializeMemoryDocs(sdk, apiKey, task, dir) {
       notes.push(`memory doc '${f.key}' not materialized: ${f.reason}`);
     }
     for (const doc of fetched) {
-      writeFileSync8(join8(dir, doc.filename), doc.body, { mode: 384 });
+      writeFileSync8(join9(dir, doc.filename), doc.body, { mode: 384 });
       files[`doc:${doc.key}`] = doc.filename;
       notes.push(describeSource(doc));
     }
@@ -117518,14 +117880,14 @@ async function materializeMemoryDocs(sdk, apiKey, task, dir) {
 }
 
 // src/mcp-server/index.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 
 // src/loops/dashboard.ts
 init_esm_shims();
 import { createServer as createServer2 } from "http";
 import * as realFs from "fs";
 import { spawn as realSpawn } from "child_process";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var DEFAULT_PORT = 4477;
 var DASHBOARD_PORT_ENV = "AMETYST_LOOP_DASHBOARD_PORT";
 var DASHBOARD_NO_OPEN_ENV = "AMETYST_DASHBOARD_NO_OPEN";
@@ -117586,14 +117948,14 @@ function startDashboardServer(args) {
         const data = {};
         for (const name of files) {
           try {
-            const p = join9(args.loopDir, name);
+            const p = join10(args.loopDir, name);
             if (fs.existsSync(p)) data[name] = fs.readFileSync(p, "utf-8");
           } catch {
           }
         }
         const state = {};
         try {
-          const p = join9(args.loopDir, ".state", "fires.jsonl");
+          const p = join10(args.loopDir, ".state", "fires.jsonl");
           if (fs.existsSync(p)) state["fires.jsonl"] = fs.readFileSync(p, "utf-8");
         } catch {
         }
@@ -117992,7 +118354,7 @@ function injectDefaultDashboard(loop2) {
 
 // src/loops/memory-verbs.ts
 init_esm_shims();
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 
 // src/loops/sdk.ts
 init_esm_shims();
@@ -118252,7 +118614,7 @@ async function taskMemoryAppendVerb(rawSlug, opts) {
   const archived = opts.archived === true;
   const note = opts.note?.trim() || void 0;
   const scope = parseScopeFlag(opts.scope, false);
-  const content = opts.file !== void 0 ? readFileSync9(opts.file, "utf-8") : opts.content ?? "";
+  const content = opts.file !== void 0 ? readFileSync10(opts.file, "utf-8") : opts.content ?? "";
   if (!content) {
     throw new Error("nothing to store: pass --content <text> or --file <path>");
   }
@@ -118389,14 +118751,14 @@ ${full.markdownBody ?? ""}`;
 
 // src/mcp-server/read-file-body.ts
 init_esm_shims();
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { resolve as resolvePath } from "path";
 function readMarkdownFile(filePath) {
   const raw = typeof filePath === "string" ? filePath.trim() : "";
   if (!raw) throw new Error("filePath is empty.");
   const abs = resolvePath(raw);
   try {
-    return readFileSync10(abs, "utf8");
+    return readFileSync11(abs, "utf8");
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(`Could not read file at "${abs}": ${reason}`);
@@ -118725,7 +119087,7 @@ function enforceResponseCap(payload) {
 
 // src/mcp-server/delegate-tools.ts
 init_esm_shims();
-import { existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { existsSync as existsSync11, statSync as statSync2 } from "fs";
 import { z as z3 } from "zod";
 
 // src/delegate/jobs.ts
@@ -118827,7 +119189,7 @@ import * as nodeFs from "fs";
 import { execFileSync } from "child_process";
 import { createHash } from "crypto";
 import { homedir as homedir5 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var OPENCODE_VERSION = "1.18.13";
 var OPENCODE_CHECKSUMS = {
   "darwin-arm64": "6a85ae6de1aeb8e39ae4d977337b03f49168c2a827ee37b6f82c39471d711c63",
@@ -118849,10 +119211,10 @@ function resolveOpencodePlatform(platform, arch) {
   return void 0;
 }
 function opencodeBinDir(home = homedir5()) {
-  return join10(home, `.ametyst${ENV_SUFFIX}`, "bin");
+  return join11(home, `.ametyst${ENV_SUFFIX}`, "bin");
 }
 function opencodeBinaryPath(home = homedir5()) {
-  return join10(opencodeBinDir(home), `opencode-${OPENCODE_VERSION}`);
+  return join11(opencodeBinDir(home), `opencode-${OPENCODE_VERSION}`);
 }
 function opencodeSidecarPath(home = homedir5()) {
   return `${opencodeBinaryPath(home)}.sha256`;
@@ -118907,7 +119269,7 @@ async function ensureOpencodeBinary(deps = {}) {
   const bytes = new Uint8Array(await res.arrayBuffer());
   const expected = (deps.checksums ?? OPENCODE_CHECKSUMS)[key];
   const actual = sha256Hex(bytes);
-  const tmpArchive = join10(binDir, `.${artifact}.download-${process.pid}`);
+  const tmpArchive = join11(binDir, `.${artifact}.download-${process.pid}`);
   fs.writeFileSync(tmpArchive, bytes);
   if (actual !== expected) {
     fs.rmSync(tmpArchive, { force: true });
@@ -118915,7 +119277,7 @@ async function ensureOpencodeBinary(deps = {}) {
       `opencode bootstrap: checksum mismatch for ${artifact} (expected ${expected}, got ${actual}). The download was deleted; refusing to install an unverified binary.`
     );
   }
-  const tmpExtractDir = join10(binDir, `.extract-${OPENCODE_VERSION}-${process.pid}`);
+  const tmpExtractDir = join11(binDir, `.extract-${OPENCODE_VERSION}-${process.pid}`);
   fs.rmSync(tmpExtractDir, { recursive: true, force: true });
   fs.mkdirSync(tmpExtractDir, { recursive: true, mode: 448 });
   try {
@@ -118924,7 +119286,7 @@ async function ensureOpencodeBinary(deps = {}) {
     } else {
       exec("tar", ["-xzf", tmpArchive, "-C", tmpExtractDir]);
     }
-    const extracted = join10(tmpExtractDir, "opencode");
+    const extracted = join11(tmpExtractDir, "opencode");
     if (!fs.existsSync(extracted)) {
       const entries = fs.readdirSync(tmpExtractDir).join(", ") || "<empty>";
       throw new Error(
@@ -118995,15 +119357,15 @@ import { randomUUID } from "crypto";
 init_esm_shims();
 init_paths();
 import { homedir as homedir6 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function bridgeRunDir(home = homedir6()) {
-  return join11(home, `.ametyst${ENV_SUFFIX}`, "run");
+  return join12(home, `.ametyst${ENV_SUFFIX}`, "run");
 }
 function bridgeSocketPath(pid, home = homedir6()) {
-  return join11(bridgeRunDir(home), `delegate-${pid}.sock`);
+  return join12(bridgeRunDir(home), `delegate-${pid}.sock`);
 }
 function bridgeNoncePath(pid, home = homedir6()) {
-  return join11(bridgeRunDir(home), `delegate-${pid}.nonce`);
+  return join12(bridgeRunDir(home), `delegate-${pid}.nonce`);
 }
 function bridgeNoncePathForSocket(socketPath) {
   return socketPath.replace(/\.sock$/, ".nonce");
@@ -119025,7 +119387,7 @@ function listBridgeSockets(fs, home = homedir6()) {
   const entries = [];
   for (const name of names) {
     if (pidFromSocketName(name) === void 0) continue;
-    const path2 = join11(dir, name);
+    const path2 = join12(dir, name);
     try {
       entries.push({ path: path2, mtimeMs: fs.statSync(path2).mtimeMs });
     } catch {
@@ -119374,7 +119736,7 @@ async function startShim(deps) {
 init_esm_shims();
 import * as nodeFs3 from "fs";
 import { tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var DELEGATE_PROVIDER_ID = "ametyst";
 var DELEGATE_SHIM_API_KEY = "ametyst-local-shim";
 function buildDelegateConfig(opts) {
@@ -119398,8 +119760,8 @@ function delegateModelRef(model) {
 }
 function writeTempDelegateConfig(config, deps = {}) {
   const fs = deps.fs ?? nodeFs3;
-  const dir = fs.mkdtempSync(join12(deps.tmp ?? tmpdir(), "ametyst-delegate-"));
-  const path2 = join12(dir, "opencode.json");
+  const dir = fs.mkdtempSync(join13(deps.tmp ?? tmpdir(), "ametyst-delegate-"));
+  const path2 = join13(dir, "opencode.json");
   fs.writeFileSync(path2, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
   let done = false;
@@ -119468,7 +119830,7 @@ init_paths();
 import * as nodeFs4 from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import { homedir as homedir8 } from "os";
-import { basename as basename4, join as join13 } from "path";
+import { basename as basename4, join as join14 } from "path";
 var DELEGATED_CHILD_ENV_VAR = "AMETYST_DELEGATED";
 var SPEND_GRANT_TOKEN_ENV_VAR = "AMETYST_DELEGATE_SPEND_TOKEN";
 var SPEND_KILL_SWITCH_ENV_VAR = "AMETYST_DELEGATE_NO_SPEND";
@@ -119550,11 +119912,11 @@ function isDelegatedByAncestry(deps = {}) {
   return classifyAncestry(deps) === "delegated";
 }
 function delegateChildConfigHome(home = homedir8()) {
-  return join13(home, `.ametyst${ENV_SUFFIX}`, "delegate-xdg");
+  return join14(home, `.ametyst${ENV_SUFFIX}`, "delegate-xdg");
 }
 function ensureChildConfigHome(fs = nodeFs4, home = homedir8()) {
   const root2 = delegateChildConfigHome(home);
-  const inner = join13(root2, "opencode");
+  const inner = join14(root2, "opencode");
   if (!fs.existsSync(inner)) fs.mkdirSync(inner, { recursive: true, mode: 448 });
   return root2;
 }
@@ -119564,7 +119926,7 @@ function userOpencodeConfigDir(deps = {}) {
   const env = deps.env ?? process.env;
   const home = deps.home ?? homedir8();
   const xdg = env.XDG_CONFIG_HOME?.trim();
-  return join13(xdg ? xdg : join13(home, ".config"), "opencode");
+  return join14(xdg ? xdg : join14(home, ".config"), "opencode");
 }
 function stripJsonComments(text) {
   let out = "";
@@ -119608,9 +119970,9 @@ function readUserMcpServers(deps = {}) {
   const warn = deps.warn ?? ((line) => console.error(line));
   const home = deps.home ?? homedir8();
   const dir = userOpencodeConfigDir(deps);
-  if (dir === join13(delegateChildConfigHome(home), "opencode")) return {};
+  if (dir === join14(delegateChildConfigHome(home), "opencode")) return {};
   for (const filename of USER_OPENCODE_CONFIG_FILENAMES) {
-    const path2 = join13(dir, filename);
+    const path2 = join14(dir, filename);
     let raw;
     try {
       if (!fs.existsSync(path2)) continue;
@@ -120708,7 +121070,7 @@ init_esm_shims();
 import * as nodeFs6 from "fs";
 import { createHash as createHash2, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual3 } from "crypto";
 import { homedir as homedir10 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var SPEND_GRANT_RECORD_VERSION = 1;
 var TOKEN_BYTES = 32;
 var SPEND_GRANT_GRACE_MS = 5 * 6e4;
@@ -120716,7 +121078,7 @@ function spendGrantPath(jobId, home = homedir10()) {
   if (!/^[A-Za-z0-9_-]{1,64}$/.test(jobId)) {
     throw new Error(`refusing to build a grant path for job id ${JSON.stringify(jobId)}`);
   }
-  return join14(bridgeRunDir(home), `spend-grant-${jobId}.json`);
+  return join15(bridgeRunDir(home), `spend-grant-${jobId}.json`);
 }
 function hashSpendGrantToken(token) {
   return createHash2("sha256").update(token, "utf-8").digest("hex");
@@ -120822,13 +121184,13 @@ init_esm_shims();
 init_paths();
 import * as nodeFs7 from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname6, join as join15 } from "path";
+import { dirname as dirname6, join as join16 } from "path";
 var DELEGATE_CREDIT_CAPABILITY = "credit";
 var DELEGATE_CREDIT_PRICE_USD = 1;
 var DELEGATE_CREDIT_REQUEST_BODY = "{}";
 var DELEGATE_CREDIT_SPEND_SNIPPET = `spend({ merchant_slug: "${DELEGATE_MERCHANT_SLUG}", capability: "${DELEGATE_CREDIT_CAPABILITY}", inputs: "${DELEGATE_CREDIT_REQUEST_BODY}" })`;
 function creditLedgerPath(home = homedir11()) {
-  return join15(home, `.ametyst${ENV_SUFFIX}`, "run", "delegate-credit.json");
+  return join16(home, `.ametyst${ENV_SUFFIX}`, "run", "delegate-credit.json");
 }
 function readCreditLedger(fs = nodeFs7, path2 = creditLedgerPath()) {
   try {
@@ -121219,7 +121581,7 @@ function registerDelegateTools(deps) {
     const validated = validateStartInput(params, {
       isDirectory: (path2) => {
         try {
-          return existsSync10(path2) && statSync2(path2).isDirectory();
+          return existsSync11(path2) && statSync2(path2).isDirectory();
         } catch {
           return false;
         }
@@ -121474,7 +121836,7 @@ init_resolve();
 
 // src/mcp-server/identity-reload.ts
 init_esm_shims();
-import { readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync13, statSync as statSync3 } from "fs";
 var NO_VAULT = "absent";
 var IDENTITY_CHECK_THROTTLE_MS = 1e3;
 function fingerprintVault(stat) {
@@ -121495,7 +121857,11 @@ var IdentityWatch = class {
   stat;
   /** False for an env-supplied key: `poll` is then a guaranteed no-op. */
   armed;
+  configPath;
+  readWorkspaceKey;
   fingerprint;
+  configStamp;
+  workspaceKey;
   lastCheckedAt = null;
   constructor(options) {
     this.vaultPath = options.vaultPath;
@@ -121503,12 +121869,43 @@ var IdentityWatch = class {
     this.throttleMs = options.throttleMs ?? IDENTITY_CHECK_THROTTLE_MS;
     this.stat = options.stat ?? statVaultFile;
     this.armed = options.source !== "env";
-    this.fingerprint = fingerprintVault(this.stat(this.vaultPath));
+    this.configPath = options.configPath ?? null;
+    this.readWorkspaceKey = options.readWorkspaceKey ?? null;
+    this.configStamp = this.configPath ? fingerprintVault(this.stat(this.configPath)) : NO_VAULT;
+    this.workspaceKey = this.readWorkspaceKeySafely();
+    this.fingerprint = this.composeFingerprint();
+  }
+  /** Never let a config read take the watch — or the tool call behind it — down. */
+  readWorkspaceKeySafely() {
+    if (!this.readWorkspaceKey) return null;
+    try {
+      return this.readWorkspaceKey();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Vault fingerprint AND workspace key in one string, so `poll` stays a single
+   * comparison and neither half can change without being noticed.
+   *
+   * A watch with NO workspace reader appends nothing, so its fingerprint stays
+   * exactly the string it was before 0.3.6 (`"<mtime>:<size>"` / `"absent"`).
+   * That is not cosmetic: the fingerprint is an observable of this class, and a
+   * vault-only watch must be indistinguishable from the one that shipped.
+   */
+  composeFingerprint() {
+    const vault = fingerprintVault(this.stat(this.vaultPath));
+    if (!this.readWorkspaceKey) return vault;
+    return `${vault}|ws:${this.workspaceKey ?? "unbound"}`;
   }
   /** The fingerprint this watch currently considers current. */
   currentFingerprint() {
     return this.fingerprint;
   }
+  /** The workspace key this watch last read from the config. */
+  currentWorkspaceKey() {
+    return this.workspaceKey;
+  }
   /**
    * One throttled `stat`. Returns the change when the vault file differs from
    * the fingerprint on record — and ADOPTS it in the same step, so a reload the
@@ -121521,7 +121918,14 @@ var IdentityWatch = class {
     const at = this.now();
     if (this.lastCheckedAt !== null && at - this.lastCheckedAt < this.throttleMs) return null;
     this.lastCheckedAt = at;
-    const next = fingerprintVault(this.stat(this.vaultPath));
+    if (this.configPath) {
+      const stamp = fingerprintVault(this.stat(this.configPath));
+      if (stamp !== this.configStamp) {
+        this.configStamp = stamp;
+        this.workspaceKey = this.readWorkspaceKeySafely();
+      }
+    }
+    const next = this.composeFingerprint();
     if (next === this.fingerprint) return null;
     const from14 = this.fingerprint;
     this.fingerprint = next;
@@ -121537,7 +121941,7 @@ var IdentityWatch = class {
    */
   readVault() {
     try {
-      return readFileSync12(this.vaultPath, "utf-8");
+      return readFileSync13(this.vaultPath, "utf-8");
     } catch {
       return null;
     }
@@ -121545,6 +121949,7 @@ var IdentityWatch = class {
 };
 
 // src/mcp-server/index.ts
+init_grant_keystore();
 function buildDeclaredConnectorsSentence(catalog, unreadable) {
   const read = catalog === void 0 ? { connectors: cachedCatalogOrEmpty(), unreadable: mirrorGap() } : { connectors: catalog, unreadable: unreadable ?? [] };
   const gap = describeCatalogGap(read.unreadable);
@@ -121555,6 +121960,82 @@ function buildDeclaredConnectorsSentence(catalog, unreadable) {
   return `Currently declared: ${declared}. Those are the operations picked out as most useful, NOT the limit: each provider's own surface is larger, and any operation it advertises is callable by its exact name. If the one you want is not listed, try it anyway \u2014 an operation that really does not exist comes back as a typed \`unknown_operation\` with the alternatives.` + (gap === "" ? "" : ` ${gap}`);
 }
 var currentCredentials = {};
+function vaultIsEncrypted() {
+  return !plaintextVaultMode;
+}
+function ownedSigningAddresses() {
+  const addresses = [];
+  if (currentCredentials.eoaAddress) addresses.push(currentCredentials.eoaAddress);
+  try {
+    addresses.push(...listGrantAddresses({ workspaceId: readBoundWorkspace() }));
+  } catch (err) {
+    console.error(
+      `\u26A0\uFE0F  could not read the per-grant keystore \u2014 only the install EOA is selectable: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return addresses;
+}
+function isOwnedSigningAddress(address) {
+  if (typeof address !== "string" || address.trim() === "") return false;
+  const needle = address.toLowerCase();
+  return ownedSigningAddresses().some((a) => a.toLowerCase() === needle);
+}
+function signingKeyForAddress(address, passphrase) {
+  return resolveGrantSigningKey({
+    address,
+    vaultJson: currentCredentials.walletKeystoreJson,
+    vaultAddress: currentCredentials.eoaAddress,
+    // ⛔ THE CALLER'S PASSPHRASE WINS. `start_session` resolves the key DURING
+    // `runStartSession`, before `mergeStartSessionCredentials` has put the
+    // passphrase into `currentCredentials` — so reading only the field would
+    // make every encrypted-vault unlock fail with "a passphrase is required"
+    // on the very call that was handed one.
+    passphrase: passphrase ?? currentCredentials.passphrase
+  });
+}
+async function refreshSignerBinding() {
+  if (!currentCredentials.apiKey) return { changed: false, address: currentCredentials.signerAddress };
+  let wallets;
+  try {
+    wallets = await fetchVirtualWalletsFromBackend(currentCredentials.apiKey, true);
+  } catch (err) {
+    console.error(
+      `\u26A0\uFE0F  [signer-binding] could not re-read the grants \u2014 signing with the cached binding (${currentCredentials.signerAddress ?? "none"}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    wallets = walletsCache || [];
+  }
+  const row = currentCredentials.pendingWalletId ? findCurrentApprovedWallet(wallets, ownedSigningAddresses(), currentCredentials.pendingWalletId) : selectNewestApprovedWalletAmong(
+    wallets,
+    (Array.isArray(wallets) ? wallets : []).map((w) => w?.address)
+  );
+  if (!row) return { changed: false, address: currentCredentials.signerAddress };
+  const previousSigner = currentCredentials.signerAddress;
+  const { changed, signerAddress } = bindSignerToGrantRow(currentCredentials, row);
+  if (changed) {
+    console.error(
+      `\u{1F501} [signer-binding] the active grant moved \u2014 signer ${previousSigner ?? "none"} -> ${signerAddress ?? "none"} (virtual wallet ${currentCredentials.virtualWalletId}, policy ${currentCredentials.policyId ?? "unknown"}). Dropping the signer state derived from the old grant.`
+    );
+  }
+  return { changed, address: signerAddress };
+}
+async function resolveSignerForMaterialization(passphrase) {
+  await refreshSignerBinding();
+  const address = currentCredentials.signerAddress || currentCredentials.eoaAddress || "";
+  if (!address) {
+    throw new Error(
+      "no signer address for this session \u2014 no approved grant and no install wallet. Run requestAccess first."
+    );
+  }
+  return { address, privateKey: signingKeyForAddress(address, passphrase) };
+}
+function hasSigningKeyForAddress(address) {
+  if (!address) return false;
+  try {
+    return hasGrantSigningKey({ address, vaultAddress: currentCredentials.eoaAddress });
+  } catch {
+    return false;
+  }
+}
 var plaintextVaultMode = false;
 function refreshPlaintextVaultMode() {
   const vault = currentCredentials.walletKeystoreJson;
@@ -122576,7 +123057,16 @@ async function initializeCredentials(walletKeystoreJson, eoaAddress, config) {
     currentCredentials.signerAddress = eoaAddress;
     currentCredentials.eoaAddress = eoaAddress;
     currentCredentials.apiKey = config.apiKey;
-    identityWatch = new IdentityWatch({ vaultPath: VAULT_PATH, source: config.apiKeySource ?? null });
+    identityWatch = new IdentityWatch({
+      vaultPath: VAULT_PATH,
+      source: config.apiKeySource ?? null,
+      // The workspace half (0.3.6): a `login`/`init --claim` that re-binds this
+      // install to a DIFFERENT workspace changes the recorded key, and the same
+      // reload that follows a swapped `wallet.json` drops the state cached for
+      // the old one. See ./identity-reload.ts.
+      configPath: CONFIG_PATH,
+      readWorkspaceKey: readBoundWorkspace
+    });
     mcpEventLogger = new McpEventLogger(
       () => getSDK(),
       () => currentCredentials.apiKey,
@@ -122610,12 +123100,15 @@ async function initializeCredentials(walletKeystoreJson, eoaAddress, config) {
       const wallets = walletsCache || [];
       const approvedWallet = findCurrentApprovedWallet(
         wallets,
-        eoaAddress,
+        ownedSigningAddresses(),
         currentCredentials.pendingWalletId
       );
       if (approvedWallet) {
         console.error("\u2705 Found approved wallet from backend \u2014 authorization data stored");
         currentCredentials.authorizationStatus = "approved";
+        if (typeof approvedWallet.address === "string" && approvedWallet.address.trim() !== "") {
+          currentCredentials.signerAddress = approvedWallet.address;
+        }
         currentCredentials.virtualWalletStatus = approvedWallet.status;
         currentCredentials.walletAddress = approvedWallet.walletAddress || approvedWallet.kernelAccountAddress;
         currentCredentials.virtualWalletId = String(approvedWallet.id);
@@ -122662,12 +123155,9 @@ async function createKernelClientFromVault() {
     throw new Error("No passphrase or keystore available");
   }
   if (!cliConfig) throw new Error("CLI config not initialized");
-  const { readVaultPrivateKey: readVaultPrivateKey2 } = await Promise.resolve().then(() => (init_core(), core_exports));
-  let privateKey = readVaultPrivateKey2(
-    currentCredentials.walletKeystoreJson,
-    currentCredentials.passphrase
-  );
-  console.error(`${ts()} Wallet key loaded`);
+  const signer = await resolveSignerForMaterialization();
+  let privateKey = signer.privateKey;
+  console.error(`${ts()} Wallet key loaded \u2014 signing as ${signer.address}`);
   try {
     const { virtualWalletsManagers: virtualWalletsManagers2, financialAccounts: financialAccounts2 } = await getSDK();
     console.error(`${ts()} Fetching wallet data by API key...`);
@@ -122806,12 +123296,17 @@ async function tryResolvePendingApproval(probe) {
     if (probe) probe.fetched = true;
     const approvedWallet = findCurrentApprovedWallet(
       freshWallets,
-      currentCredentials.eoaAddress,
+      // Post-rotation the row belongs to the ephemeral key this request minted,
+      // not to the install EOA — match on every address we hold a key for.
+      ownedSigningAddresses(),
       currentCredentials.pendingWalletId
     );
     if (!approvedWallet) return false;
     console.error("\u2705 [approval-wait] Backend says approved \u2014 syncing");
     currentCredentials.authorizationStatus = "approved";
+    if (typeof approvedWallet.address === "string" && approvedWallet.address.trim() !== "") {
+      currentCredentials.signerAddress = approvedWallet.address;
+    }
     currentCredentials.walletAddress = approvedWallet.walletAddress || approvedWallet.kernelAccountAddress;
     currentCredentials.virtualWalletId = String(approvedWallet.id);
     currentCredentials.paymentManagerAddress = approvedWallet.paymentManagerAddress;
@@ -122938,6 +123433,12 @@ async function applyStartSessionUnlock(passphrase, resetRequested) {
       // this process loaded at boot verifies nothing: a grant approved since boot
       // would be invisible to exactly the check that exists to find it.
       fetchWallets: () => fetchVirtualWalletsFromBackend(currentCredentials.apiKey, true),
+      // ROTATION (0.3.6). Grant selection must span every address this install
+      // holds a key for, and the key that signs must be the SELECTED row's —
+      // not whatever `wallet.json` happens to contain. Both are injected so
+      // `start-session.ts` keeps no dependency on the keystore's fs layer.
+      candidateAddresses: ownedSigningAddresses(),
+      resolveSigningKey: (address) => signingKeyForAddress(address, passphrase),
       readPolicyActiveOnchain: buildPolicyActiveOnchainReader(sdk)
     }
   );
@@ -123351,11 +123852,15 @@ server.tool(
         };
       }
       const { virtualWalletsManagers: virtualWalletsManagers2 } = await getSDK();
-      const result = await submitAccessRequest(
+      const result = await submitRotatedAccessRequest(
         virtualWalletsManagers2,
         currentCredentials.apiKey,
-        currentCredentials.eoaAddress,
-        policyId
+        policyId,
+        createGrantKeyIssuer({
+          encrypted: vaultIsEncrypted(),
+          passphrase: currentCredentials.passphrase,
+          workspaceId: readBoundWorkspace()
+        })
       );
       currentCredentials.authorizationStatus = "pending";
       currentCredentials.pendingWalletId = result.id ? String(result.id) : void 0;
@@ -123413,7 +123918,7 @@ server.tool(
 server.tool(
   {
     name: "getWalletStatus",
-    description: "Get wallet status: auth, balance, policy, allowlist, WHICH WORKSPACE this server is acting in, and the last 10 transactions (amount, merchant, timestamp, status). `workspace` is `{companyName, employeeName}` \u2014 the Ametyst workspace every task, memory document and payment from this server lands in; both fields are null when the profile could not be read, which means UNKNOWN, never 'no workspace'. A transaction `amount` is a EUR display string like `\u20AC0.0126`, or the em dash `\u2014` when the row carries no usable amount (none recorded, or a value that is not a base-units integer) \u2014 `\u2014` means UNKNOWN, never zero. The unformatted base-units value is on `amountRaw`, which is null for exactly those rows.",
+    description: "Get wallet status: auth, balance, policy, allowlist, WHICH GRANT AND KEY THIS SESSION SIGNS WITH, WHICH WORKSPACE this server is acting in, and the last 10 transactions (amount, merchant, timestamp, status). `signerAddress` is the address of the approved grant this session signs with \u2014 since every access request now mints its OWN ephemeral session key, it is NOT the same as `eoaAddress` (the install wallet) except for a grant approved before rotation; `activeVirtualWalletId` / `activePolicyId` name that grant's row, and `signerKeyPresent` says whether this machine still holds the private key for `signerAddress` \u2014 `false` means no spend can be signed until `requestAccess` mints a fresh session key and an admin approves it. `workspace` is `{companyName, employeeName}` \u2014 the Ametyst workspace every task, memory document and payment from this server lands in; both fields are null when the profile could not be read, which means UNKNOWN, never 'no workspace'. A transaction `amount` is a EUR display string like `\u20AC0.0126`, or the em dash `\u2014` when the row carries no usable amount (none recorded, or a value that is not a base-units integer) \u2014 `\u2014` means UNKNOWN, never zero. The unformatted base-units value is on `amountRaw`, which is null for exactly those rows.",
     inputs: []
   },
   async () => {
@@ -123445,9 +123950,12 @@ server.tool(
             fetchVirtualWalletsFromBackend(currentCredentials.apiKey, !refreshedFromBackend),
             fetchPoliciesFromBackend(currentCredentials.apiKey, true)
           ]);
-          const freshWallet = selectNewestApprovedWallet(freshWallets, currentCredentials.eoaAddress);
+          const freshWallet = selectNewestApprovedWalletAmong(freshWallets, ownedSigningAddresses());
           const freshWalletIsActiveGrant = String(freshWallet?.id) === String(currentCredentials.virtualWalletId);
           if (freshWallet && freshWalletIsActiveGrant) {
+            if (typeof freshWallet.address === "string" && freshWallet.address.trim() !== "") {
+              currentCredentials.signerAddress = freshWallet.address;
+            }
             if (freshWallet.policyAssociated != null) {
               currentCredentials.policyId = String(freshWallet.policyAssociated);
             }
@@ -123466,6 +123974,24 @@ server.tool(
         authorized: currentCredentials.authorizationStatus === "approved",
         status: currentCredentials.authorizationStatus || "none",
         eoaAddress: currentCredentials.eoaAddress || null,
+        // WHICH KEY IS SIGNING. Since 0.3.6 every grant gets its OWN ephemeral
+        // session key, so `signerAddress` is no longer a synonym for
+        // `eoaAddress`: it is the address of the approved row this session
+        // adopted, and `eoaAddress` is the install identity in `wallet.json`.
+        // They agree only for a pre-rotation grant. Reporting both is what makes
+        // "which key signed this" readable from a payload instead of from a
+        // nonce-key autopsy — the same lesson as `activeVirtualWalletId` below.
+        signerAddress: currentCredentials.signerAddress || currentCredentials.eoaAddress || null,
+        // CAN THIS MACHINE ACTUALLY SIGN FOR THAT GRANT? A rotated grant is
+        // signable only from the per-grant keystore entry minted with it, and a
+        // machine that lost it (a re-install, a restored home, a grant approved
+        // on another laptop) is bound to a signer it cannot produce. Presence
+        // only — no decryption, so an encrypted vault with no cached passphrase
+        // still reports `true` here and bounces at spend time on the passphrase,
+        // which is a different and recoverable problem.
+        signerKeyPresent: hasSigningKeyForAddress(
+          currentCredentials.signerAddress || currentCredentials.eoaAddress
+        ),
         walletAddress: currentCredentials.walletAddress || null,
         kernelClientActive: !!currentCredentials.virtualWalletKernelAccountClient,
         // WHICH GRANT THIS SESSION SIGNS WITH. The 2026-09-01 incident — three
@@ -123489,9 +124015,7 @@ server.tool(
         }
       }
       if (walletsCache && currentCredentials.eoaAddress) {
-        const wallet = selectNewestApprovedWallet(walletsCache, currentCredentials.eoaAddress) ?? walletsCache.find(
-          (w) => w.address?.toLowerCase() === currentCredentials.eoaAddress?.toLowerCase()
-        );
+        const wallet = selectNewestApprovedWalletAmong(walletsCache, ownedSigningAddresses()) ?? walletsCache.find((w) => isOwnedSigningAddress(w.address));
         if (wallet) {
           const now = Math.floor(Date.now() / 1e3);
           const validUntil = wallet.policyValidUntil;
@@ -124015,7 +124539,7 @@ async function startLiveDashboard(entity, dir) {
         clearInterval(watcher);
         return;
       }
-      if (!existsSync12(dir)) {
+      if (!existsSync13(dir)) {
         clearInterval(watcher);
         liveDashboards.delete(slug);
         try {
@@ -124944,11 +125468,13 @@ server.tool(
         };
       }
       touchWalletActivity();
+      let missingSignerKey;
       if (!currentCredentials.virtualWalletKernelAccountClient && currentCredentials.authorizationStatus === "approved" && isWalletUnlocked()) {
         try {
           console.error("\u{1F504} [spend] Auto-creating kernel client...");
           await createKernelClientFromVault();
         } catch (kcErr) {
+          if (isMissingGrantKeyError(kcErr)) missingSignerKey = kcErr;
           console.error("\u274C [spend] Auto kernel client creation failed:", kcErr instanceof Error ? kcErr.message : String(kcErr));
         }
       }
@@ -124962,10 +125488,13 @@ server.tool(
         }
         const approvedWallet = findCurrentApprovedWallet(
           wallets,
-          currentCredentials.eoaAddress,
+          ownedSigningAddresses(),
           currentCredentials.pendingWalletId
         );
         if (approvedWallet && currentCredentials.authorizationStatus !== "approved") {
+          if (typeof approvedWallet.address === "string" && approvedWallet.address.trim() !== "") {
+            currentCredentials.signerAddress = approvedWallet.address;
+          }
           currentCredentials.walletAddress = approvedWallet.walletAddress || approvedWallet.kernelAccountAddress;
           currentCredentials.virtualWalletId = String(approvedWallet.id);
           currentCredentials.paymentManagerAddress = approvedWallet.paymentManagerAddress;
@@ -125001,6 +125530,28 @@ server.tool(
       const apiKey = currentCredentials.apiKey;
       if (!kernelClient || !apiKey) {
         console.error("\u26A0\uFE0F [spend] Missing kernel client or API key in state");
+        if (missingSignerKey) {
+          logSpendTelemetryEarlyErr();
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  ...disclosePayment(),
+                  // PRE-PAYMENT
+                  error: "signer_key_missing",
+                  detail: missingSignerKey.message,
+                  guidance: {
+                    say_to_user: "This machine can't sign for your approved access any more \u2014 the session key it was issued to isn't here. I need to request access again so a fresh key can be approved.",
+                    next_action: "Call getAvailablePolicies(), let the user pick a policy, then call requestAccess with it. Once the admin approves the new request, retry this spend.",
+                    stop: true
+                  }
+                })
+              }
+            ]
+          };
+        }
         if (currentCredentials.authorizationStatus === "pending") {
           logSpendTelemetryEarlyErr();
           return {
@@ -125854,7 +126405,7 @@ async function reconcileApprovalStateOnConnect() {
   }
   try {
     const wallets = await fetchVirtualWalletsFromBackend(currentCredentials.apiKey, true);
-    const approved = selectNewestApprovedWallet(wallets, currentCredentials.eoaAddress);
+    const approved = selectNewestApprovedWalletAmong(wallets, ownedSigningAddresses());
     if (!approved) return;
     if (typeof approved.id === "number" && hasProcessedApprovalEventId(approved.id)) return;
     console.error(
@@ -125869,9 +126420,7 @@ async function reconcileApprovalStateOnConnect() {
       policyOnchainPermissions: void 0
     });
     if (walletsCache) {
-      const idx = walletsCache.findIndex(
-        (w) => w.address?.toLowerCase() === currentCredentials.eoaAddress?.toLowerCase()
-      );
+      const idx = walletsCache.findIndex((w) => isOwnedSigningAddress(w.address));
       if (idx >= 0) walletsCache[idx] = { ...walletsCache[idx], status: "approved" };
     }
     if (typeof approved.id === "number") rememberProcessedApprovalEventId(approved.id);
@@ -125904,8 +126453,8 @@ async function setupWebSocketListener() {
           return;
         }
         const statusMatch = event.status === "approved" || event.status === "ok";
-        const addressMatch = event.address?.toLowerCase() === currentCredentials.eoaAddress?.toLowerCase();
-        console.error(`\u{1F50D} [WebSocket] statusMatch=${statusMatch} addressMatch=${addressMatch} eoaAddress=${currentCredentials.eoaAddress}`);
+        const addressMatch = isOwnedSigningAddress(event.address);
+        console.error(`\u{1F50D} [WebSocket] statusMatch=${statusMatch} addressMatch=${addressMatch} eoaAddress=${currentCredentials.eoaAddress} signerAddress=${currentCredentials.signerAddress}`);
         if (statusMatch && addressMatch) {
           try {
             await onAuthorizationApproved({
@@ -125917,9 +126466,7 @@ async function setupWebSocketListener() {
               policyOnchainPermissions: void 0
             });
             if (walletsCache) {
-              const idx = walletsCache.findIndex(
-                (w) => w.address?.toLowerCase() === currentCredentials.eoaAddress?.toLowerCase()
-              );
+              const idx = walletsCache.findIndex((w) => isOwnedSigningAddress(w.address));
               if (idx >= 0) {
                 walletsCache[idx] = { ...walletsCache[idx], status: "approved" };
               }
@@ -126192,15 +126739,15 @@ function killPreviousServeInstances(deps) {
 
 // src/commands/autosync-skills.ts
 init_esm_shims();
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/compounds/sync-skills.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync13, rmSync, writeFileSync as writeFileSync10 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync5, readFileSync as readFileSync14, rmSync, writeFileSync as writeFileSync10 } from "fs";
+import { join as join18 } from "path";
 var MANAGED_MARKER = "<!-- ametyst-managed: sync-skills -->";
 var GITIGNORE_HEADER = "# ametyst-managed: sync-skills \u2014 pointer skills generated for this account; never commit them.";
 var GITIGNORE_HEADER_2 = "# Maintained by `ametyst serve` on every boot. Real skills without the managed marker are not listed.";
@@ -126244,22 +126791,22 @@ ${taskRunSection(slug, kind)}`;
 }
 function isManaged(file) {
   try {
-    return readFileSync13(file, "utf8").includes(MANAGED_MARKER);
+    return readFileSync14(file, "utf8").includes(MANAGED_MARKER);
   } catch {
     return false;
   }
 }
 function listManagedDirs(root2) {
-  return readdirSync4(root2, { withFileTypes: true }).filter((e) => e.isDirectory() && isManaged(join17(root2, e.name, "SKILL.md"))).map((e) => e.name).sort();
+  return readdirSync5(root2, { withFileTypes: true }).filter((e) => e.isDirectory() && isManaged(join18(root2, e.name, "SKILL.md"))).map((e) => e.name).sort();
 }
 function buildGitignoreContent(managedSlugs) {
   return [GITIGNORE_HEADER, GITIGNORE_HEADER_2, ".gitignore", ...managedSlugs.map((s) => `/${s}/`)].join("\n") + "\n";
 }
 function maintainGitignore(root2) {
-  const file = join17(root2, ".gitignore");
+  const file = join18(root2, ".gitignore");
   const managed = listManagedDirs(root2);
-  if (existsSync13(file)) {
-    const current = readFileSync13(file, "utf8");
+  if (existsSync14(file)) {
+    const current = readFileSync14(file, "utf8");
     const firstLine = current.split(/\r?\n/, 1)[0];
     if (firstLine !== GITIGNORE_HEADER) {
       console.error(
@@ -126317,26 +126864,26 @@ async function syncSkills(opts = {}) {
     if (!desired.has(dir)) desired.set(dir, item);
   }
   const root2 = skillsRoot(target, global2);
-  mkdirSync8(root2, { recursive: true });
+  mkdirSync9(root2, { recursive: true });
   let written = 0;
   const skipped = [];
   for (const [dir, item] of desired) {
-    const file = join17(dir, "SKILL.md");
-    if (existsSync13(file) && !isManaged(file)) {
+    const file = join18(dir, "SKILL.md");
+    if (existsSync14(file) && !isManaged(file)) {
       skipped.push(item.slug);
       console.warn(`\u26A0\uFE0F  sync-skills: skipping "${item.slug}" \u2014 an unmanaged skill already exists at ${file}`);
       continue;
     }
-    mkdirSync8(dir, { recursive: true });
+    mkdirSync9(dir, { recursive: true });
     writeFileSync10(file, buildStubContent(item));
     written++;
   }
   let pruned = 0;
-  for (const entry of readdirSync4(root2, { withFileTypes: true })) {
+  for (const entry of readdirSync5(root2, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const dir = join17(root2, entry.name);
+    const dir = join18(root2, entry.name);
     if (desired.has(dir)) continue;
-    if (!isManaged(join17(dir, "SKILL.md"))) continue;
+    if (!isManaged(join18(dir, "SKILL.md"))) continue;
     rmSync(dir, { recursive: true, force: true });
     pruned++;
   }
@@ -126350,12 +126897,12 @@ function isSkillsAutosyncEnabled(env = process.env) {
   return !(raw === "0" || raw === "false" || raw === "off" || raw === "no");
 }
 function detectPresentTargets(deps = {}) {
-  const exists = deps.existsSync ?? existsSync14;
+  const exists = deps.existsSync ?? existsSync15;
   const cwd = deps.cwd ?? (() => process.cwd());
   const home = deps.homedir ?? homedir12;
   const targets = [];
-  if (exists(join18(cwd(), ".claude")) || exists(join18(home(), ".claude"))) targets.push("claude");
-  if (exists(join18(cwd(), ".codex")) || exists(join18(home(), ".codex", "config.toml"))) targets.push("codex");
+  if (exists(join19(cwd(), ".claude")) || exists(join19(home(), ".claude"))) targets.push("claude");
+  if (exists(join19(cwd(), ".codex")) || exists(join19(home(), ".codex", "config.toml"))) targets.push("codex");
   return targets;
 }
 function resolveAutosyncTargets(clientName, deps = {}) {
@@ -127045,14 +127592,14 @@ init_esm_shims();
 // src/loops/materialize.ts
 init_esm_shims();
 init_paths();
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
-import { join as join19 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
+import { join as join20 } from "path";
 var MIRRORED_DEFINITION_FILES = ["SKILL.md", "VISION.md", "README.md"];
 function materialize(loop2, fireId, stateDocs = []) {
   const dir = loopFireDir(loop2.slug, fireId);
-  mkdirSync9(dir, { recursive: true, mode: 448 });
+  mkdirSync10(dir, { recursive: true, mode: 448 });
   for (const doc of stateDocs) {
-    writeFileSync11(join19(dir, doc.filename), doc.body, { mode: 384 });
+    writeFileSync11(join20(dir, doc.filename), doc.body, { mode: 384 });
   }
   const files = {
     "SKILL.md": loop2.markdownBody ?? "",
@@ -127067,10 +127614,10 @@ function materialize(loop2, fireId, stateDocs = []) {
     files["dashboard.manifest.json"] = loop2.dashboardManifest;
   }
   for (const [name, body] of Object.entries(files)) {
-    writeFileSync11(join19(dir, name), body, { mode: 384 });
+    writeFileSync11(join20(dir, name), body, { mode: 384 });
   }
   writeFileSync11(
-    join19(dir, "STATUS.md"),
+    join20(dir, "STATUS.md"),
     `# STATUS \u2014 ${loop2.slug}
 
 loop_id: ${loop2.id}
@@ -127086,11 +127633,11 @@ queue: not started
 function mirrorDefinitionFiles(slug, files) {
   try {
     const root2 = loopDir(slug);
-    mkdirSync9(root2, { recursive: true, mode: 448 });
+    mkdirSync10(root2, { recursive: true, mode: 448 });
     for (const name of [...MIRRORED_DEFINITION_FILES, "dashboard.html", "dashboard.manifest.json"]) {
       const body = files[name];
       if (body === void 0) continue;
-      writeFileSync11(join19(root2, name), body, { mode: 384 });
+      writeFileSync11(join20(root2, name), body, { mode: 384 });
     }
   } catch {
   }
@@ -127216,15 +127763,15 @@ function resolveMaxBudgetUsd(opts, env = process.env) {
 // src/loops/heartbeat.ts
 init_esm_shims();
 import * as realFs2 from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function startHeartbeat(loopDir2, info, deps = {}) {
   const fs = deps.fs ?? realFs2;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const setI = deps.setInterval ?? globalThis.setInterval;
   const clearI = deps.clearInterval ?? globalThis.clearInterval;
   const intervalMs = deps.intervalMs ?? 6e4;
-  const stateDir = join20(loopDir2, ".state");
-  const path2 = join20(stateDir, "fire.running");
+  const stateDir = join21(loopDir2, ".state");
+  const path2 = join21(stateDir, "fire.running");
   try {
     fs.mkdirSync(stateDir, { recursive: true, mode: 448 });
     fs.writeFileSync(
@@ -127264,10 +127811,10 @@ ${info.sessionId ? `session=${info.sessionId}
 init_esm_shims();
 import * as realFs3 from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function transcriptPathFor(cwd, sessionId2, home = homedir13()) {
   const slug = cwd.replace(/\//g, "-");
-  return join21(home, ".claude", "projects", slug, `${sessionId2}.jsonl`);
+  return join22(home, ".claude", "projects", slug, `${sessionId2}.jsonl`);
 }
 function parseTranscriptStats(jsonl) {
   const tokens = {
@@ -127338,9 +127885,9 @@ function recordFireAccounting(args) {
   }
 }
 function appendFireLine(fs, loopDir2, rec) {
-  const stateDir = join21(loopDir2, ".state");
+  const stateDir = join22(loopDir2, ".state");
   fs.mkdirSync(stateDir, { recursive: true, mode: 448 });
-  fs.appendFileSync(join21(stateDir, "fires.jsonl"), JSON.stringify(rec) + "\n", { mode: 384 });
+  fs.appendFileSync(join22(stateDir, "fires.jsonl"), JSON.stringify(rec) + "\n", { mode: 384 });
 }
 function recordFailedLaunch(args) {
   const fs = args.deps?.fs ?? realFs3;
@@ -127369,8 +127916,8 @@ function recordFailedLaunch(args) {
 init_esm_shims();
 import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname8, join as join23 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname8, join as join24 } from "path";
 
 // src/loops/claude-binary.ts
 init_esm_shims();
@@ -127422,7 +127969,7 @@ function ensureClaudeBinary(deps = {}) {
 // src/loops/concurrency.ts
 init_esm_shims();
 import * as realFs4 from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var DEFAULT_MAX_CONCURRENT_FIRES = 6;
 var DEFAULT_HEARTBEAT_STALE_MS = 10 * 6e4;
 function pidIsAlive(pid) {
@@ -127446,14 +127993,14 @@ function liveFires(loopRoot, deps = {}) {
   const staleMs = deps.staleMs ?? DEFAULT_HEARTBEAT_STALE_MS;
   let entries;
   try {
-    entries = fs.readdirSync(join22(loopRoot, "fires"));
+    entries = fs.readdirSync(join23(loopRoot, "fires"));
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
     try {
-      const beat = join22(loopRoot, "fires", String(entry), ".state", "fire.running");
+      const beat = join23(loopRoot, "fires", String(entry), ".state", "fire.running");
       const st = fs.statSync(beat);
       const heartbeatAgeMs = now() - Number(st.mtimeMs);
       if (!(heartbeatAgeMs <= staleMs)) continue;
@@ -127481,7 +128028,7 @@ var SHIPBACK_SIGNAL_TIMEOUT_MS = 8e3;
 function preserveRefusedConstraints(slug, fireId, body) {
   try {
     const path2 = refusedConstraintsPath(slug, fireId);
-    mkdirSync10(dirname8(path2), { recursive: true, mode: 448 });
+    mkdirSync11(dirname8(path2), { recursive: true, mode: 448 });
     writeFileSync12(path2, body, { mode: 384 });
     return { path: path2 };
   } catch (err) {
@@ -127560,8 +128107,8 @@ async function runLoop(loopId, opts = {}) {
   console.log(
     `Loop ${loop2.slug}: ${est.steps} steps (${est.paidSteps} paid), est \u20AC${est.estCostEur ?? "?"} \u2014 ${capLabel}`
   );
-  const statusPath = join23(dir, "STATUS.md");
-  const statusBefore = existsSync15(statusPath) ? readFileSync14(statusPath, "utf-8") : "";
+  const statusPath = join24(dir, "STATUS.md");
+  const statusBefore = existsSync16(statusPath) ? readFileSync15(statusPath, "utf-8") : "";
   writeFileSync12(
     statusPath,
     statusBefore.replace(
@@ -127620,8 +128167,8 @@ blast_radius: steps=${est.steps} paid=${est.paidSteps} estEur=${est.estCostEur ?
   }
   async function shipConstraints() {
     try {
-      const constraintsPath = join23(dir, "CONSTRAINTS.md");
-      const materializedConstraints = existsSync15(constraintsPath) ? readFileSync14(constraintsPath, "utf-8") : void 0;
+      const constraintsPath = join24(dir, "CONSTRAINTS.md");
+      const materializedConstraints = existsSync16(constraintsPath) ? readFileSync15(constraintsPath, "utf-8") : void 0;
       if (materializedConstraints === void 0) return;
       const boot = loop2.constraintsMd ?? "";
       for (let attempt = 1; attempt <= 2; attempt++) {
@@ -127696,7 +128243,7 @@ blast_radius: steps=${est.steps} paid=${est.paidSteps} estEur=${est.estCostEur ?
     void Promise.race([shipBackConstraints().then(() => "shipped"), deadline]).then((outcome) => {
       if (outcome === "timeout") {
         console.error(
-          `Loop ${loop2.slug}: the ship-back did not finish within ${SHIPBACK_SIGNAL_TIMEOUT_MS}ms of the signal \u2014 exiting anyway so the shutdown is not held open. Nothing was discarded: this fire's rules remain at ${join23(dir, "CONSTRAINTS.md")}, and any state doc that did not get shipped remains beside it in ${dir}. The next fire can recover them by hand from there \u2014 nothing in the CLI reads a prior fire's folder automatically. \u26D4 Constraints are shipped FIRST, so the state docs are the likelier victim of this deadline \u2014 though a constraints ship-back that alone exceeds it truncates the rules too.`
+          `Loop ${loop2.slug}: the ship-back did not finish within ${SHIPBACK_SIGNAL_TIMEOUT_MS}ms of the signal \u2014 exiting anyway so the shutdown is not held open. Nothing was discarded: this fire's rules remain at ${join24(dir, "CONSTRAINTS.md")}, and any state doc that did not get shipped remains beside it in ${dir}. The next fire can recover them by hand from there \u2014 nothing in the CLI reads a prior fire's folder automatically. \u26D4 Constraints are shipped FIRST, so the state docs are the likelier victim of this deadline \u2014 though a constraints ship-back that alone exceeds it truncates the rules too.`
         );
       }
     }).finally(() => process.exit(130));
@@ -127732,7 +128279,7 @@ blast_radius: steps=${est.steps} paid=${est.paidSteps} estEur=${est.estCostEur ?
       startedAtEpochMs
     });
   }
-  const statusAfter = existsSync15(statusPath) ? readFileSync14(statusPath, "utf-8") : "";
+  const statusAfter = existsSync16(statusPath) ? readFileSync15(statusPath, "utf-8") : "";
   const clean2 = exitCode === 0 && /(vision\s*done|queue\s*drained|status:\s*done)/i.test(statusAfter) && !/(brake|crash|crashed|errored)/i.test(statusAfter);
   await shipBackConstraints();
   process.off("SIGINT", onSignal);
@@ -127770,9 +128317,9 @@ async function showLoop(loopId) {
 // src/loops/schedule.ts
 init_esm_shims();
 init_paths();
-import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync11, rmSync as rmSync3, existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync15, accessSync as accessSync2, constants as constants2 } from "fs";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync12, rmSync as rmSync3, existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync16, accessSync as accessSync2, constants as constants2 } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
-import { join as join24, dirname as dirname9 } from "path";
+import { join as join25, dirname as dirname9 } from "path";
 import { homedir as homedir14 } from "os";
 var LOOP_KIND = {
   labelPrefix: "xyz.ametyst.loop.",
@@ -127783,7 +128330,7 @@ var LOOP_KIND = {
     return args;
   },
   stateDir(slug, cwd) {
-    return join24(cwd, `.ametyst${ENV_SUFFIX}`, "loops", safeSlug2(slug, this.noun), ".state");
+    return join25(cwd, `.ametyst${ENV_SUFFIX}`, "loops", safeSlug2(slug, this.noun), ".state");
   }
 };
 var TASK_KIND = {
@@ -127795,7 +128342,7 @@ var TASK_KIND = {
     return args;
   },
   stateDir(slug, cwd) {
-    return join24(cwd, `.ametyst${ENV_SUFFIX}`, "loops", safeSlug2(slug, this.noun), ".state");
+    return join25(cwd, `.ametyst${ENV_SUFFIX}`, "loops", safeSlug2(slug, this.noun), ".state");
   }
 };
 var COMPOUND_KIND = {
@@ -127807,7 +128354,7 @@ var COMPOUND_KIND = {
     return args;
   },
   stateDir(slug, cwd) {
-    return join24(cwd, `.ametyst${ENV_SUFFIX}`, "compounds", safeSlug2(slug, this.noun), ".state");
+    return join25(cwd, `.ametyst${ENV_SUFFIX}`, "compounds", safeSlug2(slug, this.noun), ".state");
   }
 };
 function safeSlug2(slug, noun) {
@@ -127834,7 +128381,7 @@ function parseAt(at) {
   return { hour, minute };
 }
 function plistPath(kind, home, slug) {
-  return join24(home, "Library", "LaunchAgents", `${label(kind, slug)}.plist`);
+  return join25(home, "Library", "LaunchAgents", `${label(kind, slug)}.plist`);
 }
 function launchctl(args) {
   try {
@@ -127850,7 +128397,7 @@ function isLoaded(lbl) {
 }
 function readInteractiveDefaultModel(home) {
   try {
-    const raw = readFileSync15(join24(home, ".claude", "settings.json"), "utf-8");
+    const raw = readFileSync16(join25(home, ".claude", "settings.json"), "utf-8");
     const model = JSON.parse(String(raw)).model;
     return typeof model === "string" && model.trim() ? model.trim() : void 0;
   } catch {
@@ -127952,9 +128499,9 @@ ${progArgs}
 ${envEntries}
   </dict>
   <key>StandardOutPath</key>
-  <string>${escapeXml(join24(stateDir, LAUNCHD_OUT))}</string>
+  <string>${escapeXml(join25(stateDir, LAUNCHD_OUT))}</string>
   <key>StandardErrorPath</key>
-  <string>${escapeXml(join24(stateDir, LAUNCHD_ERR))}</string>
+  <string>${escapeXml(join25(stateDir, LAUNCHD_ERR))}</string>
   <key>AbandonProcessGroup</key>
   <true/>
 ${scheduleBlock}
@@ -128020,8 +128567,8 @@ function schedule(kind, slug, opts = {}) {
     const path2 = plistPath(kind, home, slug);
     const stateDir2 = kind.stateDir(slug, cwd);
     assertWritable(cwd, "working directory");
-    mkdirSync11(dirname9(path2), { recursive: true });
-    mkdirSync11(stateDir2, { recursive: true });
+    mkdirSync12(dirname9(path2), { recursive: true });
+    mkdirSync12(stateDir2, { recursive: true });
     assertWritable(stateDir2, "log directory");
     writeFileSync13(path2, plistXml(lbl, args, scheduleBlock, cwd, jobEnv, stateDir2), { mode: 384 });
     if (isLoaded(lbl)) {
@@ -128044,7 +128591,7 @@ launchctl said: ${loaded.output.trim()}` : "")
   }
   const stateDir = kind.stateDir(slug, cwd);
   assertWritable(cwd, "working directory");
-  mkdirSync11(stateDir, { recursive: true });
+  mkdirSync12(stateDir, { recursive: true });
   assertWritable(stateDir, "log directory");
   const cronEnv = { PATH: envPath };
   if (model) cronEnv.ANTHROPIC_MODEL = model;
@@ -128077,9 +128624,9 @@ function list(kind, opts = {}) {
   const home = opts.home ?? homedir14();
   const prefix = kind.labelPrefix;
   if (platform === "darwin") {
-    const dir = join24(home, "Library", "LaunchAgents");
-    if (!existsSync16(dir)) return [];
-    return readdirSync5(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".plist")).map((f) => f.slice(prefix.length, -".plist".length));
+    const dir = join25(home, "Library", "LaunchAgents");
+    if (!existsSync17(dir)) return [];
+    return readdirSync6(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".plist")).map((f) => f.slice(prefix.length, -".plist".length));
   }
   return readCrontab().split("\n").filter((l) => l.includes(`# ${prefix}`)).map((l) => l.trimEnd().slice(l.trimEnd().lastIndexOf(prefix) + prefix.length));
 }
@@ -128139,13 +128686,13 @@ function listEntries(kind, opts = {}) {
   const home = opts.home ?? homedir14();
   const prefix = kind.labelPrefix;
   if (platform === "darwin") {
-    const dir = join24(home, "Library", "LaunchAgents");
-    if (!existsSync16(dir)) return [];
-    return readdirSync5(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".plist")).map((f) => {
+    const dir = join25(home, "Library", "LaunchAgents");
+    if (!existsSync17(dir)) return [];
+    return readdirSync6(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".plist")).map((f) => {
       const slug = f.slice(prefix.length, -".plist".length);
       let envKeys = [];
       try {
-        envKeys = plistEnvKeys(String(readFileSync15(join24(dir, f), "utf-8")));
+        envKeys = plistEnvKeys(String(readFileSync16(join25(dir, f), "utf-8")));
       } catch {
         envKeys = [];
       }