@tinycloud/operations 0.5.0-beta.1 → 0.5.0-beta.10

package/dist/cli-runtime.cjs

@@ -300,6 +300,7 @@ var init_errors2 = __esm({
       "PROFILE_NOT_FOUND",
       "PROFILE_POSTURE_NOT_ALLOWED",
       "PROFILE_OWNER_OPT_IN_REQUIRED",
+      "PROFILE_MIGRATION_REQUIRED",
       "AUTH_REQUIRED",
       "PERMISSION_DENIED",
       "SESSION_NOT_FOUND",
@@ -4108,10 +4109,10 @@ function evaluateOperationAuthority(granted, required, resolveSpace2) {
   const canonicalRequired = canonicalizeOperationCapabilities(required, resolveSpace2);
   const missing = [];
   for (const requested of canonicalRequired) {
-    const covered = canonicalGranted.some(
-      (candidate) => candidate.service === requested.service && operationSpacesEqual(candidate.space, requested.space) && isCapabilitySubset([requested], [candidate]).subset
+    const sameScope = canonicalGranted.filter(
+      (candidate) => candidate.service === requested.service && operationSpacesEqual(candidate.space, requested.space)
     );
-    if (!covered) missing.push(requested);
+    if (!isCapabilitySubset([requested], sameScope).subset) missing.push(requested);
   }
   return {
     satisfied: missing.length === 0,
@@ -4234,9 +4235,161 @@ var init_authority = __esm({
 
 // src/state.ts
 function processWideContext(key) {
-  var _a3;
+  var _a4;
   const registry = globalThis;
-  return registry[_a3 = Symbol.for(key)] ?? (registry[_a3] = new import_node_async_hooks.AsyncLocalStorage());
+  return registry[_a4 = Symbol.for(key)] ?? (registry[_a4] = new import_node_async_hooks.AsyncLocalStorage());
+}
+function processOrigin() {
+  if (cachedProcessOrigin !== void 0) return cachedProcessOrigin;
+  if (process.platform !== "linux") return cachedProcessOrigin = null;
+  try {
+    const bootId = (0, import_node_fs.readFileSync)("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    const pidNamespace = (0, import_node_fs.readlinkSync)("/proc/self/ns/pid");
+    const processStat = (0, import_node_fs.readFileSync)("/proc/self/stat", "utf8");
+    const closingParen = processStat.lastIndexOf(") ");
+    const processStartTime = closingParen < 0 ? void 0 : processStat.slice(closingParen + 2).trim().split(/\s+/)[19];
+    if (!/^[0-9a-f-]{36}$/.test(bootId) || !/^pid:\[[0-9]+\]$/.test(pidNamespace) || !processStartTime || !/^[0-9]+$/.test(processStartTime)) {
+      return cachedProcessOrigin = null;
+    }
+    return cachedProcessOrigin = { bootId, pidNamespace, processStartTime };
+  } catch {
+    return cachedProcessOrigin = null;
+  }
+}
+function processOwner(liveness) {
+  return { instanceId: processInstanceId, ...processOrigin(), ...liveness ? { liveness: liveness.record } : {} };
+}
+function socketDirectory(name) {
+  const match = LIVENESS_SOCKET.exec(name);
+  return match ? `${match[1]}-${match[2]}` : null;
+}
+async function pinDirectory(directory) {
+  const handle = await (0, import_promises.open)(directory, "r");
+  try {
+    const { dev, ino } = await handle.stat({ bigint: true });
+    return {
+      identity: `${dev.toString(16)}-${ino.toString(16)}`,
+      path: (name) => `/proc/self/fd/${handle.fd}/${name}`,
+      close: () => handle.close()
+    };
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+async function bindLiveness(directory) {
+  if (!processOrigin()) return null;
+  let pinned;
+  try {
+    pinned = await pinDirectory(directory);
+  } catch {
+    return null;
+  }
+  const socket = `.live-${pinned.identity}-${(0, import_node_crypto.randomUUID)()}`;
+  const server = (0, import_node_net.createServer)((connection) => connection.destroy());
+  let bound = false;
+  try {
+    await new Promise((resolve2, reject) => {
+      server.once("error", reject);
+      server.listen({ path: pinned.path(`${socket}.new`), exclusive: true }, () => {
+        server.off("error", reject);
+        resolve2();
+      });
+    });
+    bound = true;
+    server.on("error", () => void 0);
+    server.unref();
+    await (0, import_promises.rename)(pinned.path(`${socket}.new`), pinned.path(socket));
+    const stats = await (0, import_promises.lstat)(pinned.path(socket), { bigint: true });
+    if (!stats.isSocket()) throw new Error(`${socket} is not a socket`);
+    await waitForTestBarrier(TEST_LOCK_LIVENESS_BARRIER_DIR, (0, import_node_path.basename)(directory));
+    return { record: { socket, dev: String(stats.dev), ino: String(stats.ino) }, path: (0, import_node_path.join)(directory, socket), server };
+  } catch {
+    if (bound) {
+      server.close();
+      for (const name of [`${socket}.new`, socket]) await (0, import_promises.unlink)(pinned.path(name)).catch(() => void 0);
+    }
+    return null;
+  } finally {
+    await pinned.close();
+  }
+}
+async function ensureLiveness(acquisition) {
+  if (acquisition.held === void 0) acquisition.held = await bindLiveness(acquisition.directory);
+  return acquisition.held;
+}
+async function closeLiveness(held) {
+  held.server.close();
+  await (0, import_promises.unlink)(held.path).catch(() => void 0);
+}
+function parseLiveness(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const { socket, dev, ino } = value;
+  const name = typeof socket === "string" ? LIVENESS_SOCKET.exec(socket) : null;
+  return name !== null && name[3] === void 0 && typeof dev === "string" && /^[0-9]+$/.test(dev) && typeof ino === "string" && /^[0-9]+$/.test(ino) ? { socket: name[0], dev, ino } : null;
+}
+async function controlIn(pinned, acquisition) {
+  const own = await ensureLiveness(acquisition);
+  if (!own || socketDirectory(own.record.socket) !== pinned.identity) return null;
+  const stats = await (0, import_promises.lstat)(pinned.path(own.record.socket), { bigint: true }).catch(() => null);
+  return stats?.isSocket() && String(stats.dev) === own.record.dev && String(stats.ino) === own.record.ino ? own : null;
+}
+async function tryConnect(path) {
+  return new Promise((resolve2) => {
+    const probe = (0, import_node_net.connect)({ path });
+    const settle = (outcome) => {
+      clearTimeout(timer);
+      probe.destroy();
+      resolve2(outcome);
+    };
+    const timer = setTimeout(() => settle("other"), LIVENESS_PROBE_TIMEOUT_MS);
+    probe.once("connect", () => settle("connected"));
+    probe.once("error", (error) => settle(isErrno(error, "ECONNREFUSED") ? "refused" : "other"));
+  });
+}
+async function kernelRefuses(pinned, name, control) {
+  if (process.versions.bun !== void 0) return false;
+  return await tryConnect(pinned.path(name)) === "refused" && await tryConnect(pinned.path(control.record.socket)) === "connected";
+}
+async function probeLiveness(liveness, acquisition) {
+  let pinned;
+  try {
+    pinned = await pinDirectory(acquisition.directory);
+  } catch {
+    return "unknown";
+  }
+  try {
+    if (socketDirectory(liveness.socket) !== pinned.identity) return "unknown";
+    const control = await controlIn(pinned, acquisition);
+    if (!control) return "unknown";
+    let stats;
+    try {
+      stats = await (0, import_promises.lstat)(pinned.path(liveness.socket), { bigint: true });
+    } catch (error) {
+      return isErrno(error, "ENOENT") ? "gone" : "unknown";
+    }
+    if (!stats.isSocket() || String(stats.dev) !== liveness.dev || String(stats.ino) !== liveness.ino) return "unknown";
+    return await kernelRefuses(pinned, liveness.socket, control) ? "refused" : "unknown";
+  } finally {
+    await pinned.close();
+  }
+}
+async function sweepLiveness(acquisition) {
+  if (process.versions.bun !== void 0 || !acquisition.held) return;
+  const pinned = await pinDirectory(acquisition.directory);
+  try {
+    const control = await controlIn(pinned, acquisition);
+    if (!control) return;
+    for (const name of await (0, import_promises.readdir)(pinned.path("."))) {
+      if (name === control.record.socket || socketDirectory(name) !== pinned.identity) continue;
+      const stats = await (0, import_promises.lstat)(pinned.path(name)).catch(() => null);
+      if (stats?.isSocket() && await kernelRefuses(pinned, name, control)) {
+        await (0, import_promises.unlink)(pinned.path(name)).catch(() => void 0);
+      }
+    }
+  } finally {
+    await pinned.close();
+  }
 }
 function tinycloudHomePath() {
   const home = invocationStateRoot.getStore() ?? process.env.TC_HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os.homedir)();
@@ -4413,7 +4566,18 @@ async function acquireProfileLock(profile, options) {
       if (path !== directory || !isErrno(error, "ENOENT")) throw error;
     });
   }
-  const { turn, firstWaitedTurn } = await acquireTurn(profile, turnDirectory, deadline);
+  const liveness = { directory: turnDirectory, held: void 0 };
+  const closeAcquisitionLiveness = async () => {
+    if (liveness.held) await closeLiveness(liveness.held);
+  };
+  let taken;
+  try {
+    taken = await acquireTurn(profile, turnDirectory, deadline, liveness);
+  } catch (error) {
+    await closeAcquisitionLiveness();
+    throw error;
+  }
+  const { turn, firstWaitedTurn } = taken;
   try {
     if (options.requireProfile && !await exists(profileConfigPath(profile))) {
       await (0, import_promises.rmdir)(directory).catch(() => void 0);
@@ -4423,7 +4587,7 @@ async function acquireProfileLock(profile, options) {
     const deletedWhileWaiting = typeof deletion?.slot === "number" && deletion.slot >= firstWaitedTurn;
     while (true) {
       const token = (0, import_node_crypto.randomUUID)();
-      if (await publishProfileLock(profile, lockPath, token, options.requireProfile === true)) {
+      if (await publishProfileLock(profile, lockPath, token, options.requireProfile === true, liveness.held ?? null)) {
         return {
           deletedWhileWaiting,
           turnSlot: turn.slot,
@@ -4431,17 +4595,19 @@ async function acquireProfileLock(profile, options) {
             try {
               await releaseProfileLock(profile, lockPath, token);
             } finally {
-              await releaseTurn(profile, turn);
+              await releaseTurn(profile, turn, liveness);
+              await closeAcquisitionLiveness();
             }
           }
         };
       }
       await signalTestLockContention(profile);
-      if (await recoverStaleLock(profile, lockPath, staleAfterMs)) continue;
+      if (await recoverStaleLock(profile, lockPath, liveness, staleAfterMs)) continue;
       await waitOrTimeOut(profile, deadline);
     }
   } catch (error) {
-    await releaseTurn(profile, turn);
+    await releaseTurn(profile, turn, liveness);
+    await closeAcquisitionLiveness();
     throw error;
   }
 }
@@ -4454,7 +4620,7 @@ 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) {
+async function acquireTurn(profile, directory, deadline, liveness) {
   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.`;
@@ -4479,13 +4645,13 @@ async function acquireTurn(profile, directory, deadline) {
     }
     firstWaitedTurn ?? (firstWaitedTurn = latest.done ? latest.slot + 1 : latest.slot);
     if (latest.held && latest.done) {
-      const turn = await takeTurn(profile, directory, latest);
+      const turn = await takeTurn(profile, directory, latest, await ensureLiveness(liveness));
       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)) {
+    } else if (latest.pid === process.pid && relinquishedTurns.has(latest.token) || !await isRecordedProcessAlive(latest, liveness)) {
       await waitForTestBarrier(TEST_LOCK_TURN_SETTLE_BARRIER_DIR, profile);
       await settleAbandonedTurn(directory, latest);
       relinquishedTurns.delete(latest.token);
@@ -4530,6 +4696,7 @@ async function readTurn(directory, slot) {
   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 {
+    ...owner,
     slot,
     token: owner.token,
     pid: owner.pid,
@@ -4543,11 +4710,11 @@ async function isFinishedTurn(directory, slot, token) {
   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) {
+async function takeTurn(profile, directory, latest, liveness) {
   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 };
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: latest.token, ...processOwner(liveness) };
   let published = false;
   try {
     published = await publishDirectory(
@@ -4601,7 +4768,7 @@ async function markTurn(path, token, kind) {
 }
 async function createTurnDirectory(directory) {
   const token = (0, import_node_crypto.randomUUID)();
-  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: null };
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: null, ...processOwner(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)}
 `,
@@ -4625,31 +4792,39 @@ async function publishDirectory(stage, target, files, beforeRename) {
     await (0, import_promises.rm)(stage, { recursive: true, force: true }).catch(() => void 0);
   }
 }
-async function releaseTurn(profile, turn) {
+async function releaseTurn(profile, turn, liveness) {
   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);
+  await collectTurns(profile, turn, liveness).catch(() => void 0);
 }
-function isAbandonedTurnEntry(name) {
+async function isAbandonedTurnEntry(directory, name, liveness) {
   if (name.startsWith(".trash-")) return true;
   const writer = /^\.(?:stage|deleted\.json)[-.]([0-9]+)[-.]/.exec(name)?.[1];
-  return writer !== void 0 && !isProcessAlive(Number(writer));
+  if (writer === void 0) return false;
+  if (Number(writer) !== process.pid) return !await isRecordedProcessAlive({ pid: Number(writer) }, liveness);
+  return name.startsWith(".stage-") && await isStagedOwnerGone((0, import_node_path.join)(directory, name, "owner.json"), liveness);
 }
-function isAbandonedTurnDirectoryStage(name) {
+async function isAbandonedTurnDirectoryStage(directory, name, liveness) {
   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));
+  if (writer === void 0) return false;
+  if (Number(writer) !== process.pid) return !await isRecordedProcessAlive({ pid: Number(writer) }, liveness);
+  return isStagedOwnerGone((0, import_node_path.join)(directory, name, "0", "owner.json"), liveness);
 }
-async function collectTurns(profile, turn) {
+async function isStagedOwnerGone(recordPath, liveness) {
+  const owner = await readJson(recordPath).catch(() => null);
+  return typeof owner === "object" && owner !== null && owner.pid === process.pid && !await isRecordedProcessAlive(owner, liveness);
+}
+async function collectTurns(profile, turn, liveness) {
   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);
+    for (const name of await (0, import_promises.readdir)(directory)) {
+      if (await abandoned(directory, name, liveness)) 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);
@@ -4667,8 +4842,9 @@ async function collectTurns(profile, turn) {
       await (0, import_promises.rm)(trash, { recursive: true, force: true }).catch(() => void 0);
     }
   }
+  await sweepLiveness(liveness);
 }
-async function publishProfileLock(profile, lockPath, token, requireProfile) {
+async function publishProfileLock(profile, lockPath, token, requireProfile, liveness) {
   try {
     await (0, import_promises.mkdir)(lockPath, { mode: PRIVATE_DIR_MODE });
   } catch (error) {
@@ -4681,7 +4857,7 @@ async function publishProfileLock(profile, lockPath, token, requireProfile) {
   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 = `${JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token }, null, 2)}
+  const owner = `${JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, ...processOwner(liveness) }, null, 2)}
 `;
   try {
     await (0, import_promises.writeFile)(staged, owner, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
@@ -4725,7 +4901,7 @@ async function signalTestLockContention(profile) {
   await (0, import_promises.writeFile)(signalPath, `${profile}
 `, { encoding: "utf8", flag: "wx" }).catch(() => void 0);
 }
-async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
+async function recoverOwnerlessLock(profile, lockPath, liveness, staleAfterMs) {
   let aged;
   try {
     const { mtimeMs } = await (0, import_promises.stat)(lockPath);
@@ -4742,7 +4918,7 @@ async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
     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 hasLiveRecoveryOwner(claimPath, liveness)) {
         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;
       }
@@ -4758,7 +4934,7 @@ async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
   await removeAgedOwnerFiles(lockPath, staleAfterMs);
   return true;
 }
-async function hasLiveRecoveryOwner(claimPath) {
+async function hasLiveRecoveryOwner(claimPath, liveness) {
   let contents;
   try {
     contents = await (0, import_promises.readFile)(claimPath, "utf8");
@@ -4772,8 +4948,8 @@ async function hasLiveRecoveryOwner(claimPath) {
   } 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);
+  const record = typeof owner === "object" && owner !== null && "pid" in owner ? owner : null;
+  return typeof record?.pid === "number" && Number.isInteger(record.pid) && record.pid > 0 && await isRecordedProcessAlive(record, liveness);
 }
 function recoveryFenced(since, staleAfterMs) {
   return performance.now() - since >= staleAfterMs / 2;
@@ -4787,11 +4963,11 @@ async function removeAgedOwnerFiles(lockPath, staleAfterMs) {
     if (aged) await (0, import_promises.rm)(path, { force: true }).catch(() => void 0);
   }
 }
-async function recoverStaleLock(profile, lockPath, staleAfterMs) {
+async function recoverStaleLock(profile, lockPath, liveness, staleAfterMs) {
   const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
   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;
+  if (observed === null) return recoverOwnerlessLock(profile, lockPath, liveness, staleAfterMs);
+  if (!await isAbandonedOwner(observed, ownerPath, liveness, staleAfterMs)) return false;
   await waitForTestBarrier(TEST_LOCK_RECOVERY_BARRIER_DIR, profile);
   const claimPath = (0, import_node_path.join)(lockPath, `.recover-${(0, import_node_crypto.randomUUID)()}.json`);
   let moved = false;
@@ -4827,7 +5003,7 @@ async function recoverStaleLock(profile, lockPath, staleAfterMs) {
   await removeAgedOwnerFiles(lockPath, staleAfterMs);
   return true;
 }
-async function isAbandonedOwner(observed, ownerPath, staleAfterMs) {
+async function isAbandonedOwner(observed, ownerPath, liveness, staleAfterMs) {
   let owner;
   try {
     owner = JSON.parse(observed);
@@ -4835,7 +5011,7 @@ async function isAbandonedOwner(observed, ownerPath, staleAfterMs) {
     owner = null;
   }
   if (typeof owner === "object" && owner !== null && "pid" in owner) {
-    return isStaleOwner(owner, staleAfterMs);
+    return isStaleOwner(owner, liveness, staleAfterMs);
   }
   const modifiedAt = await (0, import_promises.stat)(ownerPath).then(({ mtimeMs }) => mtimeMs, () => Number.NaN);
   return Date.now() - modifiedAt >= staleAfterMs;
@@ -4857,14 +5033,14 @@ async function waitForTestBarrier(environmentName, profile) {
     }
   }
 }
-function isStaleOwner(owner, staleAfterMs) {
+async function isStaleOwner(owner, liveness, staleAfterMs) {
   const now = Date.now();
   const createdAt = typeof owner?.createdAt === "string" ? Date.parse(owner.createdAt) : Number.NaN;
   if (!Number.isFinite(createdAt) || now - createdAt < staleAfterMs) return false;
   if (typeof owner?.pid !== "number" || !Number.isInteger(owner.pid) || owner.pid <= 0) {
     return false;
   }
-  return !isProcessAlive(owner.pid);
+  return !await isRecordedProcessAlive(owner, liveness);
 }
 async function exists(path) {
   try {
@@ -4875,13 +5051,22 @@ async function exists(path) {
     throw error;
   }
 }
-function isProcessAlive(pid) {
+async function isRecordedProcessAlive(owner, acquisition) {
+  const pid = owner.pid;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return true;
   try {
     process.kill(pid, 0);
-    return true;
   } catch (error) {
     return !isErrno(error, "ESRCH");
   }
+  if (pid !== process.pid || typeof owner.instanceId !== "string" || !/^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(owner.instanceId) || owner.instanceId === processInstanceId) return true;
+  const origin = processOrigin();
+  if (!origin || owner.bootId !== origin.bootId || typeof owner.pidNamespace !== "string" || !/^pid:\[[0-9]+\]$/.test(owner.pidNamespace)) return true;
+  if (owner.pidNamespace === origin.pidNamespace) {
+    return typeof owner.processStartTime !== "string" || !/^[0-9]+$/.test(owner.processStartTime) || owner.processStartTime === origin.processStartTime;
+  }
+  const liveness = parseLiveness(owner.liveness);
+  return liveness === null || await probeLiveness(liveness, acquisition) === "unknown";
 }
 function validateProfileName(profile) {
   if (!profile || profile === "." || profile === ".." || profile.includes("/") || profile.includes("\\") || profile.includes("\0")) {
@@ -4895,13 +5080,15 @@ 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_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, _a2, relinquishedTurns, MARKER_RETRY_DELAYS_MS, SETTLE_RETRY_MS, SETTLE_RETRIES, NO_HARD_LINK_ERRORS, ABANDONED_CLAIM, RECOVERY_CLAIM, STAGED_OWNER;
+var import_node_crypto, import_node_async_hooks, import_node_fs, import_promises, import_node_net, 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, TEST_LOCK_LIVENESS_BARRIER_DIR, invocationStateRoot, heldProfileLocks, _a2, processInstanceId, cachedProcessOrigin, LIVENESS_SOCKET, LIVENESS_PROBE_TIMEOUT_MS, ProfileLockTimeoutError, ProfileDeletedError, TURN, _a3, 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";
     import_node_crypto = require("crypto");
     import_node_async_hooks = require("async_hooks");
+    import_node_fs = require("fs");
     import_promises = require("fs/promises");
+    import_node_net = require("net");
     import_node_os = require("os");
     import_node_path = require("path");
     DEFAULT_PROFILE = "default";
@@ -4922,8 +5109,12 @@ var init_state = __esm({
     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";
+    TEST_LOCK_LIVENESS_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_LIVENESS_BARRIER_DIR";
     invocationStateRoot = processWideContext("tinycloud.operations.invocationStateRoot.v1");
     heldProfileLocks = processWideContext("tinycloud.operations.heldProfileLocks.v2");
+    processInstanceId = globalThis[_a2 = /* @__PURE__ */ Symbol.for("tinycloud.operations.profileLockInstance.v1")] ?? (globalThis[_a2] = (0, import_node_crypto.randomUUID)());
+    LIVENESS_SOCKET = /^\.live-([0-9a-f]+)-([0-9a-f]+)-[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}(\.new)?$/;
+    LIVENESS_PROBE_TIMEOUT_MS = 1e3;
     ProfileLockTimeoutError = class extends Error {
       /** `detail` names the cause when it is not simply another process holding the lock. */
       constructor(profile, timeoutMs, detail) {
@@ -4940,7 +5131,7 @@ var init_state = __esm({
       }
     };
     TURN = /^(?:0|[1-9][0-9]*)$/;
-    relinquishedTurns = globalThis[_a2 = /* @__PURE__ */ Symbol.for("tinycloud.operations.relinquishedProfileTurns.v1")] ?? (globalThis[_a2] = /* @__PURE__ */ new Set());
+    relinquishedTurns = globalThis[_a3 = /* @__PURE__ */ Symbol.for("tinycloud.operations.relinquishedProfileTurns.v1")] ?? (globalThis[_a3] = /* @__PURE__ */ new Set());
     MARKER_RETRY_DELAYS_MS = [10, 50, 250];
     SETTLE_RETRY_MS = 1e3;
     SETTLE_RETRIES = 300;
@@ -5232,6 +5423,45 @@ var init_artifacts = __esm({
   }
 });
 
+// src/recovery.ts
+function signInRecovery(profile, posture) {
+  if (!SAFE_PROFILE_TOKEN.test(profile)) return { action: "sign_in" };
+  const template = posture === "local-owner-key" ? SIGN_IN_TEMPLATES.local : posture === "delegate-session" ? SIGN_IN_TEMPLATES.scoped : SIGN_IN_TEMPLATES.openkey;
+  return { action: "sign_in", command: template(profile) };
+}
+function migrationRecovery(profile) {
+  return SAFE_PROFILE_TOKEN.test(profile) ? { action: "complete_migration", command: migrationCommand(profile), operationId: MIGRATION_OPERATION_ID } : { action: "complete_migration", operationId: MIGRATION_OPERATION_ID };
+}
+function isSafeRecovery(value, action) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  if (record.action !== action) return false;
+  const keys = Object.keys(record);
+  const allowed = action === "sign_in" ? ["action", "command"] : ["action", "command", "operationId"];
+  if (!keys.every((key) => allowed.includes(key))) return false;
+  if (action === "complete_migration" && record.operationId !== MIGRATION_OPERATION_ID) return false;
+  if (!("command" in record)) return true;
+  const command = record.command;
+  if (typeof command !== "string") return false;
+  const profile = /^tc --profile (\S+) /.exec(command)?.[1];
+  if (profile === void 0 || !SAFE_PROFILE_TOKEN.test(profile)) return false;
+  return action === "sign_in" ? Object.values(SIGN_IN_TEMPLATES).some((template) => template(profile) === command) : migrationCommand(profile) === command;
+}
+var SAFE_PROFILE_TOKEN, MIGRATION_OPERATION_ID, SIGN_IN_TEMPLATES, migrationCommand;
+var init_recovery = __esm({
+  "src/recovery.ts"() {
+    "use strict";
+    SAFE_PROFILE_TOKEN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+    MIGRATION_OPERATION_ID = "tinycloud.auth.capabilities";
+    SIGN_IN_TEMPLATES = {
+      local: (profile) => `tc --profile ${profile} auth login --method local`,
+      openkey: (profile) => `tc --profile ${profile} auth login --method openkey`,
+      scoped: (profile) => `tc --profile ${profile} auth login --method openkey --paste --manifest <manifest.json>`
+    };
+    migrationCommand = (profile) => `tc --profile ${profile} auth caps`;
+  }
+});
+
 // src/secrets.ts
 function normalizeSecretsGetInput(input) {
   const reference = resolveSecretReference(input);
@@ -5318,15 +5548,6 @@ function canonicalizeSpaceUri(space) {
   }
   return space;
 }
-function buildSecretSetupUrl(reference) {
-  const parameters = [
-    ["secret", reference.name],
-    ...reference.scope === void 0 ? [] : [["scope", reference.scope]],
-    ["space", reference.space]
-  ];
-  const query = parameters.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
-  return `${SECRET_MANAGER_BASE_URL}/app?${query}`;
-}
 function canonicalizeSecretScope(scope) {
   if (scope === void 0 || scope === "") return void 0;
   const trimmed = scope.trim();
@@ -5354,14 +5575,13 @@ function invalidSecretInput() {
     operationError("INPUT_INVALID", "The secret reference is invalid.")
   );
 }
-var nodeSdk, DEFAULT_SECRETS_SPACE, SECRET_MANAGER_BASE_URL, SECRET_NAME_RE2, RESERVED_SECRET_SCOPES;
+var nodeSdk, DEFAULT_SECRETS_SPACE, SECRET_NAME_RE2, RESERVED_SECRET_SCOPES;
 var init_secrets = __esm({
   "src/secrets.ts"() {
     "use strict";
     nodeSdk = __toESM(require("@tinycloud/node-sdk"), 1);
     init_errors2();
     DEFAULT_SECRETS_SPACE = "secrets";
-    SECRET_MANAGER_BASE_URL = "https://secrets.tinycloud.xyz";
     SECRET_NAME_RE2 = /^[A-Z][A-Z0-9_]*$/;
     RESERVED_SECRET_SCOPES = /* @__PURE__ */ new Set(["default", "global"]);
   }
@@ -5846,6 +6066,33 @@ var init_auth = __esm({
   }
 });
 
+// src/kv-failure.ts
+function kvRefusal(error) {
+  const verdict = (0, import_sdk_services2.authorizationVerdictOf)(error);
+  if (verdict === "unauthenticated") {
+    return (0, import_sdk_services2.validatedCapabilityOf)(error) === void 0 ? "auth_required" : "permission_denied";
+  }
+  return verdict === "forbidden" ? "permission_denied" : void 0;
+}
+function authorizationFailure(error, action) {
+  switch (kvRefusal(error)) {
+    case "auth_required":
+      return { status: "error", error: operationError("AUTH_REQUIRED", `Authentication is required to ${action}.`) };
+    case "permission_denied":
+      return { status: "error", error: operationError("PERMISSION_DENIED", `Permission is denied to ${action}.`) };
+    case void 0:
+      return void 0;
+  }
+}
+var import_sdk_services2;
+var init_kv_failure = __esm({
+  "src/kv-failure.ts"() {
+    "use strict";
+    import_sdk_services2 = require("@tinycloud/sdk-services");
+    init_errors2();
+  }
+});
+
 // src/operations/exploration.ts
 async function planAccountRegistryRead(context, path) {
   return [{
@@ -6213,19 +6460,6 @@ function caughtKvFailure(error, action) {
   if (error instanceof OperationInvocationError) return { status: "error", error: error.operationError };
   return authorizationFailure(error, action) ?? nodeFailure(action);
 }
-function authorizationFailure(error, action) {
-  const verdict = (0, import_sdk_services2.authorizationVerdictOf)(error);
-  if (verdict === "unauthenticated") {
-    if ((0, import_sdk_services2.validatedCapabilityOf)(error) !== void 0) {
-      return { status: "error", error: operationError("PERMISSION_DENIED", `Permission is denied to ${action}.`) };
-    }
-    return { status: "error", error: operationError("AUTH_REQUIRED", `Authentication is required to ${action}.`) };
-  }
-  if (verdict === "forbidden") {
-    return { status: "error", error: operationError("PERMISSION_DENIED", `Permission is denied to ${action}.`) };
-  }
-  return void 0;
-}
 function accountRegistryOutput(output) {
   if (Buffer.byteLength(JSON.stringify(output), "utf8") > MAX_ACCOUNT_REGISTRY_BYTES) {
     return {
@@ -6274,11 +6508,11 @@ function nodeFailure(action) {
     )
   };
 }
-var import_sdk_services2, import_zod4, MAX_KV_VALUE_BYTES, DEFAULT_KV_LIST_LIMIT, MAX_ACCOUNT_REGISTRY_RECORDS, MAX_ACCOUNT_REGISTRY_BYTES, EmptyInputSchema2, SpaceSchema, PrefixSchema, KeySchema, LimitSchema, StrongEtagSchema, ContentTypeSchema, JsonNumberSchema, JsonValueSchema, KvMetadataSchema, AccountSpaceSchema, AccountSpacesOutputSchema, AccountApplicationSchema, AccountApplicationsOutputSchema, KvListInputSchema, KvListOutputSchema, KvGetInputSchema, KvGetOutputSchema, KvPutContentSchema, KvPutCommonSchema, KvPutInputSchema, KvPutOutputSchema, KvHeadInputSchema, KvHeadOutputSchema, KvDeleteInputSchema, KvDeleteOutputSchema, AUTHENTICATED_POSTURES, EXPLORATION_EXPOSURE, ACCOUNT_SPACES_SENSITIVITY, ACCOUNT_APPLICATIONS_SENSITIVITY, KV_LIST_SENSITIVITY, KV_GET_SENSITIVITY, KV_PUT_SENSITIVITY, KV_KEY_SENSITIVITY, explorationOperationDefinitions;
+var import_zod4, MAX_KV_VALUE_BYTES, DEFAULT_KV_LIST_LIMIT, MAX_ACCOUNT_REGISTRY_RECORDS, MAX_ACCOUNT_REGISTRY_BYTES, EmptyInputSchema2, SpaceSchema, PrefixSchema, KeySchema, LimitSchema, StrongEtagSchema, ContentTypeSchema, JsonNumberSchema, JsonValueSchema, KvMetadataSchema, AccountSpaceSchema, AccountSpacesOutputSchema, AccountApplicationSchema, AccountApplicationsOutputSchema, KvListInputSchema, KvListOutputSchema, KvGetInputSchema, KvGetOutputSchema, KvPutContentSchema, KvPutCommonSchema, KvPutInputSchema, KvPutOutputSchema, KvHeadInputSchema, KvHeadOutputSchema, KvDeleteInputSchema, KvDeleteOutputSchema, AUTHENTICATED_POSTURES, EXPLORATION_EXPOSURE, ACCOUNT_SPACES_SENSITIVITY, ACCOUNT_APPLICATIONS_SENSITIVITY, KV_LIST_SENSITIVITY, KV_GET_SENSITIVITY, KV_PUT_SENSITIVITY, KV_KEY_SENSITIVITY, explorationOperationDefinitions;
 var init_exploration = __esm({
   "src/operations/exploration.ts"() {
     "use strict";
-    import_sdk_services2 = require("@tinycloud/sdk-services");
+    init_kv_failure();
     import_zod4 = require("zod");
     init_errors2();
     init_secrets();
@@ -6580,6 +6814,191 @@ var init_exploration = __esm({
   }
 });
 
+// src/secret-request.ts
+function canonicalSecretRequestOwner(did) {
+  const match = typeof did === "string" ? OWNER_RE.exec(did) : null;
+  if (match === null || !Number.isSafeInteger(Number(match[1]))) throw invalidOwner();
+  const address = match[2];
+  let checksummed;
+  try {
+    checksummed = nodeSdk3.canonicalizeAddress(address);
+  } catch {
+    throw invalidOwner();
+  }
+  if (/[A-F]/.test(address.slice(2)) && address !== checksummed) throw invalidOwner();
+  return `did:pkh:eip155:${match[1]}:${checksummed}`;
+}
+function buildSecretRequestUrl(input) {
+  const owner = canonicalSecretRequestOwner(input.owner);
+  const names = validSecretNames(input.names);
+  if (input.scope !== void 0) assertSecretRequestScope(input.scope);
+  const requester = input.requester;
+  if (requester !== void 0 && (typeof requester !== "string" || requester.length === 0 || requester.length > MAX_REQUESTER_LENGTH || CONTROL_OR_FORMAT.test(requester))) {
+    throw new SecretRequestInputError("INVALID_REQUESTER", "The requester label must be 1-64 characters with no control or format characters.");
+  }
+  if (input.returnTo !== void 0 && !isAllowedReturnTo(input.returnTo)) {
+    throw new SecretRequestInputError("INVALID_RETURN_TO", "The return address is not an allowed Secret Manager callback.");
+  }
+  if (input.state !== void 0 && !STATE_RE.test(input.state)) {
+    throw new SecretRequestInputError("INVALID_STATE", "The state must be 1-128 characters of A-Z, a-z, 0-9, '.', '_', '~' or '-'.");
+  }
+  const parameters = [
+    ["owner", owner],
+    ...names.map((name) => ["name", name]),
+    ...input.scope === void 0 ? [] : [["scope", input.scope]],
+    ...input.requester === void 0 ? [] : [["requester", input.requester]],
+    ...input.returnTo === void 0 ? [] : [["return_to", input.returnTo]],
+    ...input.state === void 0 ? [] : [["state", input.state]],
+    ["v", "1"]
+  ];
+  const url = `${SECRET_MANAGER_ORIGIN}/request?${parameters.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&")}`;
+  if (url.length > SECRET_REQUEST_MAX_URL_LENGTH) {
+    throw new SecretRequestInputError("REQUEST_LINK_TOO_LONG", `The request link is longer than ${SECRET_REQUEST_MAX_URL_LENGTH} characters.`);
+  }
+  return { url, owner, names, ...input.scope === void 0 ? {} : { scope: input.scope } };
+}
+function secretSetupFor(link2) {
+  return {
+    url: link2.url,
+    names: [...link2.names],
+    ...link2.scope === void 0 ? {} : { scope: link2.scope },
+    owner: link2.owner,
+    action: "add_secret"
+  };
+}
+function resolveSecretsOwner(profile, requestedOwner) {
+  const resolved = profile.local ? ownerOrUndefined(profile.principalDid) : ownerOrUndefined(profile.ownerDid) ?? (profile.posture === "delegate-session" ? ownerOfSpace(profile.space) : void 0) ?? ownerOrUndefined(profile.principalDid);
+  const requested = requestedOwner === void 0 ? void 0 : ownerOrUndefined(requestedOwner);
+  if (resolved !== void 0) {
+    if (requestedOwner !== void 0 && requested !== resolved) {
+      return {
+        ok: false,
+        code: "OWNER_MISMATCH",
+        message: "The requested owner is not the owner of this identity's secrets."
+      };
+    }
+    return { ok: true, owner: resolved, local: profile.local };
+  }
+  if (requested !== void 0 && !profile.local) return { ok: true, owner: requested, local: false };
+  return {
+    ok: false,
+    code: "OWNER_DID_UNKNOWN",
+    message: "The owner of this identity's secrets is unknown. Pass the owner's did:pkh with --owner."
+  };
+}
+function missingSecretRecovery(input) {
+  if (input.local) {
+    return { kind: "put_locally", hint: `Store it with: ${putCommands(input.names, input.scope)}` };
+  }
+  if (input.owner !== void 0) {
+    try {
+      return {
+        kind: "add_secret",
+        setup: secretSetupFor(buildSecretRequestUrl({
+          owner: input.owner,
+          names: input.names,
+          ...input.scope === void 0 ? {} : { scope: input.scope }
+        }))
+      };
+    } catch {
+    }
+  }
+  return {
+    kind: "not_requestable",
+    hint: `No Secret Manager request link can express this secret. The owner can store it with: ${putCommands(input.names, input.scope)}`
+  };
+}
+function isValidSecretRequestScope(scope) {
+  return scope.length <= MAX_SCOPE_LENGTH && SCOPE_RE.test(scope) && !RESERVED_SCOPES.includes(scope);
+}
+function isValidSecretName(name) {
+  return name.length <= MAX_NAME_LENGTH && NAME_RE.test(name);
+}
+function validSecretNames(names) {
+  for (const name of names) assertSecretName(name);
+  const unique = dedupe(names);
+  if (unique.length === 0) {
+    throw new SecretRequestInputError("INVALID_SECRET_NAME", "At least one secret name is required.");
+  }
+  if (unique.length > SECRET_REQUEST_MAX_NAMES) {
+    throw new SecretRequestInputError("TOO_MANY_SECRET_NAMES", `At most ${SECRET_REQUEST_MAX_NAMES} secret names can be requested at once.`);
+  }
+  return unique;
+}
+function assertSecretName(name) {
+  if (typeof name !== "string" || !isValidSecretName(name)) {
+    throw new SecretRequestInputError("INVALID_SECRET_NAME", "Secret names are 1-64 characters of A-Z, 0-9 and '_', starting with a letter.");
+  }
+}
+function assertSecretRequestScope(scope) {
+  if (typeof scope !== "string" || !isValidSecretRequestScope(scope)) {
+    throw new SecretRequestInputError("INVALID_SECRET_SCOPE", "The scope must be a canonical scope of at most 64 characters, not default, global or scoped.");
+  }
+}
+function isAllowedReturnTo(returnTo) {
+  if (typeof returnTo !== "string" || returnTo.length > MAX_RETURN_TO_LENGTH) return false;
+  let url;
+  try {
+    url = new URL(returnTo);
+  } catch {
+    return false;
+  }
+  if (url.username !== "" || url.password !== "") return false;
+  return RETURN_TO_ORIGINS.includes(url.origin) || RETURN_TO_PREVIEW.test(url.origin);
+}
+function ownerOrUndefined(did) {
+  if (did === void 0) return void 0;
+  try {
+    return canonicalSecretRequestOwner(did);
+  } catch {
+    return void 0;
+  }
+}
+function ownerOfSpace(space) {
+  const match = space === void 0 ? null : PKH_SPACE_RE.exec(space);
+  if (match === null) return void 0;
+  return ownerOrUndefined(`did:pkh:eip155:${match[1]}:${match[2].toLowerCase()}`);
+}
+function putCommands(names, scope) {
+  return dedupe(names).map((name) => `tc secrets put ${name}${scope === void 0 ? "" : ` --scope ${scope}`} --stdin`).join("; ");
+}
+function dedupe(names) {
+  return [...new Set(names)];
+}
+function invalidOwner() {
+  return new SecretRequestInputError("INVALID_OWNER", "The owner must be a did:pkh:eip155 account with a valid EIP-55 address.");
+}
+var nodeSdk3, SECRET_MANAGER_ORIGIN, SECRET_REQUEST_MAX_NAMES, SECRET_REQUEST_MAX_URL_LENGTH, OWNER_RE, NAME_RE, MAX_NAME_LENGTH, SCOPE_RE, MAX_SCOPE_LENGTH, RESERVED_SCOPES, MAX_REQUESTER_LENGTH, CONTROL_OR_FORMAT, STATE_RE, MAX_RETURN_TO_LENGTH, RETURN_TO_ORIGINS, RETURN_TO_PREVIEW, PKH_SPACE_RE, SecretRequestInputError;
+var init_secret_request = __esm({
+  "src/secret-request.ts"() {
+    "use strict";
+    nodeSdk3 = __toESM(require("@tinycloud/node-sdk"), 1);
+    SECRET_MANAGER_ORIGIN = "https://secrets.tinycloud.xyz";
+    SECRET_REQUEST_MAX_NAMES = 10;
+    SECRET_REQUEST_MAX_URL_LENGTH = 8192;
+    OWNER_RE = /^did:pkh:eip155:([1-9][0-9]*):(0x[0-9a-fA-F]{40})$/;
+    NAME_RE = /^[A-Z][A-Z0-9_]*$/;
+    MAX_NAME_LENGTH = 64;
+    SCOPE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+    MAX_SCOPE_LENGTH = 64;
+    RESERVED_SCOPES = ["default", "global", "scoped"];
+    MAX_REQUESTER_LENGTH = 64;
+    CONTROL_OR_FORMAT = /[\p{Cc}\p{Cf}]/u;
+    STATE_RE = /^[A-Za-z0-9._~-]{1,128}$/;
+    MAX_RETURN_TO_LENGTH = 2048;
+    RETURN_TO_ORIGINS = ["https://feed.tinycloud.xyz"];
+    RETURN_TO_PREVIEW = /^https:\/\/[a-z0-9-]+\.tinyfeed\.pages\.dev$/;
+    PKH_SPACE_RE = /^tinycloud:pkh:eip155:([1-9][0-9]*):(0x[0-9a-fA-F]{40}):[^:]+$/;
+    SecretRequestInputError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.name = "SecretRequestInputError";
+        this.code = code;
+      }
+    };
+  }
+});
+
 // src/operations/secrets-get.ts
 async function planSecretGet(context, input) {
   const reference = resolveSecretReferenceForOperation(
@@ -6646,27 +7065,14 @@ async function executeSecretGet(context, input) {
       )
     };
   }
-  return classifySecretRead(reference, result);
+  return classifySecretRead(reference, result, context.runtime?.localOwner === true);
 }
-function classifySecretRead(reference, result) {
+function classifySecretRead(reference, result, localOwner) {
   switch (result.status) {
     case "ok":
       return { status: "ok", output: { value: result.value } };
     case "not_found":
-      return {
-        status: "setup_required",
-        setup: {
-          kind: "secret_manager",
-          secret: {
-            name: reference.name,
-            ...reference.scope === void 0 ? {} : { scope: reference.scope },
-            space: reference.space
-          },
-          url: buildSecretSetupUrl(reference),
-          message: "Enter this secret in Secret Manager, then retry the operation."
-        },
-        requiresCallerInput: true
-      };
+      return missingSecretOutcome(reference, localOwner);
     case "permission_required":
       return {
         status: "authority_required",
@@ -6711,6 +7117,47 @@ function classifySecretRead(reference, result) {
     error: operationError("SECRET_READ_FAILED", "The secret read failed.")
   };
 }
+function missingSecretOutcome(reference, localOwner) {
+  const owner = ownerOfSpace(reference.space);
+  const recovery = missingSecretRecovery({
+    owner,
+    local: localOwner,
+    names: [reference.name],
+    ...reference.scope === void 0 ? {} : { scope: reference.scope }
+  });
+  if (recovery.kind === "add_secret") {
+    const { setup } = recovery;
+    return {
+      status: "setup_required",
+      setup: {
+        kind: "secret_manager",
+        action: setup.action,
+        url: setup.url,
+        names: setup.names,
+        ...setup.scope === void 0 ? {} : { scope: setup.scope },
+        owner: setup.owner,
+        secret: {
+          name: reference.name,
+          ...reference.scope === void 0 ? {} : { scope: reference.scope },
+          space: reference.space
+        },
+        message: "Ask the owner to add this secret in Secret Manager, then retry the operation."
+      },
+      requiresCallerInput: true
+    };
+  }
+  return {
+    status: "error",
+    error: operationError("KV_NOT_FOUND", recovery.hint, {
+      details: {
+        names: [reference.name],
+        ...reference.scope === void 0 ? {} : { scope: reference.scope },
+        ...owner === void 0 ? {} : { owner },
+        recoveryKind: recovery.kind
+      }
+    })
+  };
+}
 function resolveEncryptionNetworkId(node, space) {
   const candidate = node;
   let scoped;
@@ -6738,6 +7185,7 @@ var init_secrets_get = __esm({
     "use strict";
     import_zod5 = require("zod");
     init_errors2();
+    init_secret_request();
     init_secrets();
     SecretsGetInputSchema = import_zod5.z.object({
       name: import_zod5.z.string(),
@@ -6789,6 +7237,194 @@ var init_secrets_get = __esm({
   }
 });
 
+// src/operations/secrets-status.ts
+async function executeSecretsStatus(context, input) {
+  const runtime = context.runtime;
+  const node = runtime?.node;
+  if (runtime === void 0 || typeof node?.kvForSpace !== "function") {
+    return {
+      status: "error",
+      error: operationError("NODE_ERROR", "The TinyCloud node could not check the secrets.", { retryable: true })
+    };
+  }
+  const local = runtime.localOwner === true;
+  const resolution = resolveSecretsOwner({
+    local,
+    posture: context.summary.posture,
+    ...context.summary.ownerDid === void 0 ? {} : { ownerDid: context.summary.ownerDid },
+    ...context.summary.principalDid === void 0 ? {} : { principalDid: context.summary.principalDid },
+    ...context.summary.space === void 0 ? {} : { space: context.summary.space }
+  }, input.owner);
+  if (!resolution.ok) {
+    return {
+      status: "error",
+      error: operationError("INPUT_INVALID", resolution.message, { details: { reason: resolution.code } })
+    };
+  }
+  const owner = resolution.owner;
+  const skipped2 = runtime.skippedGrantReasons ?? [];
+  const pkh = nodeSdk4.parsePkhDid(owner);
+  const kv = node.kvForSpace(nodeSdk4.makePkhSpaceId(pkh.address, pkh.chainId, "secrets"));
+  const outcomes = await Promise.all(input.names.map(async (name) => {
+    const path = input.scope === void 0 ? `vault/secrets/${name}` : `vault/secrets/scoped/${input.scope}/${name}`;
+    try {
+      const result = await kv.get(path, { raw: true, prefix: "", timeout: PROBE_TIMEOUT_MS });
+      if (result.ok) return "present";
+      const error = result.error;
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "KV_NOT_FOUND") {
+        return "pending";
+      }
+      const refusal = kvRefusal(error);
+      if (refusal === "auth_required") return "auth_required";
+      if (refusal === "permission_denied") return "denied";
+      return "unreachable";
+    } catch {
+      return "unreachable";
+    }
+  }));
+  const namesWith = (outcome) => input.names.filter((_, index) => outcomes[index] === outcome);
+  const present = namesWith("present");
+  const pending = namesWith("pending");
+  const denied = namesWith("denied");
+  if (present.length + pending.length < input.names.length) {
+    if (outcomes.includes("auth_required") || skipped2.includes("activation_unauthenticated")) {
+      return {
+        status: "error",
+        error: operationError(
+          "AUTH_REQUIRED",
+          "The node did not accept this profile's stored session. Sign in again, then retry.",
+          { retryable: false, details: { recovery: signInRecovery(context.summary.profile, context.summary.posture) } }
+        )
+      };
+    }
+    if (outcomes.includes("unreachable") || skipped2.includes("activation_unavailable")) {
+      return {
+        status: "error",
+        error: operationError("NODE_UNREACHABLE", "The TinyCloud node could not be reached.", { retryable: true })
+      };
+    }
+  }
+  const recovery = pending.length === 0 ? void 0 : missingSecretRecovery({
+    owner,
+    local,
+    names: pending,
+    ...input.scope === void 0 ? {} : { scope: input.scope }
+  });
+  return {
+    status: "ok",
+    output: {
+      status: denied.length > 0 ? "consent_required" : pending.length > 0 ? "pending" : "ready",
+      owner,
+      names: [...input.names],
+      ...input.scope === void 0 ? {} : { scope: input.scope },
+      present,
+      pending,
+      denied,
+      ...recovery === void 0 ? {} : recovery.kind === "add_secret" ? { setup: recovery.setup } : { hint: recovery.hint }
+    }
+  };
+}
+var import_zod6, nodeSdk4, PROBE_TIMEOUT_MS, SECRETS_STATUS_DEADLINE_MS, SecretsStatusInputSchema, SecretSetupSchema, SecretsStatusOutputSchema, SECRETS_STATUS_POSTURES, SECRETS_STATUS_EXPOSURE, SECRETS_STATUS_SENSITIVITY, secretsStatusOperationDefinition, secretsStatusOperationDefinitions;
+var init_secrets_status = __esm({
+  "src/operations/secrets-status.ts"() {
+    "use strict";
+    import_zod6 = require("zod");
+    nodeSdk4 = __toESM(require("@tinycloud/node-sdk"), 1);
+    init_errors2();
+    init_kv_failure();
+    init_recovery();
+    init_secret_request();
+    init_secrets();
+    PROBE_TIMEOUT_MS = 15e3;
+    SECRETS_STATUS_DEADLINE_MS = 18e3;
+    SecretsStatusInputSchema = import_zod6.z.object({
+      names: import_zod6.z.array(import_zod6.z.string()),
+      scope: import_zod6.z.string().optional(),
+      owner: import_zod6.z.string().optional()
+    }).strict().superRefine((input, context) => {
+      try {
+        validSecretNames(input.names);
+      } catch {
+        context.addIssue({ code: import_zod6.z.ZodIssueCode.custom, path: ["names"], message: "Invalid secret names." });
+      }
+      try {
+        const scope = canonicalizeSecretScope(input.scope);
+        if (scope !== void 0 && !isValidSecretRequestScope(scope)) throw new Error("invalid scope");
+      } catch {
+        context.addIssue({ code: import_zod6.z.ZodIssueCode.custom, path: ["scope"], message: "Invalid secret scope." });
+      }
+      if (input.owner !== void 0) {
+        try {
+          canonicalSecretRequestOwner(input.owner);
+        } catch {
+          context.addIssue({ code: import_zod6.z.ZodIssueCode.custom, path: ["owner"], message: "Invalid owner." });
+        }
+      }
+    }).transform((input) => {
+      const scope = canonicalizeSecretScope(input.scope);
+      return {
+        names: validSecretNames(input.names),
+        ...scope === void 0 ? {} : { scope },
+        ...input.owner === void 0 ? {} : { owner: canonicalSecretRequestOwner(input.owner) }
+      };
+    });
+    SecretSetupSchema = import_zod6.z.object({
+      url: import_zod6.z.string().url(),
+      names: import_zod6.z.array(import_zod6.z.string()).min(1),
+      scope: import_zod6.z.string().optional(),
+      owner: import_zod6.z.string(),
+      action: import_zod6.z.literal("add_secret")
+    }).strict();
+    SecretsStatusOutputSchema = import_zod6.z.object({
+      status: import_zod6.z.enum(["ready", "pending", "consent_required"]),
+      owner: import_zod6.z.string(),
+      names: import_zod6.z.array(import_zod6.z.string()).min(1),
+      scope: import_zod6.z.string().optional(),
+      present: import_zod6.z.array(import_zod6.z.string()),
+      pending: import_zod6.z.array(import_zod6.z.string()),
+      denied: import_zod6.z.array(import_zod6.z.string()),
+      setup: SecretSetupSchema.optional(),
+      hint: import_zod6.z.string().optional()
+    }).strict();
+    SECRETS_STATUS_POSTURES = [
+      "owner-openkey",
+      "delegate-session",
+      "local-owner-key"
+    ];
+    SECRETS_STATUS_EXPOSURE = {
+      cli: { status: "required" },
+      mcp: { status: "required" },
+      skill: { status: "required" },
+      docs: { status: "required" }
+    };
+    SECRETS_STATUS_SENSITIVITY = {
+      input: [],
+      output: []
+    };
+    secretsStatusOperationDefinition = {
+      id: "tinycloud.secrets.status",
+      version: 1,
+      title: "Check whether TinyCloud secrets exist",
+      description: "Report, without reading any value, which named secrets exist in the owner's secrets space: ready, pending (with a Secret Manager request link), or consent_required for names this identity may not read. Each name needs tinycloud.kv/get; this operation never requests it. It never signs in: it uses only the profile's stored session, and writes no profile state.",
+      input: SecretsStatusInputSchema,
+      output: SecretsStatusOutputSchema,
+      effects: ["read"],
+      runtime: "restored",
+      postures: SECRETS_STATUS_POSTURES,
+      exposure: SECRETS_STATUS_EXPOSURE,
+      sensitivity: SECRETS_STATUS_SENSITIVITY,
+      deadlineMs: SECRETS_STATUS_DEADLINE_MS,
+      // Never evaluated against the session: a missing grant is reported as
+      // `consent_required`, never saved as an authority request.
+      authority: async () => [],
+      execute: executeSecretsStatus
+    };
+    secretsStatusOperationDefinitions = [
+      secretsStatusOperationDefinition
+    ];
+  }
+});
+
 // src/operations/sql.ts
 async function planSqlRead(context, input) {
   const space = resolveSqlSpace(context, input.space);
@@ -7101,15 +7737,15 @@ function isByte(value) {
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var import_node_sql_parser, import_zod6, DEFAULT_MAX_ROWS, MAX_MAX_ROWS, DEFAULT_MAX_BYTES, MAX_MAX_BYTES, SCHEMA_MAX_ROWS, SCHEMA_MAX_BYTES, MAX_PARAMETERS, MAX_SQL_LENGTH, SQL_WRITE_AUTHORITY_NOTICE, SCHEMA_QUERY, sqlParser, SpaceSchema2, DatabaseSchema, SafeNumberSchema, Base64Schema, SqlInputValueSchema, SqlParamsSchema, RequiredSqlParamsSchema, SqlOutputValueSchema, SqlTargetInputSchema, SqlQueryInputSchema, SqlExecuteInputSchema, SqlLimitsOutputSchema, SqlSchemaInspectOutputSchema, SqlQueryOutputSchema, SqlExecuteOutputSchema, AUTHENTICATED_POSTURES2, SQL_EXPOSURE, SQL_SCHEMA_SENSITIVITY, SQL_QUERY_SENSITIVITY, SQL_EXECUTE_SENSITIVITY, sqlOperationDefinitions;
+var import_node_sql_parser, import_zod7, DEFAULT_MAX_ROWS, MAX_MAX_ROWS, DEFAULT_MAX_BYTES, MAX_MAX_BYTES, SCHEMA_MAX_ROWS, SCHEMA_MAX_BYTES, MAX_PARAMETERS, MAX_SQL_LENGTH, SQL_WRITE_AUTHORITY_NOTICE, SCHEMA_QUERY, sqlParser, SpaceSchema2, DatabaseSchema, SafeNumberSchema, Base64Schema, SqlInputValueSchema, SqlParamsSchema, RequiredSqlParamsSchema, SqlOutputValueSchema, SqlTargetInputSchema, SqlQueryInputSchema, SqlExecuteInputSchema, SqlLimitsOutputSchema, SqlSchemaInspectOutputSchema, SqlQueryOutputSchema, SqlExecuteOutputSchema, AUTHENTICATED_POSTURES2, SQL_EXPOSURE, SQL_SCHEMA_SENSITIVITY, SQL_QUERY_SENSITIVITY, SQL_EXECUTE_SENSITIVITY, sqlOperationDefinitions;
 var init_sql = __esm({
   "src/operations/sql.ts"() {
     "use strict";
     import_node_sql_parser = __toESM(require("node-sql-parser"), 1);
-    import_zod6 = require("zod");
+    import_zod7 = require("zod");
     init_errors2();
     init_secrets();
-    init_exploration();
+    init_kv_failure();
     DEFAULT_MAX_ROWS = 100;
     MAX_MAX_ROWS = 1e3;
     DEFAULT_MAX_BYTES = 1024 * 1024;
@@ -7125,29 +7761,29 @@ WHERE type IN ('table', 'view', 'index', 'trigger')
   AND name NOT LIKE 'sqlite_%'
 ORDER BY type, name`;
     sqlParser = new import_node_sql_parser.default.Parser();
-    SpaceSchema2 = import_zod6.z.string().min(1).refine(
+    SpaceSchema2 = import_zod7.z.string().min(1).refine(
       (space) => (/^[A-Za-z0-9_-]+$/.test(space) || space.startsWith("tinycloud:")) && !space.includes("*"),
       "Invalid TinyCloud space."
     );
-    DatabaseSchema = import_zod6.z.string().min(1).max(256).refine(
+    DatabaseSchema = import_zod7.z.string().min(1).max(256).refine(
       (database) => database !== "/" && !database.endsWith("/") && !database.includes("*") && !/[\u0000-\u001f\u007f]/.test(database),
       "Invalid SQLite database name."
     );
-    SafeNumberSchema = import_zod6.z.number().finite().refine(
+    SafeNumberSchema = import_zod7.z.number().finite().refine(
       (value) => !Number.isInteger(value) || Number.isSafeInteger(value),
       "SQLite integer parameters must be JavaScript safe integers."
     );
-    Base64Schema = import_zod6.z.string().max(Math.ceil(MAX_MAX_BYTES / 3) * 4).refine(
+    Base64Schema = import_zod7.z.string().max(Math.ceil(MAX_MAX_BYTES / 3) * 4).refine(
       isCanonicalBase642,
       "Invalid base64 BLOB value."
     );
-    SqlInputValueSchema = import_zod6.z.union([
-      import_zod6.z.null(),
+    SqlInputValueSchema = import_zod7.z.union([
+      import_zod7.z.null(),
       SafeNumberSchema,
-      import_zod6.z.string().max(MAX_MAX_BYTES),
-      import_zod6.z.object({ type: import_zod6.z.literal("blob"), base64: Base64Schema }).strict()
+      import_zod7.z.string().max(MAX_MAX_BYTES),
+      import_zod7.z.object({ type: import_zod7.z.literal("blob"), base64: Base64Schema }).strict()
     ]);
-    SqlParamsSchema = import_zod6.z.array(SqlInputValueSchema).max(MAX_PARAMETERS).superRefine(
+    SqlParamsSchema = import_zod7.z.array(SqlInputValueSchema).max(MAX_PARAMETERS).superRefine(
       (params, context) => {
         const totalBytes = params.reduce(
           (total, value) => total + sqlInputValueBytes(value),
@@ -7155,13 +7791,13 @@ ORDER BY type, name`;
         );
         if (totalBytes > MAX_MAX_BYTES) {
           context.addIssue({
-            code: import_zod6.z.ZodIssueCode.custom,
+            code: import_zod7.z.ZodIssueCode.custom,
             message: "SQLite query parameters exceed the 4 MiB input limit."
           });
         }
       }
     );
-    RequiredSqlParamsSchema = import_zod6.z.array(SqlInputValueSchema).min(1).max(MAX_PARAMETERS).superRefine(
+    RequiredSqlParamsSchema = import_zod7.z.array(SqlInputValueSchema).min(1).max(MAX_PARAMETERS).superRefine(
       (params, context) => {
         const totalBytes = params.reduce(
           (total, value) => total + sqlInputValueBytes(value),
@@ -7169,88 +7805,88 @@ ORDER BY type, name`;
         );
         if (totalBytes > MAX_MAX_BYTES) {
           context.addIssue({
-            code: import_zod6.z.ZodIssueCode.custom,
+            code: import_zod7.z.ZodIssueCode.custom,
             message: "SQLite query parameters exceed the 4 MiB input limit."
           });
         }
       }
     );
-    SqlOutputValueSchema = import_zod6.z.union([
-      import_zod6.z.null(),
+    SqlOutputValueSchema = import_zod7.z.union([
+      import_zod7.z.null(),
       SafeNumberSchema,
-      import_zod6.z.string(),
-      import_zod6.z.object({
-        type: import_zod6.z.literal("blob"),
-        base64: import_zod6.z.string(),
-        byteLength: import_zod6.z.number().int().nonnegative()
+      import_zod7.z.string(),
+      import_zod7.z.object({
+        type: import_zod7.z.literal("blob"),
+        base64: import_zod7.z.string(),
+        byteLength: import_zod7.z.number().int().nonnegative()
       }).strict()
     ]);
-    SqlTargetInputSchema = import_zod6.z.object({
+    SqlTargetInputSchema = import_zod7.z.object({
       space: SpaceSchema2,
       database: DatabaseSchema
     }).strict();
-    SqlQueryInputSchema = import_zod6.z.object({
+    SqlQueryInputSchema = import_zod7.z.object({
       space: SpaceSchema2,
       database: DatabaseSchema,
-      sql: import_zod6.z.string().min(1).max(MAX_SQL_LENGTH).superRefine((sql, context) => {
+      sql: import_zod7.z.string().min(1).max(MAX_SQL_LENGTH).superRefine((sql, context) => {
         if (!isSingleReadQuery(sql)) {
           context.addIssue({
-            code: import_zod6.z.ZodIssueCode.custom,
+            code: import_zod7.z.ZodIssueCode.custom,
             message: "SQL must parse as exactly one SQLite SELECT statement."
           });
         }
       }),
       params: SqlParamsSchema.optional(),
-      maxRows: import_zod6.z.number().int().positive().max(MAX_MAX_ROWS).optional(),
-      maxBytes: import_zod6.z.number().int().positive().max(MAX_MAX_BYTES).optional()
+      maxRows: import_zod7.z.number().int().positive().max(MAX_MAX_ROWS).optional(),
+      maxBytes: import_zod7.z.number().int().positive().max(MAX_MAX_BYTES).optional()
     }).strict();
-    SqlExecuteInputSchema = import_zod6.z.object({
+    SqlExecuteInputSchema = import_zod7.z.object({
       space: SpaceSchema2,
       database: DatabaseSchema,
-      sql: import_zod6.z.string().min(1).max(MAX_SQL_LENGTH),
+      sql: import_zod7.z.string().min(1).max(MAX_SQL_LENGTH),
       params: RequiredSqlParamsSchema,
-      acknowledgeDatabaseWideAuthority: import_zod6.z.literal(true).describe(SQL_WRITE_AUTHORITY_NOTICE)
+      acknowledgeDatabaseWideAuthority: import_zod7.z.literal(true).describe(SQL_WRITE_AUTHORITY_NOTICE)
     }).strict().superRefine((input, context) => {
       if (parseSingleDmlStatement(input.sql, input.params.length) === void 0) {
         context.addIssue({
-          code: import_zod6.z.ZodIssueCode.custom,
+          code: import_zod7.z.ZodIssueCode.custom,
           path: ["sql"],
           message: "SQL must parse as exactly one parameterized INSERT, UPDATE, or DELETE with one value per positional placeholder."
         });
       }
     });
-    SqlLimitsOutputSchema = import_zod6.z.object({
-      maxRows: import_zod6.z.number().int().positive(),
-      maxBytes: import_zod6.z.number().int().positive(),
-      enforcement: import_zod6.z.literal("node-requested-client-verified")
+    SqlLimitsOutputSchema = import_zod7.z.object({
+      maxRows: import_zod7.z.number().int().positive(),
+      maxBytes: import_zod7.z.number().int().positive(),
+      enforcement: import_zod7.z.literal("node-requested-client-verified")
     }).strict();
-    SqlSchemaInspectOutputSchema = import_zod6.z.object({
-      space: import_zod6.z.string().min(1),
-      database: import_zod6.z.string().min(1),
-      objects: import_zod6.z.array(import_zod6.z.object({
-        type: import_zod6.z.enum(["table", "view", "index", "trigger"]),
-        name: import_zod6.z.string().min(1),
-        tableName: import_zod6.z.string().min(1),
-        sql: import_zod6.z.string().optional()
+    SqlSchemaInspectOutputSchema = import_zod7.z.object({
+      space: import_zod7.z.string().min(1),
+      database: import_zod7.z.string().min(1),
+      objects: import_zod7.z.array(import_zod7.z.object({
+        type: import_zod7.z.enum(["table", "view", "index", "trigger"]),
+        name: import_zod7.z.string().min(1),
+        tableName: import_zod7.z.string().min(1),
+        sql: import_zod7.z.string().optional()
       }).strict()),
-      count: import_zod6.z.number().int().nonnegative(),
+      count: import_zod7.z.number().int().nonnegative(),
       limits: SqlLimitsOutputSchema
     }).strict();
-    SqlQueryOutputSchema = import_zod6.z.object({
-      space: import_zod6.z.string().min(1),
-      database: import_zod6.z.string().min(1),
-      columns: import_zod6.z.array(import_zod6.z.string()),
-      rows: import_zod6.z.array(import_zod6.z.array(SqlOutputValueSchema)),
-      rowCount: import_zod6.z.number().int().nonnegative(),
+    SqlQueryOutputSchema = import_zod7.z.object({
+      space: import_zod7.z.string().min(1),
+      database: import_zod7.z.string().min(1),
+      columns: import_zod7.z.array(import_zod7.z.string()),
+      rows: import_zod7.z.array(import_zod7.z.array(SqlOutputValueSchema)),
+      rowCount: import_zod7.z.number().int().nonnegative(),
       limits: SqlLimitsOutputSchema
     }).strict();
-    SqlExecuteOutputSchema = import_zod6.z.object({
-      space: import_zod6.z.string().min(1),
-      database: import_zod6.z.string().min(1),
-      statementType: import_zod6.z.enum(["insert", "update", "delete"]),
-      changes: import_zod6.z.number().int().nonnegative(),
-      lastInsertRowId: import_zod6.z.number().int().nullable(),
-      authorityNotice: import_zod6.z.literal(SQL_WRITE_AUTHORITY_NOTICE)
+    SqlExecuteOutputSchema = import_zod7.z.object({
+      space: import_zod7.z.string().min(1),
+      database: import_zod7.z.string().min(1),
+      statementType: import_zod7.z.enum(["insert", "update", "delete"]),
+      changes: import_zod7.z.number().int().nonnegative(),
+      lastInsertRowId: import_zod7.z.number().int().nullable(),
+      authorityNotice: import_zod7.z.literal(SQL_WRITE_AUTHORITY_NOTICE)
     }).strict();
     AUTHENTICATED_POSTURES2 = [
       "owner-openkey",
@@ -7350,6 +7986,8 @@ var init_contract = __esm({
       "resources_mismatch",
       "unsupported",
       "activation_rejected",
+      "activation_unavailable",
+      "activation_unauthenticated",
       "invalid"
     ];
     DELEGATION_CID_PATTERN = "^bafkr4i[a-z2-7]{52}$";
@@ -7452,6 +8090,9 @@ function skipped(reason) {
 }
 async function replayProfileDelegations(profile, node, options) {
   await prepareStoredDelegationReplay(profile, node, { host: options.host, migrate: options.migrate });
+  return replayStoredDelegationRecords(profile, node, options);
+}
+async function replayStoredDelegationRecords(profile, node, options) {
   const installed = [];
   const warnings = [];
   const seen = /* @__PURE__ */ new Set();
@@ -7492,7 +8133,7 @@ function storedDelegationForAnotherKey(entry, node) {
   const audience = verifiedCompactAudience(node, delegation);
   if (audience === void 0) return false;
   try {
-    return nodeSdk3.principalDidEquals(delegation.delegateDID, audience) && !nodeSdk3.principalDidEquals(audience, node.sessionDid);
+    return nodeSdk5.principalDidEquals(delegation.delegateDID, audience) && !nodeSdk5.principalDidEquals(audience, node.sessionDid);
   } catch {
     return false;
   }
@@ -7526,7 +8167,7 @@ async function assess(node, entry, options, mode) {
   let outsideRequest = false;
   let effectivePermissions;
   try {
-    const installed = await nodeSdk3.activateValidatedRuntimeDelegation(node, toActivate, {
+    const installed = await nodeSdk5.activateValidatedRuntimeDelegation(node, toActivate, {
       host: options.host,
       authorize: (effective) => {
         verifyCompactProof(toActivate);
@@ -7558,7 +8199,7 @@ function verifyCompactProof(delegation) {
   try {
     parseSignedCompactUcanAttenuation(withoutBearer(authorization), delegation.cid);
   } catch {
-    throw new nodeSdk3.RuntimeDelegationRejectedError("proof_invalid", "The compact delegation proof is invalid.");
+    throw new nodeSdk5.RuntimeDelegationRejectedError("proof_invalid", "The compact delegation proof is invalid.");
   }
 }
 function rejectionReason(error) {
@@ -7575,7 +8216,7 @@ async function bindingMigrationRecorded(profile) {
 async function signedCapabilities(node, delegation, host) {
   let signed;
   try {
-    await nodeSdk3.activateValidatedRuntimeDelegation(node, delegation, {
+    await nodeSdk5.activateValidatedRuntimeDelegation(node, delegation, {
       // The transport host is not signed authority; check it at replay instead.
       host: delegation.host ?? host,
       authorize: (effective) => {
@@ -7610,13 +8251,13 @@ function recordKey(entry) {
 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, NOT_REPLAYED, DELEGATION_CID;
+var import_node_path2, nodeSdk5, REQUEST_ID_PREFIX, BINDING_NOTES, MIGRATION_LOCK_TIMEOUT_MS, NOT_REPLAYED, DELEGATION_CID;
 var init_delegation_binding = __esm({
   "src/delegation-binding.ts"() {
     "use strict";
     import_node_path2 = require("path");
     init_operations_bundle();
-    nodeSdk3 = __toESM(require("@tinycloud/node-sdk"), 1);
+    nodeSdk5 = __toESM(require("@tinycloud/node-sdk"), 1);
     init_artifacts();
     init_authority();
     init_contract();
@@ -7757,35 +8398,35 @@ function profileNotFound(profile) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var import_zod7, StatusInputSchema, StatusOutputSchema, STATUS_POSTURES, STATUS_EXPOSURE, STATUS_SENSITIVITY, statusOperationDefinitions;
+var import_zod8, StatusInputSchema, StatusOutputSchema, STATUS_POSTURES, STATUS_EXPOSURE, STATUS_SENSITIVITY, statusOperationDefinitions;
 var init_status = __esm({
   "src/operations/status.ts"() {
     "use strict";
-    import_zod7 = require("zod");
+    import_zod8 = require("zod");
     init_delegation_binding();
     init_errors2();
     init_state();
-    StatusInputSchema = import_zod7.z.object({}).strict();
-    StatusOutputSchema = import_zod7.z.object({
-      profile: import_zod7.z.string().min(1),
-      host: import_zod7.z.string().min(1),
-      posture: import_zod7.z.enum([
+    StatusInputSchema = import_zod8.z.object({}).strict();
+    StatusOutputSchema = import_zod8.z.object({
+      profile: import_zod8.z.string().min(1),
+      host: import_zod8.z.string().min(1),
+      posture: import_zod8.z.enum([
         "owner-openkey",
         "delegate-session",
         "local-owner-key",
         "unauthenticated"
       ]),
-      operatorType: import_zod7.z.enum(["human", "agent"]).optional(),
-      principalDid: import_zod7.z.string().min(1).optional(),
-      sessionDid: import_zod7.z.string().min(1).optional(),
-      ownerDid: import_zod7.z.string().min(1).optional(),
-      space: import_zod7.z.string().min(1).optional(),
-      session: import_zod7.z.object({
-        present: import_zod7.z.boolean(),
-        expired: import_zod7.z.boolean().nullable(),
-        expiresAt: import_zod7.z.string().datetime({ offset: true }).nullable()
+      operatorType: import_zod8.z.enum(["human", "agent"]).optional(),
+      principalDid: import_zod8.z.string().min(1).optional(),
+      sessionDid: import_zod8.z.string().min(1).optional(),
+      ownerDid: import_zod8.z.string().min(1).optional(),
+      space: import_zod8.z.string().min(1).optional(),
+      session: import_zod8.z.object({
+        present: import_zod8.z.boolean(),
+        expired: import_zod8.z.boolean().nullable(),
+        expiresAt: import_zod8.z.string().datetime({ offset: true }).nullable()
       }).strict(),
-      liveAdditionalDelegationCount: import_zod7.z.number().int().nonnegative().describe(
+      liveAdditionalDelegationCount: import_zod8.z.number().int().nonnegative().describe(
         "Stored, unexpired compact-UCAN or signed-login delegations with a valid request binding. Each still requires local proof validation and node activation before it grants authority."
       )
     }).strict();
@@ -7829,7 +8470,8 @@ function registeredOperationDefinitions() {
     ...authOperationDefinitions,
     ...explorationOperationDefinitions,
     ...sqlOperationDefinitions,
-    ...secretsGetOperationDefinitions
+    ...secretsGetOperationDefinitions,
+    ...secretsStatusOperationDefinitions
   ]);
   return operationDefinitions;
 }
@@ -7861,6 +8503,7 @@ var init_registry = __esm({
     init_auth();
     init_exploration();
     init_secrets_get();
+    init_secrets_status();
     init_sql();
     init_status();
   }
@@ -7913,6 +8556,9 @@ function resolvePosture(profile) {
   if (profile.authMethod === "local") return "local-owner-key";
   return "owner-openkey";
 }
+function isLocalOwnerProfile(profile) {
+  return resolvePosture(profile) === "local-owner-key" || profile.authMethod === "local" || typeof profile.privateKey === "string";
+}
 function profileNotFound2(profile) {
   return {
     ok: false,
@@ -7997,11 +8643,14 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
   if (requirement === "inspection") {
     return { ok: true, context: { summary } };
   }
+  if (requirement === "restored") {
+    return createRestoredRuntime(target, resolved);
+  }
   const profileName = summary.profile;
   try {
     const {
       TinyCloudNode: TinyCloudNodeConstructor
-    } = nodeSdk4;
+    } = nodeSdk6;
     const explicitPrivateKeyOverride = typeof target.privateKey === "string";
     const [session, key] = explicitPrivateKeyOverride ? [null, null] : await Promise.all([
       readSession(profileName),
@@ -8079,7 +8728,9 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
     const runtime = {
       node,
       granted: canonicalizeCapabilities(livePermissions),
-      ...warnings.length === 0 ? {} : { warnings }
+      ...warnings.length === 0 ? {} : { warnings },
+      localOwner: explicitPrivateKeyOverride || isLocalOwnerProfile(profile),
+      skippedGrantReasons: warnings.map((warning) => warning.reason)
     };
     return {
       ok: true,
@@ -8103,11 +8754,112 @@ async function createInvocationRuntime(target, requirement = "authenticated") {
     ));
   }
 }
+async function createRestoredRuntime(target, resolved) {
+  const summary = resolved.context;
+  const profileName = summary.profile;
+  const profile = resolved.profile;
+  if (typeof target.privateKey === "string") {
+    return failed(summary, operationError(
+      "AUTH_REQUIRED",
+      "This operation never signs in; an explicit private key has no stored session.",
+      { details: { reason: "explicit_key" } }
+    ));
+  }
+  try {
+    const actualPosture = resolvePosture(profile);
+    const selectedPosture = profile.authMethod === "local" ? "local-owner-key" : summary.posture;
+    if (actualPosture !== summary.posture || selectedPosture !== summary.posture) {
+      return failed(
+        { ...summary, posture: actualPosture !== summary.posture ? actualPosture : selectedPosture },
+        operationError(
+          "PROFILE_POSTURE_NOT_ALLOWED",
+          "The selected profile changed posture during runtime resolution."
+        )
+      );
+    }
+    const [session, key] = await Promise.all([
+      readSession(profileName),
+      readJson(`${profilePath(profileName)}/key.json`)
+    ]);
+    const activeSession = session === null ? void 0 : normalizeSession(session, key);
+    if (activeSession === void 0) {
+      return failed(summary, operationError(
+        "SESSION_NOT_FOUND",
+        "The selected profile does not have an active session. This operation never signs in.",
+        { details: { recovery: signInRecovery(profileName, summary.posture) } }
+      ));
+    }
+    if (!await bindingMigrationRecorded(profileName)) {
+      const records = await readAdditionalDelegations(profileName);
+      if (records.some(
+        (entry) => storedDelegationKind(entry) === "compact" && !("authorityRequest" in entry)
+      )) {
+        return failed(summary, operationError(
+          "PROFILE_MIGRATION_REQUIRED",
+          `Profile "${profileName}" has a one-time stored-grant upgrade to finish. Run one authenticated command on it (tc --profile <profile> auth caps), then retry.`,
+          { retryable: false, details: { recovery: migrationRecovery(profileName) } }
+        ));
+      }
+    }
+    const { TinyCloudNode: TinyCloudNodeConstructor } = nodeSdk6;
+    const node = new TinyCloudNodeConstructor({
+      host: summary.host,
+      ...typeof profile.privateKey === "string" ? { privateKey: profile.privateKey } : {}
+    });
+    try {
+      await node.restoreSession(activeSession);
+    } catch (error) {
+      if (isRecord7(error) && error.code === "AUTH_EXPIRED") {
+        return failed(summary, operationError(
+          "AUTH_REQUIRED",
+          "The stored session has expired or is no longer valid. Sign in again.",
+          { retryable: false, details: { recovery: signInRecovery(profileName, summary.posture) } }
+        ));
+      }
+      throw error;
+    }
+    const activeSessionDid = normalizeDid(node.sessionDid);
+    const livePrincipalDid = normalizeDid(node.did);
+    const livePermissions = [...node.getVerifiedSessionCapabilities()];
+    const replay = await replayStoredDelegationRecords(
+      profileName,
+      node,
+      { host: summary.host, resolveSpace: operationSpaceResolver(node, summary.space) }
+    );
+    for (const installed of replay.installed) {
+      livePermissions.push(...installed.effectivePermissions);
+    }
+    const runtime = {
+      node,
+      granted: canonicalizeCapabilities(livePermissions),
+      ...replay.warnings.length === 0 ? {} : { warnings: replay.warnings },
+      localOwner: isLocalOwnerProfile(profile),
+      skippedGrantReasons: replay.warnings.map((warning) => warning.reason)
+    };
+    return {
+      ok: true,
+      context: {
+        summary: {
+          ...summary,
+          ...livePrincipalDid === void 0 ? {} : { principalDid: livePrincipalDid },
+          ...activeSessionDid === void 0 ? {} : { sessionDid: activeSessionDid }
+        },
+        runtime
+      }
+    };
+  } catch {
+    return failed(summary, operationError(
+      "NODE_ERROR",
+      "The selected profile runtime could not be initialized.",
+      { retryable: true }
+    ));
+  }
+}
 function spaceForAuthenticatedPrincipal(principal2) {
   if (principal2 === void 0) return void 0;
   try {
-    const pkh = nodeSdk4.parsePkhDid(principal2);
-    return pkh === null ? void 0 : nodeSdk4.makePkhSpaceId(pkh.address, pkh.chainId, "secrets");
+    const pkh = nodeSdk6.parsePkhDid(principal2);
+    return pkh === null ? void 0 : nodeSdk6.makePkhSpaceId(pkh.address, pkh.chainId, "secrets");
   } catch {
     return void 0;
   }
@@ -8151,14 +8903,15 @@ function unresolvedSummary(target) {
     posture: "unauthenticated"
   };
 }
-var nodeSdk4;
+var nodeSdk6;
 var init_runtime = __esm({
   "src/runtime.ts"() {
     "use strict";
-    nodeSdk4 = __toESM(require("@tinycloud/node-sdk"), 1);
+    nodeSdk6 = __toESM(require("@tinycloud/node-sdk"), 1);
     init_authority();
     init_errors2();
     init_profile();
+    init_recovery();
     init_secrets();
     init_state();
     init_delegation_binding();
@@ -8181,6 +8934,9 @@ init_errors2();
 init_authority();
 init_artifacts();
 
+// src/redaction.ts
+init_recovery();
+
 // src/safe-values.ts
 function safeOriginHost(value) {
   if (typeof value !== "string" || value.length === 0) return void 0;
@@ -8257,7 +9013,25 @@ function redactOperationError(_definition, error) {
 }
 var SAFE_ERROR_DETAIL_POLICIES = {
   INPUT_INVALID: {
-    issues: (value) => Array.isArray(value) ? safeIssueCodes(value) : void 0
+    issues: (value) => Array.isArray(value) ? safeIssueCodes(value) : void 0,
+    reason: (value) => value === "OWNER_MISMATCH" || value === "OWNER_DID_UNKNOWN" ? value : void 0
+  },
+  AUTH_REQUIRED: {
+    recovery: (value) => isSafeRecovery(value, "sign_in") ? { ...value } : void 0,
+    reason: (value) => value === "explicit_key" ? value : void 0
+  },
+  SESSION_NOT_FOUND: {
+    recovery: (value) => isSafeRecovery(value, "sign_in") ? { ...value } : void 0
+  },
+  PROFILE_MIGRATION_REQUIRED: {
+    recovery: (value) => isSafeRecovery(value, "complete_migration") ? { ...value } : void 0
+  },
+  // `secrets.get` not found for an identity no request link serves.
+  KV_NOT_FOUND: {
+    recoveryKind: (value) => value === "put_locally" || value === "not_requestable" ? value : void 0,
+    names: (value) => Array.isArray(value) && value.length >= 1 && value.length <= 10 && value.every((name) => typeof name === "string" && name.length <= 256 && /^[A-Z][A-Z0-9_]*$/.test(name)) ? [...value] : void 0,
+    scope: (value) => typeof value === "string" && value.length <= 256 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(value) ? value : void 0,
+    owner: (value) => typeof value === "string" && /^did:pkh:eip155:[1-9][0-9]*:0x[0-9a-fA-F]{40}$/.test(value) ? value : void 0
   },
   OPERATION_VERSION_UNSUPPORTED: {
     supportedVersions: (value) => Array.isArray(value) && value.every((item) => Number.isInteger(item)) ? value : void 0
@@ -8541,7 +9315,7 @@ async function prepareInvocation(operationId, operationVersion, invocationTarget
       )
     ) };
   }
-  if (target.privateKey === void 0 && definition.runtime === "authenticated" && isOwnerPosture(inspectionResolution.context.summary.posture) && target.allowOwnerProfile !== true) {
+  if (target.privateKey === void 0 && requiresRuntime(definition.runtime) && isOwnerPosture(inspectionResolution.context.summary.posture) && target.allowOwnerProfile !== true) {
     return { status: "error", result: errorResult(
       operation,
       inspectionResolution.context.summary,
@@ -8551,15 +9325,15 @@ async function prepareInvocation(operationId, operationVersion, invocationTarget
       )
     ) };
   }
-  const runtimeResolution = definition.runtime === "inspection" ? inspectionResolution : await resolveRuntime(target, "authenticated");
+  const runtimeResolution = definition.runtime === "inspection" ? inspectionResolution : await resolveRuntime(target, definition.runtime);
   if (!runtimeResolution.ok) {
     return { status: "error", result: errorResult(
       operation,
       runtimeResolution.context,
-      runtimeResolution.error
+      redactOperationError(definition, runtimeResolution.error)
     ) };
   }
-  if (definition.runtime === "authenticated") {
+  if (requiresRuntime(definition.runtime)) {
     const actualPosture = runtimeResolution.context.summary.posture;
     if (!definition.postures.includes(actualPosture)) {
       return { status: "error", result: errorResult(
@@ -9045,6 +9819,15 @@ function internalOperationErrorResult(prepared) {
 function isOwnerPosture(posture) {
   return posture === "owner-openkey" || posture === "local-owner-key";
 }
+function requiresRuntime(requirement) {
+  switch (requirement) {
+    case "authenticated":
+    case "restored":
+      return true;
+    case "inspection":
+      return false;
+  }
+}
 function zodIssueDetails(error) {
   return {
     // The canonical error channel carries only schema-owned issue codes.