@tinycloud/operations 0.3.4-beta.6 → 0.4.0-beta.8

package/dist/index.cjs

@@ -6967,6 +6967,9 @@ function evaluateOperationAuthority(granted, required, resolveSpace2) {
     missing: canonicalizeCapabilities(missing)
   };
 }
+function delegationWithinRequest(requested, effective, resolveSpace2) {
+  return requested.length > 0 && evaluateOperationAuthority(requested, canonicalizeCapabilities(effective), resolveSpace2).satisfied;
+}
 function isExactCapabilityMemberSubset(hinted, planned, resolveSpace2) {
   const canonicalHinted = canonicalizeOperationCapabilities(hinted, resolveSpace2);
   const canonicalPlanned = canonicalizeOperationCapabilities(planned, resolveSpace2);
@@ -7079,6 +7082,11 @@ var init_authority = __esm({
 });
 
 // src/state.ts
+function processWideContext(key) {
+  var _a2;
+  const registry = globalThis;
+  return registry[_a2 = Symbol.for(key)] ?? (registry[_a2] = new import_node_async_hooks.AsyncLocalStorage());
+}
 function tinycloudHomePath() {
   const home = invocationStateRoot.getStore() ?? process.env.TC_HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os.homedir)();
   return (0, import_node_path.join)(home, ".tinycloud");
@@ -7117,6 +7125,9 @@ function profileStoreMetadataPath(profile, store) {
 function profileLockPath(profile) {
   return (0, import_node_path.join)(profilePath(profile), ".lock");
 }
+function profileTurnLockPath(profile) {
+  return (0, import_node_path.join)(tinycloudHomePath(), "profile-locks", validateProfileName(profile));
+}
 async function readJson(filePath) {
   try {
     return JSON.parse(await (0, import_promises.readFile)(filePath, "utf8"));
@@ -7126,6 +7137,9 @@ async function readJson(filePath) {
   }
 }
 async function writeJsonAtomic(filePath, value) {
+  await replaceJson(filePath, value, false);
+}
+async function replaceJson(filePath, value, durable) {
   const directory = (0, import_node_path.dirname)(filePath);
   const temporaryPath = (0, import_node_path.join)(
     directory,
@@ -7135,13 +7149,25 @@ async function writeJsonAtomic(filePath, value) {
 `;
   await (0, import_promises.mkdir)(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
   try {
-    await (0, import_promises.writeFile)(temporaryPath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+    if (durable) await writeFileDurably(temporaryPath, contents);
+    else await (0, import_promises.writeFile)(temporaryPath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
     await (0, import_promises.rename)(temporaryPath, filePath);
   } catch (error) {
     await (0, import_promises.rm)(temporaryPath, { force: true }).catch(() => void 0);
     throw error;
   }
 }
+async function writeFileDurably(path, contents) {
+  const handle = await (0, import_promises.open)(path, "wx", PRIVATE_FILE_MODE);
+  try {
+    if (contents) {
+      await handle.writeFile(contents, "utf8");
+      await handle.datasync();
+    }
+  } finally {
+    await handle.close();
+  }
+}
 async function readProfile(profile) {
   return readJson(profileConfigPath(profile));
 }
@@ -7178,15 +7204,28 @@ async function withProfileLock(profile, action, options = {}) {
   const lockPath = profileLockPath(normalizedProfile);
   const held = (heldProfileLocks.getStore() ?? []).filter((ownership2) => ownership2.active);
   if (held.some((ownership2) => ownership2.lockPath === lockPath)) return action();
-  const release = await acquireProfileLock(normalizedProfile, options);
-  const ownership = { lockPath, active: true };
+  const acquired = await acquireProfileLock(normalizedProfile, options);
+  const ownership = {
+    lockPath,
+    turnSlot: acquired.turnSlot,
+    deletedWhileWaiting: acquired.deletedWhileWaiting,
+    active: true
+  };
   try {
     return await heldProfileLocks.run([...held, ownership], action);
   } finally {
     ownership.active = false;
-    await release();
+    await acquired.release();
+    if (acquired.deletedWhileWaiting) await (0, import_promises.rmdir)(profilePath(normalizedProfile)).catch(() => void 0);
   }
 }
+async function refuseWriteToDeletedProfile(profile) {
+  const lockPath = profileLockPath(profile);
+  const ownership = (heldProfileLocks.getStore() ?? []).find((candidate) => candidate.active && candidate.lockPath === lockPath);
+  if (!ownership?.deletedWhileWaiting) return;
+  if (await exists(profileConfigPath(profile))) return;
+  throw new ProfileDeletedError(profile);
+}
 async function updateProfileStore(profile, store, update, options = {}) {
   return withProfileLock(
     profile,
@@ -7195,6 +7234,7 @@ async function updateProfileStore(profile, store, update, options = {}) {
   );
 }
 async function updateProfileStoreWhileLocked(profile, store, update) {
+  await refuseWriteToDeletedProfile(profile);
   const current = await readProfileStore(profile, store);
   const next = await update(current.records);
   await writeJsonAtomic(profileStorePath(profile, store), next.records);
@@ -7205,32 +7245,271 @@ async function writeFormatOneMetadata(profile, store) {
   await writeJsonAtomic(profileStoreMetadataPath(profile, store), { formatVersion: 1 });
 }
 async function acquireProfileLock(profile, options) {
-  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-  const retryMs = options.retryMs ?? DEFAULT_LOCK_RETRY_MS;
+  const deadline = {
+    startedAt: Date.now(),
+    timeoutMs: options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS,
+    retryMs: options.retryMs ?? DEFAULT_LOCK_RETRY_MS
+  };
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
-  const startedAt = Date.now();
   const lockPath = profileLockPath(profile);
+  const turnDirectory = profileTurnLockPath(profile);
   const directory = profilePath(profile);
   await (0, import_promises.mkdir)(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(turnDirectory), { recursive: true, mode: PRIVATE_DIR_MODE });
   for (const path of [tinycloudHomePath(), profilesPath(), directory]) {
     await (0, import_promises.chmod)(path, PRIVATE_DIR_MODE).catch((error) => {
       if (path !== directory || !isErrno(error, "ENOENT")) throw error;
     });
   }
-  while (true) {
-    const token = (0, import_node_crypto.randomUUID)();
-    if (await publishProfileLock(profile, lockPath, token)) {
-      return async () => {
-        await releaseProfileLock(profile, lockPath, token);
-      };
+  const { turn, firstWaitedTurn } = await acquireTurn(profile, turnDirectory, deadline);
+  try {
+    const deletion = await readJson((0, import_node_path.join)(turnDirectory, "deleted.json")).catch(() => null);
+    const deletedWhileWaiting = typeof deletion?.slot === "number" && deletion.slot >= firstWaitedTurn;
+    while (true) {
+      const token = (0, import_node_crypto.randomUUID)();
+      if (await publishProfileLock(profile, lockPath, token)) {
+        return {
+          deletedWhileWaiting,
+          turnSlot: turn.slot,
+          release: async () => {
+            try {
+              await releaseProfileLock(profile, lockPath, token);
+            } finally {
+              await releaseTurn(profile, turn);
+            }
+          }
+        };
+      }
+      await signalTestLockContention(profile);
+      if (await recoverStaleLock(profile, lockPath, staleAfterMs)) continue;
+      await waitOrTimeOut(profile, deadline);
+    }
+  } catch (error) {
+    await releaseTurn(profile, turn);
+    throw error;
+  }
+}
+function checkDeadline(profile, deadline, detail) {
+  if (Date.now() - deadline.startedAt >= deadline.timeoutMs) {
+    throw new ProfileLockTimeoutError(profile, deadline.timeoutMs, detail);
+  }
+}
+async function waitOrTimeOut(profile, deadline, detail) {
+  checkDeadline(profile, deadline, detail);
+  await sleep(Math.min(deadline.retryMs, deadline.timeoutMs - (Date.now() - deadline.startedAt)));
+}
+async function acquireTurn(profile, directory, deadline) {
+  let firstWaitedTurn;
+  let problem;
+  const damaged = (what) => `The turn lock ${directory} ${what}, so no process can take it. If no tc or MCP process is using profile "${profile}", remove that directory.`;
+  for (let first = true; ; first = false) {
+    if (!first) checkDeadline(profile, deadline, problem);
+    problem = void 0;
+    const latest = await readLatestTurn(directory);
+    if (latest === "missing") {
+      await createTurnDirectory(directory);
+      continue;
+    }
+    if (latest === "empty") {
+      problem = damaged("has no turns");
+      await waitOrTimeOut(profile, deadline, problem);
+      continue;
+    }
+    if (latest === null) continue;
+    if (typeof latest === "number") {
+      problem = damaged(`has an unreadable turn ${latest}`);
+      await waitOrTimeOut(profile, deadline, problem);
+      continue;
     }
-    await signalTestLockContention(profile);
-    if (await recoverStaleLock(profile, lockPath, staleAfterMs)) continue;
-    const elapsedMs = Date.now() - startedAt;
-    if (elapsedMs >= timeoutMs) {
-      throw new ProfileLockTimeoutError(profile, timeoutMs);
+    firstWaitedTurn ?? (firstWaitedTurn = latest.done ? latest.slot + 1 : latest.slot);
+    if (latest.held && latest.done) {
+      const turn = await takeTurn(profile, directory, latest);
+      if (turn !== null) return { turn, firstWaitedTurn };
+      await waitOrTimeOut(profile, deadline);
+    } else if (latest.done) {
+      problem = damaged(`ends with turn ${latest.slot}, which was never granted`);
+      await waitOrTimeOut(profile, deadline, problem);
+    } else if (latest.pid === process.pid ? relinquishedTurns.has(latest.token) : !isProcessAlive(latest.pid)) {
+      await waitForTestBarrier(TEST_LOCK_TURN_SETTLE_BARRIER_DIR, profile);
+      await settleAbandonedTurn(directory, latest);
+      relinquishedTurns.delete(latest.token);
+    } else {
+      await signalTestLockContention(profile);
+      await waitOrTimeOut(profile, deadline);
+    }
+  }
+}
+async function readLatestTurn(directory) {
+  let names;
+  try {
+    names = await (0, import_promises.readdir)(directory);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return "missing";
+    throw error;
+  }
+  const slots = names.filter((name) => TURN.test(name)).map(Number);
+  if (slots.length === 0) return "empty";
+  const slot = Math.max(...slots);
+  const turn = await readTurn(directory, slot);
+  return turn === "damaged" ? slot : turn;
+}
+async function readTurn(directory, slot) {
+  const path = (0, import_node_path.join)(directory, String(slot));
+  let text;
+  try {
+    text = await (0, import_promises.readFile)((0, import_node_path.join)(path, "owner.json"), "utf8");
+  } catch (error) {
+    if (!isErrno(error, "ENOENT") && !isErrno(error, "ENOTDIR")) throw error;
+    return await exists(path) ? "damaged" : null;
+  }
+  let owner;
+  try {
+    owner = JSON.parse(text);
+  } catch {
+    return "damaged";
+  }
+  if (owner === null || typeof owner !== "object" || typeof owner.token !== "string" || typeof owner.pid !== "number") {
+    return "damaged";
+  }
+  const done = await exists((0, import_node_path.join)(path, `${owner.token}.done`));
+  const held = await exists((0, import_node_path.join)(path, `${owner.token}.held`));
+  return {
+    slot,
+    token: owner.token,
+    pid: owner.pid,
+    after: typeof owner.after === "string" ? owner.after : null,
+    held,
+    done
+  };
+}
+async function isFinishedTurn(directory, slot, token) {
+  const turn = await readTurn(directory, slot);
+  if (turn === "damaged") throw new Error(`Turn ${slot} of the turn lock ${directory} is unreadable.`);
+  return turn !== null && turn.token === token && turn.held && turn.done;
+}
+async function takeTurn(profile, directory, latest) {
+  const token = (0, import_node_crypto.randomUUID)();
+  const slot = latest.slot + 1;
+  const path = (0, import_node_path.join)(directory, String(slot));
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: latest.token };
+  let published = false;
+  try {
+    published = await publishDirectory(
+      (0, import_node_path.join)(directory, `.stage-${process.pid}-${token}`),
+      path,
+      { "owner.json": `${JSON.stringify(owner, null, 2)}
+` },
+      () => waitForTestBarrier(TEST_LOCK_TURN_PUBLISH_BARRIER_DIR, profile)
+    );
+    if (published && await isFinishedTurn(directory, latest.slot, latest.token) && await markTurn(path, token, "held")) {
+      return { directory, slot, token };
+    }
+    if (published) await markTurn(path, token, "done");
+    return null;
+  } catch (error) {
+    if (published) settleOwnTurn(directory, slot, token);
+    throw error;
+  }
+}
+async function settleAbandonedTurn(directory, abandoned) {
+  const path = (0, import_node_path.join)(directory, String(abandoned.slot));
+  if (!abandoned.held && abandoned.after !== null && await isFinishedTurn(directory, abandoned.slot - 1, abandoned.after)) {
+    await markTurn(path, abandoned.token, "held");
+  }
+  await markTurn(path, abandoned.token, "done");
+}
+function settleOwnTurn(directory, slot, token, retries = SETTLE_RETRIES) {
+  relinquishedTurns.add(token);
+  void (async () => {
+    try {
+      const turn = await readTurn(directory, slot);
+      if (turn !== null && turn !== "damaged" && turn.token === token && !turn.done) await settleAbandonedTurn(directory, turn);
+      relinquishedTurns.delete(token);
+    } catch {
+      if (retries > 0) setTimeout(() => settleOwnTurn(directory, slot, token, retries - 1), SETTLE_RETRY_MS).unref();
+    }
+  })();
+}
+async function markTurn(path, token, kind) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await (0, import_promises.writeFile)((0, import_node_path.join)(path, `${token}.${kind}`), "", { mode: PRIVATE_FILE_MODE, flag: "wx" });
+      return true;
+    } catch (error) {
+      if (isErrno(error, "EEXIST")) return true;
+      if (isErrno(error, "ENOENT")) return false;
+      if (attempt >= MARKER_RETRY_DELAYS_MS.length) throw error;
+      await sleep(MARKER_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+}
+async function createTurnDirectory(directory) {
+  const token = (0, import_node_crypto.randomUUID)();
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: null };
+  await publishDirectory((0, import_node_path.join)((0, import_node_path.dirname)(directory), `.stage-${(0, import_node_path.basename)(directory)}-${process.pid}-${token}`), directory, {
+    "0/owner.json": `${JSON.stringify(owner, null, 2)}
+`,
+    [`0/${token}.held`]: "",
+    [`0/${token}.done`]: ""
+  });
+}
+async function publishDirectory(stage, target, files, beforeRename) {
+  try {
+    for (const [name, contents] of Object.entries(files)) {
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)((0, import_node_path.join)(stage, name)), { recursive: true, mode: PRIVATE_DIR_MODE });
+      await writeFileDurably((0, import_node_path.join)(stage, name), contents);
+    }
+    await beforeRename?.();
+    await (0, import_promises.rename)(stage, target);
+    return true;
+  } catch (error) {
+    if (["ENOTEMPTY", "EEXIST", "ENOENT"].some((code) => isErrno(error, code)) || await exists(target)) return false;
+    throw error;
+  } finally {
+    await (0, import_promises.rm)(stage, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function releaseTurn(profile, turn) {
+  try {
+    await markTurn((0, import_node_path.join)(turn.directory, String(turn.slot)), turn.token, "done");
+  } catch {
+    settleOwnTurn(turn.directory, turn.slot, turn.token);
+    return;
+  }
+  await collectTurns(profile, turn).catch(() => void 0);
+}
+function isAbandonedTurnEntry(name) {
+  if (name.startsWith(".trash-")) return true;
+  const writer = /^\.(?:stage|deleted\.json)[-.]([0-9]+)[-.]/.exec(name)?.[1];
+  return writer !== void 0 && !isProcessAlive(Number(writer));
+}
+function isAbandonedTurnDirectoryStage(name) {
+  const writer = /^\.stage-.+-([0-9]+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.exec(name)?.[1];
+  return writer !== void 0 && !isProcessAlive(Number(writer));
+}
+async function collectTurns(profile, turn) {
+  for (const [directory, abandoned] of [
+    [turn.directory, isAbandonedTurnEntry],
+    [(0, import_node_path.dirname)(turn.directory), isAbandonedTurnDirectoryStage]
+  ]) {
+    for (const name of (await (0, import_promises.readdir)(directory)).filter(abandoned)) {
+      await (0, import_promises.rm)((0, import_node_path.join)(directory, name), { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+  const older = (await (0, import_promises.readdir)(turn.directory)).filter((name) => TURN.test(name)).map(Number).filter((slot) => slot < turn.slot).sort((left, right) => left - right);
+  for (const slot of older) {
+    const candidate = await readTurn(turn.directory, slot);
+    if (candidate === null || candidate === "damaged" || !candidate.done) continue;
+    if (candidate.held) {
+      if (await exists((0, import_node_path.join)(turn.directory, String(slot - 1)))) continue;
+      const next = await readTurn(turn.directory, slot + 1);
+      if (next === null || next === "damaged" || !next.held || !next.done) continue;
+    }
+    await waitForTestBarrier(TEST_LOCK_TURN_COLLECT_BARRIER_DIR, profile);
+    const trash = (0, import_node_path.join)(turn.directory, `.trash-${(0, import_node_crypto.randomUUID)()}`);
+    if (await (0, import_promises.rename)((0, import_node_path.join)(turn.directory, String(slot)), trash).then(() => true, () => false)) {
+      await (0, import_promises.rm)(trash, { recursive: true, force: true }).catch(() => void 0);
     }
-    await sleep(Math.min(retryMs, timeoutMs - elapsedMs));
   }
 }
 async function publishProfileLock(profile, lockPath, token) {
@@ -7243,12 +7522,18 @@ async function publishProfileLock(profile, lockPath, token) {
     return false;
   }
   await waitForTestBarrier(TEST_LOCK_PUBLISH_BARRIER_DIR, profile);
+  const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
   const staged = (0, import_node_path.join)((0, import_node_path.dirname)(lockPath), `.lock-owner-${token}.tmp`);
-  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token };
+  const owner = `${JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token }, null, 2)}
+`;
   try {
-    await (0, import_promises.writeFile)(staged, `${JSON.stringify(owner, null, 2)}
-`, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
-    await (0, import_promises.link)(staged, (0, import_node_path.join)(lockPath, "owner.json"));
+    await (0, import_promises.writeFile)(staged, owner, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    try {
+      await (0, import_promises.link)(staged, ownerPath);
+    } catch (error) {
+      if (!lacksHardLinks(error)) throw error;
+      await (0, import_promises.writeFile)(ownerPath, owner, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    }
     return true;
   } catch (error) {
     if (isErrno(error, "EEXIST") || isErrno(error, "ENOENT")) return false;
@@ -7258,6 +7543,9 @@ async function publishProfileLock(profile, lockPath, token) {
     await (0, import_promises.rm)(staged, { force: true }).catch(() => void 0);
   }
 }
+function lacksHardLinks(error) {
+  return typeof error === "object" && error !== null && "code" in error && NO_HARD_LINK_ERRORS.has(String(error.code));
+}
 async function releaseProfileLock(profile, lockPath, token) {
   const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
   const owner = await readJson(ownerPath).catch(() => null);
@@ -7281,9 +7569,10 @@ async function signalTestLockContention(profile) {
 `, { encoding: "utf8", flag: "wx" }).catch(() => void 0);
 }
 async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
+  let aged;
   try {
     const { mtimeMs } = await (0, import_promises.stat)(lockPath);
-    if (Date.now() - mtimeMs < staleAfterMs) return false;
+    aged = Date.now() - mtimeMs >= staleAfterMs;
   } catch {
     return false;
   }
@@ -7292,7 +7581,16 @@ async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
   try {
     const entries = await (0, import_promises.readdir)(lockPath);
     if (entries.includes("owner.json")) return false;
-    if (recoveryFenced(checkedAt, staleAfterMs)) return false;
+    const onlyOrphanedClaims = entries.length > 0 && entries.every((entry) => RECOVERY_CLAIM.test(entry));
+    if (!onlyOrphanedClaims && (!aged || recoveryFenced(checkedAt, staleAfterMs))) return false;
+    for (const name of entries.filter((entry) => RECOVERY_CLAIM.test(entry))) {
+      const claimPath = (0, import_node_path.join)(lockPath, name);
+      if (await hasLiveRecoveryOwner(claimPath)) {
+        if (!await exists((0, import_node_path.join)(lockPath, "owner.json"))) await (0, import_promises.rename)(claimPath, (0, import_node_path.join)(lockPath, "owner.json"));
+        return false;
+      }
+      await (0, import_promises.rm)(claimPath, { force: true });
+    }
     for (const name of entries.filter((entry) => ABANDONED_CLAIM.test(entry))) {
       await (0, import_promises.rm)((0, import_node_path.join)(lockPath, name), { force: true });
     }
@@ -7303,6 +7601,23 @@ async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
   await removeAgedOwnerFiles(lockPath, staleAfterMs);
   return true;
 }
+async function hasLiveRecoveryOwner(claimPath) {
+  let contents;
+  try {
+    contents = await (0, import_promises.readFile)(claimPath, "utf8");
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return false;
+    throw error;
+  }
+  let owner;
+  try {
+    owner = JSON.parse(contents);
+  } catch {
+    return false;
+  }
+  const pid = typeof owner === "object" && owner !== null && "pid" in owner ? owner.pid : null;
+  return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && isProcessAlive(pid);
+}
 function recoveryFenced(since, staleAfterMs) {
   return performance.now() - since >= staleAfterMs / 2;
 }
@@ -7317,37 +7632,57 @@ async function removeAgedOwnerFiles(lockPath, staleAfterMs) {
 }
 async function recoverStaleLock(profile, lockPath, staleAfterMs) {
   const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
-  const owner = await readJson(ownerPath).catch(() => null);
-  if (owner === null) return recoverOwnerlessLock(profile, lockPath, staleAfterMs);
-  if (!isStaleOwner(owner, staleAfterMs)) return false;
-  const observedToken = typeof owner?.token === "string" && owner.token.length > 0 ? owner.token : "legacy";
+  const observed = await (0, import_promises.readFile)(ownerPath, "utf8").catch(() => null);
+  if (observed === null) return recoverOwnerlessLock(profile, lockPath, staleAfterMs);
+  if (!await isAbandonedOwner(observed, ownerPath, staleAfterMs)) return false;
   await waitForTestBarrier(TEST_LOCK_RECOVERY_BARRIER_DIR, profile);
-  const claimPath = (0, import_node_path.join)(lockPath, `.stale-${(0, import_node_crypto.randomUUID)()}.json`);
+  const claimPath = (0, import_node_path.join)(lockPath, `.recover-${(0, import_node_crypto.randomUUID)()}.json`);
+  let moved = false;
   try {
     await (0, import_promises.link)(ownerPath, claimPath);
-  } catch {
-    return false;
+  } catch (error) {
+    if (!lacksHardLinks(error)) return false;
+    try {
+      await (0, import_promises.rename)(ownerPath, claimPath);
+      moved = true;
+    } catch {
+      return false;
+    }
   }
-  const claimedAt = performance.now();
-  await waitForTestBarrier(TEST_LOCK_CLAIM_BARRIER_DIR, profile);
-  const claimed = await readJson(claimPath).catch(() => null);
-  const sameInstance = claimed !== null && (observedToken === "legacy" ? claimed.token === void 0 : claimed.token === observedToken);
+  if (moved) await waitForTestBarrier(TEST_LOCK_MOVED_BARRIER_DIR, profile);
+  const sameInstance = await (0, import_promises.readFile)(claimPath, "utf8").then((claimed) => claimed === observed, () => false);
   await waitForTestBarrier(TEST_LOCK_VERIFIED_BARRIER_DIR, profile);
-  if (sameInstance && recoveryFenced(claimedAt, staleAfterMs)) {
-    await (0, import_promises.rm)(claimPath, { force: true });
-    await waitForTestBarrier(TEST_LOCK_FENCED_BARRIER_DIR, profile);
+  if (!sameInstance) {
+    if (moved) {
+      await (0, import_promises.rename)(claimPath, ownerPath).catch(() => void 0);
+    } else {
+      await (0, import_promises.unlink)(claimPath).catch(() => void 0);
+    }
     return false;
   }
-  if (sameInstance) {
-    await (0, import_promises.rm)(ownerPath, { force: true });
-    await waitForTestBarrier(TEST_LOCK_CLAIMED_BARRIER_DIR, profile);
+  if (!moved) await (0, import_promises.rm)(ownerPath, { force: true });
+  await waitForTestBarrier(TEST_LOCK_CLAIM_BARRIER_DIR, profile);
+  await waitForTestBarrier(TEST_LOCK_CLAIMED_BARRIER_DIR, profile);
+  for (const name of (await (0, import_promises.readdir)(lockPath).catch(() => [])).filter((entry) => RECOVERY_CLAIM.test(entry))) {
+    if ((0, import_node_path.join)(lockPath, name) !== claimPath) await (0, import_promises.rm)((0, import_node_path.join)(lockPath, name), { force: true });
   }
-  await (0, import_promises.rm)(claimPath, { force: true });
-  await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
-  if (!sameInstance) return false;
+  if (await (0, import_promises.unlink)(claimPath).then(() => true, () => false)) await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
   await removeAgedOwnerFiles(lockPath, staleAfterMs);
   return true;
 }
+async function isAbandonedOwner(observed, ownerPath, staleAfterMs) {
+  let owner;
+  try {
+    owner = JSON.parse(observed);
+  } catch {
+    owner = null;
+  }
+  if (typeof owner === "object" && owner !== null && "pid" in owner) {
+    return isStaleOwner(owner, staleAfterMs);
+  }
+  const modifiedAt = await (0, import_promises.stat)(ownerPath).then(({ mtimeMs }) => mtimeMs, () => Number.NaN);
+  return Date.now() - modifiedAt >= staleAfterMs;
+}
 async function waitForTestBarrier(environmentName, profile) {
   if (process.env.NODE_ENV !== "test") return;
   const barrierDirectory = process.env[environmentName];
@@ -7374,6 +7709,15 @@ function isStaleOwner(owner, staleAfterMs) {
   }
   return !isProcessAlive(owner.pid);
 }
+async function exists(path) {
+  try {
+    await (0, import_promises.stat)(path);
+    return true;
+  } catch (error) {
+    if (isErrno(error, "ENOENT") || isErrno(error, "ENOTDIR")) return false;
+    throw error;
+  }
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -7394,7 +7738,7 @@ function isErrno(error, code) {
 function sleep(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
 }
-var import_node_crypto, import_node_async_hooks, import_promises, import_node_os, import_node_path, DEFAULT_PROFILE, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_LOCK_RETRY_MS, DEFAULT_STALE_LOCK_MS, TEST_LOCK_CONTENTION_SIGNAL_PATH, PRIVATE_FILE_MODE, PRIVATE_DIR_MODE, TEST_LOCK_RECOVERY_BARRIER_DIR, TEST_LOCK_OWNERLESS_BARRIER_DIR, TEST_LOCK_PUBLISH_BARRIER_DIR, TEST_LOCK_RELEASE_BARRIER_DIR, TEST_LOCK_CLAIM_BARRIER_DIR, TEST_LOCK_CLAIMED_BARRIER_DIR, TEST_LOCK_FENCED_BARRIER_DIR, TEST_LOCK_VERIFIED_BARRIER_DIR, invocationStateRoot, heldProfileLocks, ProfileLockTimeoutError, ABANDONED_CLAIM, STAGED_OWNER;
+var import_node_crypto, import_node_async_hooks, import_promises, import_node_os, import_node_path, DEFAULT_PROFILE, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_LOCK_RETRY_MS, DEFAULT_STALE_LOCK_MS, TEST_LOCK_CONTENTION_SIGNAL_PATH, PRIVATE_FILE_MODE, PRIVATE_DIR_MODE, TEST_LOCK_RECOVERY_BARRIER_DIR, TEST_LOCK_OWNERLESS_BARRIER_DIR, TEST_LOCK_PUBLISH_BARRIER_DIR, TEST_LOCK_RELEASE_BARRIER_DIR, TEST_LOCK_CLAIM_BARRIER_DIR, TEST_LOCK_CLAIMED_BARRIER_DIR, TEST_LOCK_VERIFIED_BARRIER_DIR, TEST_LOCK_MOVED_BARRIER_DIR, TEST_LOCK_TURN_PUBLISH_BARRIER_DIR, TEST_LOCK_TURN_SETTLE_BARRIER_DIR, TEST_LOCK_TURN_COLLECT_BARRIER_DIR, invocationStateRoot, heldProfileLocks, ProfileLockTimeoutError, ProfileDeletedError, TURN, _a, relinquishedTurns, MARKER_RETRY_DELAYS_MS, SETTLE_RETRY_MS, SETTLE_RETRIES, NO_HARD_LINK_ERRORS, ABANDONED_CLAIM, RECOVERY_CLAIM, STAGED_OWNER;
 var init_state = __esm({
   "src/state.ts"() {
     "use strict";
@@ -7416,18 +7760,36 @@ var init_state = __esm({
     TEST_LOCK_RELEASE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RELEASE_BARRIER_DIR";
     TEST_LOCK_CLAIM_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIM_BARRIER_DIR";
     TEST_LOCK_CLAIMED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIMED_BARRIER_DIR";
-    TEST_LOCK_FENCED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_FENCED_BARRIER_DIR";
     TEST_LOCK_VERIFIED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_VERIFIED_BARRIER_DIR";
-    invocationStateRoot = new import_node_async_hooks.AsyncLocalStorage();
-    heldProfileLocks = new import_node_async_hooks.AsyncLocalStorage();
+    TEST_LOCK_MOVED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_MOVED_BARRIER_DIR";
+    TEST_LOCK_TURN_PUBLISH_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_PUBLISH_BARRIER_DIR";
+    TEST_LOCK_TURN_SETTLE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_SETTLE_BARRIER_DIR";
+    TEST_LOCK_TURN_COLLECT_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_COLLECT_BARRIER_DIR";
+    invocationStateRoot = processWideContext("tinycloud.operations.invocationStateRoot.v1");
+    heldProfileLocks = processWideContext("tinycloud.operations.heldProfileLocks.v2");
     ProfileLockTimeoutError = class extends Error {
-      constructor(profile, timeoutMs) {
-        super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.`);
+      /** `detail` names the cause when it is not simply another process holding the lock. */
+      constructor(profile, timeoutMs, detail) {
+        super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.${detail ? ` ${detail}` : ""}`);
         this.code = "PROFILE_LOCK_TIMEOUT";
         this.name = "ProfileLockTimeoutError";
       }
     };
+    ProfileDeletedError = class extends Error {
+      constructor(profile) {
+        super(`Profile "${profile}" was deleted while this change waited for its lock, so the change was not written.`);
+        this.code = "PROFILE_NOT_FOUND";
+        this.name = "ProfileDeletedError";
+      }
+    };
+    TURN = /^(?:0|[1-9][0-9]*)$/;
+    relinquishedTurns = globalThis[_a = /* @__PURE__ */ Symbol.for("tinycloud.operations.relinquishedProfileTurns.v1")] ?? (globalThis[_a] = /* @__PURE__ */ new Set());
+    MARKER_RETRY_DELAYS_MS = [10, 50, 250];
+    SETTLE_RETRY_MS = 1e3;
+    SETTLE_RETRIES = 300;
+    NO_HARD_LINK_ERRORS = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EISDIR", "EMLINK"]);
     ABANDONED_CLAIM = /^\.(?:release|stale)-[0-9a-f-]+\.json$/;
+    RECOVERY_CLAIM = /^\.recover-[0-9a-f-]+\.json$/;
     STAGED_OWNER = /^\.lock-owner-[0-9a-f-]+\.tmp$/;
   }
 });
@@ -7634,7 +7996,7 @@ function evaluateArtifactAuthority(granted, required, resolveSpace2) {
 function defaultRequestId(now) {
   return `req_${now.getTime().toString(36)}_${(0, import_node_crypto2.randomUUID)().replace(/-/g, "")}`;
 }
-var import_node_crypto2, import_zod2, THIRTY_DAYS_MS, PermissionEntrySchema, CommandSchema, LegacyPermissionRequestArtifactSchema, PortableDelegationSchema, PermissionRequestArtifactSchema, DelegationImportArtifactSchema;
+var import_node_crypto2, import_zod2, THIRTY_DAYS_MS, PermissionEntrySchema, CommandSchema, LegacyPermissionRequestArtifactSchema, PortableDelegationSchema, PermissionRequestArtifactSchema, DelegationImportArtifactSchema, DelegationRequestBindingSchema;
 var init_artifacts = __esm({
   "src/artifacts.ts"() {
     "use strict";
@@ -7709,6 +8071,7 @@ var init_artifacts = __esm({
       expiry: import_zod2.z.string().datetime({ offset: true }).optional(),
       prompted: import_zod2.z.boolean().optional()
     }).strict();
+    DelegationRequestBindingSchema = PermissionRequestArtifactSchema.pick({ requestId: true, requested: true }).strict();
   }
 });
 
@@ -7768,18 +8131,18 @@ function resolveOperationSpace(space, node, ownerSpace) {
     if (resolved !== void 0) return canonicalizeSpaceUri(resolved);
   }
   const did = typeof candidate.did === "string" ? candidate.did : void 0;
-  const pkh = did === void 0 ? null : (0, import_node_sdk.parsePkhDid)(did);
+  const pkh = did === void 0 ? null : nodeSdk.parsePkhDid(did);
   if (pkh === null) {
     throw invalidSecretInput();
   }
-  return (0, import_node_sdk.makePkhSpaceId)(pkh.address, pkh.chainId, space);
+  return nodeSdk.makePkhSpaceId(pkh.address, pkh.chainId, space);
 }
 function ownedSpaceForName(ownerSpace, name) {
-  const parsed = (0, import_node_sdk.parseSpaceUri)(ownerSpace);
+  const parsed = nodeSdk.parseSpaceUri(ownerSpace);
   if (parsed === null) return void 0;
   try {
-    const pkh = (0, import_node_sdk.parsePkhDid)(parsed.owner);
-    return pkh === null ? void 0 : (0, import_node_sdk.makePkhSpaceId)(pkh.address, pkh.chainId, name);
+    const pkh = nodeSdk.parsePkhDid(parsed.owner);
+    return pkh === null ? void 0 : nodeSdk.makePkhSpaceId(pkh.address, pkh.chainId, name);
   } catch {
     return void 0;
   }
@@ -7794,7 +8157,7 @@ function canonicalizeSpaceUri(space) {
     /^tinycloud:pkh:eip155:(\d+):(0x[0-9a-fA-F]{40}):([^:]+)$/
   );
   if (pkh !== null) {
-    return `tinycloud:pkh:eip155:${pkh[1]}:${(0, import_node_sdk.canonicalizeAddress)(pkh[2]).toLowerCase()}:${pkh[3]}`;
+    return `tinycloud:pkh:eip155:${pkh[1]}:${nodeSdk.canonicalizeAddress(pkh[2]).toLowerCase()}:${pkh[3]}`;
   }
   return space;
 }
@@ -7834,11 +8197,11 @@ function invalidSecretInput() {
     operationError("INPUT_INVALID", "The secret reference is invalid.")
   );
 }
-var import_node_sdk, DEFAULT_SECRETS_SPACE, SECRET_MANAGER_BASE_URL, SECRET_NAME_RE2, RESERVED_SECRET_SCOPES;
+var nodeSdk, DEFAULT_SECRETS_SPACE, SECRET_MANAGER_BASE_URL, SECRET_NAME_RE2, RESERVED_SECRET_SCOPES;
 var init_secrets = __esm({
   "src/secrets.ts"() {
     "use strict";
-    import_node_sdk = require("@tinycloud/node-sdk");
+    nodeSdk = __toESM(require("@tinycloud/node-sdk"), 1);
     init_errors();
     DEFAULT_SECRETS_SPACE = "secrets";
     SECRET_MANAGER_BASE_URL = "https://secrets.tinycloud.xyz";
@@ -7991,7 +8354,7 @@ async function importRequestBoundDelegation(context, input) {
     };
     let activated;
     try {
-      activated = await nodeSdk.activateValidatedRuntimeDelegation(
+      activated = await nodeSdk2.activateValidatedRuntimeDelegation(
         context.runtime.node,
         delegation,
         { host }
@@ -8007,11 +8370,7 @@ async function importRequestBoundDelegation(context, input) {
       context.runtime.node,
       context.summary.space
     );
-    if (request.requested.length === 0 || !evaluateOperationAuthority(
-      request.requested,
-      effectivePermissions,
-      resolveSpace2
-    ).satisfied) {
+    if (!delegationWithinRequest(request.requested, effectivePermissions, resolveSpace2)) {
       return operationFailure(
         "DELEGATION_REJECTED",
         "The delegation exceeds the stored authority request."
@@ -8039,12 +8398,19 @@ async function importRequestBoundDelegation(context, input) {
               )
             };
           }
-          const alreadyPresent = records.some((entry) => delegationCid(entry) === activated.cid);
+          const record = {
+            delegation: activated.delegation,
+            permissions: activated.effectivePermissions,
+            authorityRequest: {
+              requestId: request.requestId,
+              requested: request.requested
+            }
+          };
+          const position = records.findIndex((entry) => delegationCid(entry) === activated.cid);
+          const alreadyPresent = position !== -1;
+          const others = records.filter((entry) => delegationCid(entry) !== activated.cid);
           return {
-            records: alreadyPresent ? records : [...records, {
-              delegation: activated.delegation,
-              permissions: activated.effectivePermissions
-            }],
+            records: alreadyPresent ? [...others.slice(0, position), record, ...others.slice(position)] : [...records, record],
             result: {
               status: "ok",
               output: {
@@ -8173,11 +8539,11 @@ function internalImportFailure() {
 function operationFailure(code, message, details) {
   return { status: "error", error: operationError(code, message, { ...details === void 0 ? {} : { details } }) };
 }
-var nodeSdk, import_zod3, EmptyInputSchema, CapabilitiesOutputSchema, AuthRequestInputSchema, PermissionRequestOutputSchema, AuthRequestOutputSchema, AuthImportOutputSchema, AUTH_POSTURES, AUTH_EXPOSURE, AUTH_CAPABILITIES_SENSITIVITY, AUTH_REQUEST_SENSITIVITY, AUTH_IMPORT_SENSITIVITY, authOperationDefinitions;
+var nodeSdk2, import_zod3, EmptyInputSchema, CapabilitiesOutputSchema, AuthRequestInputSchema, PermissionRequestOutputSchema, AuthRequestOutputSchema, AuthImportOutputSchema, AUTH_POSTURES, AUTH_EXPOSURE, AUTH_CAPABILITIES_SENSITIVITY, AUTH_REQUEST_SENSITIVITY, AUTH_IMPORT_SENSITIVITY, authOperationDefinitions;
 var init_auth = __esm({
   "src/operations/auth.ts"() {
     "use strict";
-    nodeSdk = __toESM(require("@tinycloud/node-sdk"), 1);
+    nodeSdk2 = __toESM(require("@tinycloud/node-sdk"), 1);
     import_zod3 = require("zod");
     init_authority();
     init_artifacts();
@@ -9774,6 +10140,173 @@ ORDER BY type, name`;
   }
 });
 
+// src/delegation-binding.ts
+function bindingMigrationPath(profile) {
+  return (0, import_node_path2.join)(profilePath(profile), "delegation-binding-migration.json");
+}
+function storedDelegationKind(entry) {
+  if (!isRecord4(entry)) return "refused";
+  const delegation = entry.delegation;
+  if (!isRecord4(delegation)) return "refused";
+  const header = delegation.delegationHeader;
+  if (!isRecord4(header) || Object.keys(header).length !== 1 || !Object.prototype.hasOwnProperty.call(header, "Authorization") || typeof header.Authorization !== "string") {
+    return "refused";
+  }
+  if ("siweProof" in delegation) return "signed-login";
+  if (header.Authorization.includes(".")) return "compact";
+  return "authorityRequest" in entry ? "refused" : "other";
+}
+function replayLimit(entry, migrated) {
+  const kind = storedDelegationKind(entry);
+  if (!isRecord4(entry) || kind !== "compact" && kind !== "signed-login") return void 0;
+  const binding = DelegationRequestBindingSchema.safeParse(entry.authorityRequest);
+  if (binding.success) return binding.data.requested;
+  return !migrated && kind === "compact" && !("authorityRequest" in entry) ? "signed" : void 0;
+}
+function bindToSignedCapabilities(record, signed, source, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    ...record,
+    authorityRequest: DelegationRequestBindingSchema.parse({
+      requestId: `${REQUEST_ID_PREFIX[source]}:${record.delegation.cid}`,
+      requested: structuredClone(signed)
+    }),
+    authorityRequestAudit: { source, recordedAt, note: BINDING_NOTES[source] }
+  };
+}
+async function prepareStoredDelegationReplay(profile, node, options) {
+  if (await bindingMigrationRecorded(profile)) return true;
+  if (!options.migrate || !await holdsPersistedSession(profile, node)) return false;
+  try {
+    return await withProfileLock(profile, async () => {
+      if (await bindingMigrationRecorded(profile)) return true;
+      if (!await holdsPersistedSession(profile, node)) return false;
+      const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const bound = /* @__PURE__ */ new Map();
+      const unbound = [];
+      for (const entry of await readAdditionalDelegations(profile)) {
+        if (!isRecord4(entry) || "authorityRequest" in entry || storedDelegationKind(entry) !== "compact") continue;
+        const migrated = await migratedRecord(node, entry, options.host, recordedAt);
+        if (migrated === void 0) unbound.push(String(storedCid(entry)));
+        else bound.set(recordKey(entry), migrated);
+      }
+      if (bound.size > 0) {
+        await updateProfileStore(profile, "additional-delegations", (records) => ({
+          records: records.map((entry) => {
+            const key = !isRecord4(entry) || "authorityRequest" in entry ? void 0 : recordKey(entry);
+            return (key === void 0 ? void 0 : bound.get(key)) ?? entry;
+          }),
+          result: void 0
+        }));
+      }
+      await writeJsonAtomic(bindingMigrationPath(profile), {
+        formatVersion: 1,
+        migratedAt: recordedAt,
+        bound: [...bound.values()].map(storedCid),
+        unbound
+      });
+      return true;
+    }, { timeoutMs: MIGRATION_LOCK_TIMEOUT_MS });
+  } catch {
+    return false;
+  }
+}
+async function holdsPersistedSession(profile, node) {
+  try {
+    const persisted = await readSession(profile);
+    return typeof persisted?.verificationMethod === "string" && typeof node.sessionDid === "string" && persisted.verificationMethod.split("#", 1)[0] === node.sessionDid.split("#", 1)[0];
+  } catch {
+    return false;
+  }
+}
+async function migratedRecord(node, entry, host, recordedAt) {
+  const delegation = normalizeStoredDelegation(entry);
+  if (delegation === void 0) return void 0;
+  const signed = await signedCapabilities(node, delegation, host);
+  if (signed === void 0) return void 0;
+  try {
+    return bindToSignedCapabilities({ ...entry, delegation: { ...entry.delegation, cid: delegation.cid } }, signed, "migration", recordedAt);
+  } catch {
+    return void 0;
+  }
+}
+async function replayStoredDelegation(node, entry, options) {
+  const delegation = normalizeStoredDelegation(entry);
+  if (delegation === void 0 || delegation.expiry.getTime() <= Date.now()) return void 0;
+  const limit = replayLimit(entry, options.migrated);
+  if (limit === void 0) return void 0;
+  const authorize = limit === "signed" ? () => true : (effective) => delegationWithinRequest(limit, effective, options.resolveSpace);
+  try {
+    return await nodeSdk3.activateValidatedRuntimeDelegation(node, delegation, { host: options.host, authorize });
+  } catch {
+    return void 0;
+  }
+}
+async function bindingMigrationRecorded(profile) {
+  try {
+    return await readJson(bindingMigrationPath(profile)) !== null;
+  } catch {
+    return true;
+  }
+}
+async function signedCapabilities(node, delegation, host) {
+  let signed;
+  try {
+    await nodeSdk3.activateValidatedRuntimeDelegation(node, delegation, {
+      // The transport host is not signed authority; check it at replay instead.
+      host: delegation.host ?? host,
+      authorize: (effective) => {
+        signed = effective;
+        return false;
+      }
+    });
+  } catch {
+  }
+  return signed;
+}
+function normalizeStoredDelegation(entry) {
+  if (!isRecord4(entry)) return void 0;
+  const raw = entry.delegation;
+  if (!isRecord4(raw) || !isRecord4(raw.delegationHeader)) return void 0;
+  const expiry = raw.expiry instanceof Date ? raw.expiry : typeof raw.expiry === "string" ? new Date(raw.expiry) : void 0;
+  if (expiry === void 0 || Number.isNaN(expiry.getTime()) || typeof raw.cid !== "string" || typeof raw.spaceId !== "string" || typeof raw.path !== "string" || !Array.isArray(raw.actions) || !raw.actions.every((action) => typeof action === "string") || typeof raw.delegateDID !== "string" || typeof raw.ownerAddress !== "string" || typeof raw.chainId !== "number" || typeof raw.delegationHeader.Authorization !== "string") {
+    return void 0;
+  }
+  return { ...raw, expiry };
+}
+function storedCid(entry) {
+  const cid = isRecord4(entry) && isRecord4(entry.delegation) ? entry.delegation.cid : void 0;
+  return typeof cid === "string" ? cid : void 0;
+}
+function recordKey(entry) {
+  const delegation = entry.delegation;
+  if (!isRecord4(delegation) || !isRecord4(delegation.delegationHeader)) return void 0;
+  return JSON.stringify([delegation.cid, delegation.delegationHeader.Authorization]);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var import_node_path2, nodeSdk3, REQUEST_ID_PREFIX, BINDING_NOTES, MIGRATION_LOCK_TIMEOUT_MS;
+var init_delegation_binding = __esm({
+  "src/delegation-binding.ts"() {
+    "use strict";
+    import_node_path2 = require("path");
+    nodeSdk3 = __toESM(require("@tinycloud/node-sdk"), 1);
+    init_artifacts();
+    init_authority();
+    init_state();
+    init_secrets();
+    REQUEST_ID_PREFIX = {
+      migration: "migrated",
+      "unbound-import": "unbound-import"
+    };
+    BINDING_NOTES = {
+      migration: "Stored without a request binding before bindings were required. Bound at migration to exactly its own signed capabilities, so replay refuses any delegation in this record that exceeds them.",
+      "unbound-import": "Imported by `tc auth import` without a stored request. Bound to exactly its own signed capabilities, so replay refuses any delegation in this record that exceeds them."
+    };
+    MIGRATION_LOCK_TIMEOUT_MS = 250;
+  }
+});
+
 // src/operations/status.ts
 function createStatusDefinition(params) {
   return {
@@ -9829,7 +10362,7 @@ async function inspectPinnedProfileStatus(context, _input) {
 async function pinnedProfileExists(profile) {
   try {
     const storedProfile = await readProfile(profile);
-    return isRecord4(storedProfile);
+    return isRecord5(storedProfile);
   } catch {
     return false;
   }
@@ -9840,16 +10373,18 @@ async function countLiveAdditionalDelegations(profile) {
   if (rawDelegations === null) return 0;
   if (!Array.isArray(rawDelegations)) throw new TypeError("Invalid additional delegation store.");
   const now = Date.now();
+  const migrated = await bindingMigrationRecorded(profile);
   let count = 0;
   for (const entry of rawDelegations) {
+    if (storedDelegationKind(entry) === "refused") continue;
     const expiry = storedDelegationExpiry(entry);
-    if (expiry.getTime() > now) count += 1;
+    if (expiry.getTime() > now && replayLimit(entry, migrated) !== void 0) count += 1;
   }
   return count;
 }
 function summarizeSession(session) {
   if (session === null) return { present: false, expired: null, expiresAt: null };
-  if (!isRecord4(session)) throw new TypeError("Invalid session store.");
+  if (!isRecord5(session)) throw new TypeError("Invalid session store.");
   const expiry = extractSessionExpiry(session);
   if (expiry === null) return { present: true, expired: null, expiresAt: null };
   return {
@@ -9859,7 +10394,7 @@ function summarizeSession(session) {
   };
 }
 function storedDelegationExpiry(entry) {
-  if (!isRecord4(entry) || !isRecord4(entry.delegation) || !("expiry" in entry.delegation)) {
+  if (!isRecord5(entry) || !isRecord5(entry.delegation) || !("expiry" in entry.delegation)) {
     throw new TypeError("Invalid stored delegation.");
   }
   return parseExpiry(entry.delegation.expiry);
@@ -9888,7 +10423,7 @@ function profileNotFound(profile) {
     )
   };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var import_zod7, StatusInputSchema, StatusOutputSchema, STATUS_POSTURES, STATUS_EXPOSURE, STATUS_SENSITIVITY, statusOperationDefinitions;
@@ -9896,6 +10431,7 @@ var init_status = __esm({
   "src/operations/status.ts"() {
     "use strict";
     import_zod7 = require("zod");
+    init_delegation_binding();
     init_errors();
     init_state();
     StatusInputSchema = import_zod7.z.object({}).strict();
@@ -9918,7 +10454,9 @@ var init_status = __esm({
         expired: import_zod7.z.boolean().nullable(),
         expiresAt: import_zod7.z.string().datetime({ offset: true }).nullable()
       }).strict(),
-      liveAdditionalDelegationCount: import_zod7.z.number().int().nonnegative()
+      liveAdditionalDelegationCount: import_zod7.z.number().int().nonnegative().describe(
+        "Stored, unexpired delegations the replay rule accepts: compact-UCAN or signed-login records with a request binding, and unbound compact-UCAN records before the profile's one-time binding migration. Each is still validated, and checked against its binding, when a runtime installs it."
+      )
     }).strict();
     STATUS_POSTURES = [
       "owner-openkey",
@@ -10072,9 +10610,9 @@ function isOperatorType(value) {
   return value === "human" || value === "agent";
 }
 function isStoredProfile(value) {
-  return isRecord5(value) && isNonEmptyString(value.name) && isNonEmptyString(value.host) && typeof value.chainId === "number" && Number.isFinite(value.chainId) && isNonEmptyString(value.spaceName) && isNonEmptyString(value.did) && isNonEmptyString(value.createdAt) && isOptionalNonEmptyString(value.sessionDid) && isOptionalNonEmptyString(value.ownerDid) && isOptionalNonEmptyString(value.spaceId) && isOptionalPosture(value.posture) && isOptionalOperatorType(value.operatorType) && isOptionalAuthMethod(value.authMethod) && isOptionalNonEmptyString(value.defaultSpace) && isOptionalNonEmptyString(value.privateKey) && isOptionalNonEmptyString(value.address) && isOptionalNonEmptyString(value.openkeyHost);
+  return isRecord6(value) && isNonEmptyString(value.name) && isNonEmptyString(value.host) && typeof value.chainId === "number" && Number.isFinite(value.chainId) && isNonEmptyString(value.spaceName) && isNonEmptyString(value.did) && isNonEmptyString(value.createdAt) && isOptionalNonEmptyString(value.sessionDid) && isOptionalNonEmptyString(value.ownerDid) && isOptionalNonEmptyString(value.spaceId) && isOptionalPosture(value.posture) && isOptionalOperatorType(value.operatorType) && isOptionalAuthMethod(value.authMethod) && isOptionalNonEmptyString(value.defaultSpace) && isOptionalNonEmptyString(value.privateKey) && isOptionalNonEmptyString(value.address) && isOptionalNonEmptyString(value.openkeyHost);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString(value) {
@@ -10131,14 +10669,12 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
   const profileName = summary.profile;
   try {
     const {
-      activateValidatedRuntimeDelegation: activateValidatedRuntimeDelegation2,
       TinyCloudNode: TinyCloudNodeConstructor
-    } = nodeSdk2;
+    } = nodeSdk4;
     const explicitPrivateKeyOverride = typeof target.privateKey === "string";
-    const [session, key, additionalDelegations] = explicitPrivateKeyOverride ? [null, null, []] : await Promise.all([
+    const [session, key] = explicitPrivateKeyOverride ? [null, null] : await Promise.all([
       readSession(profileName),
-      readJson(`${profilePath(profileName)}/key.json`),
-      readAdditionalDelegations(profileName)
+      readJson(`${profilePath(profileName)}/key.json`)
     ]);
     const profile = resolved.profile;
     const actualPosture = resolvePosture(profile);
@@ -10185,19 +10721,26 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
     const livePrincipalDid = normalizeDid(node.did);
     const authenticatedSpace = explicitPrivateKeyOverride ? spaceForAuthenticatedPrincipal(livePrincipalDid) : void 0;
     const livePermissions = [...node.getVerifiedSessionCapabilities()];
+    const resolveSpace2 = operationSpaceResolver(node, authenticatedSpace ?? summary.space);
     const seenCids = /* @__PURE__ */ new Set();
-    for (const entry of additionalDelegations) {
-      const delegation = normalizeStoredDelegation(entry);
-      if (delegation === void 0 || delegation.expiry.getTime() <= Date.now()) continue;
-      try {
-        const activated = await activateValidatedRuntimeDelegation2(node, delegation, {
-          host: summary.host
+    if (!explicitPrivateKeyOverride) {
+      const activator = node;
+      const migrated = await prepareStoredDelegationReplay(profileName, activator, {
+        host: summary.host,
+        // Only the profile's own restored session; a local sign-in without
+        // one uses a fresh session key the stored records do not address.
+        migrate: activeSession !== void 0
+      });
+      for (const entry of await readAdditionalDelegations(profileName)) {
+        const activated = await replayStoredDelegation(activator, entry, {
+          host: summary.host,
+          migrated,
+          resolveSpace: resolveSpace2
         });
-        if (!seenCids.has(activated.cid)) {
+        if (activated !== void 0 && !seenCids.has(activated.cid)) {
           seenCids.add(activated.cid);
           livePermissions.push(...activated.effectivePermissions);
         }
-      } catch {
       }
     }
     const runtime = {
@@ -10229,8 +10772,8 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
 function spaceForAuthenticatedPrincipal(principal2) {
   if (principal2 === void 0) return void 0;
   try {
-    const pkh = nodeSdk2.parsePkhDid(principal2);
-    return pkh === null ? void 0 : nodeSdk2.makePkhSpaceId(pkh.address, pkh.chainId, "secrets");
+    const pkh = nodeSdk4.parsePkhDid(principal2);
+    return pkh === null ? void 0 : nodeSdk4.makePkhSpaceId(pkh.address, pkh.chainId, "secrets");
   } catch {
     return void 0;
   }
@@ -10238,7 +10781,7 @@ function spaceForAuthenticatedPrincipal(principal2) {
 function normalizeSession(session, key) {
   const header = session.delegationHeader;
   const jwk = hasPrivateParameter(session.jwk) ? session.jwk : key;
-  if (!isRecord6(header) || typeof header.Authorization !== "string" || typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || !hasPrivateParameter(jwk) || typeof session.verificationMethod !== "string") {
+  if (!isRecord7(header) || typeof header.Authorization !== "string" || typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || !hasPrivateParameter(jwk) || typeof session.verificationMethod !== "string") {
     return void 0;
   }
   return {
@@ -10254,27 +10797,14 @@ function normalizeSession(session, key) {
     ...Array.isArray(session.tinycloudHosts) && session.tinycloudHosts.every((host) => typeof host === "string") ? { tinycloudHosts: session.tinycloudHosts } : {}
   };
 }
-function normalizeStoredDelegation(entry) {
-  const raw = entry.delegation;
-  if (!isRecord6(raw) || !isRecord6(raw.delegationHeader)) return void 0;
-  const expiry = parseExpiry2(raw.expiry);
-  if (expiry === void 0 || typeof raw.cid !== "string" || typeof raw.spaceId !== "string" || typeof raw.path !== "string" || !Array.isArray(raw.actions) || !raw.actions.every((action) => typeof action === "string") || typeof raw.delegateDID !== "string" || typeof raw.ownerAddress !== "string" || typeof raw.chainId !== "number" || typeof raw.delegationHeader.Authorization !== "string") {
-    return void 0;
-  }
-  return { ...raw, expiry };
-}
-function parseExpiry2(value) {
-  const expiry = value instanceof Date ? value : typeof value === "string" ? new Date(value) : void 0;
-  return expiry !== void 0 && !Number.isNaN(expiry.getTime()) ? expiry : void 0;
-}
 function hasPrivateParameter(value) {
-  return isRecord6(value) && typeof value.d === "string" && value.d.length > 0;
+  return isRecord7(value) && typeof value.d === "string" && value.d.length > 0;
 }
 function normalizeDid(value) {
   if (typeof value !== "string" || value.length === 0) return void 0;
   return value.split("#", 1)[0];
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function failed(context, error) {
@@ -10287,15 +10817,17 @@ function unresolvedSummary(target) {
     posture: "unauthenticated"
   };
 }
-var nodeSdk2;
+var nodeSdk4;
 var init_runtime = __esm({
   "src/runtime.ts"() {
     "use strict";
-    nodeSdk2 = __toESM(require("@tinycloud/node-sdk"), 1);
+    nodeSdk4 = __toESM(require("@tinycloud/node-sdk"), 1);
     init_authority();
     init_errors();
     init_profile();
+    init_secrets();
     init_state();
+    init_delegation_binding();
   }
 });
 
@@ -10308,8 +10840,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/invoke.ts
 var import_node_crypto3 = require("crypto");
-var import_node_path2 = require("path");
-var import_node_sdk2 = require("@tinycloud/node-sdk");
+var import_node_path3 = require("path");
+var import_node_sdk = require("@tinycloud/node-sdk");
 
 // ../sdk-core/src/policy/errors.ts
 var SignedObjectProfileError = class extends Error {
@@ -11014,7 +11546,7 @@ function normalizeInvocationTarget(target) {
     const stateRoot = candidate.stateRoot;
     const allowOwnerProfile = candidate.allowOwnerProfile;
     const privateKey = candidate.privateKey;
-    if (profile !== void 0 && typeof profile !== "string" || host !== void 0 && typeof host !== "string" || stateRoot !== void 0 && (typeof stateRoot !== "string" || !(0, import_node_path2.isAbsolute)(stateRoot)) || allowOwnerProfile !== void 0 && typeof allowOwnerProfile !== "boolean" || privateKey !== void 0 && typeof privateKey !== "string") {
+    if (profile !== void 0 && typeof profile !== "string" || host !== void 0 && typeof host !== "string" || stateRoot !== void 0 && (typeof stateRoot !== "string" || !(0, import_node_path3.isAbsolute)(stateRoot)) || allowOwnerProfile !== void 0 && typeof allowOwnerProfile !== "boolean" || privateKey !== void 0 && typeof privateKey !== "string") {
       return void 0;
     }
     return {