@tinycloud/operations 0.5.0-beta.0 → 0.5.0-beta.2

package/dist/index.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",
@@ -5232,6 +5233,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 +5358,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 +5385,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"]);
   }
@@ -5516,7 +5546,10 @@ async function importRequestBoundDelegation(context, input) {
         delegation,
         { host }
       );
-    } catch {
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "reason" in error && error.reason === "expired") {
+        return expiredDelegation();
+      }
       return operationFailure(
         "DELEGATION_REJECTED",
         "The delegation was rejected by the TinyCloud runtime."
@@ -5534,55 +5567,67 @@ async function importRequestBoundDelegation(context, input) {
       );
     }
     try {
-      return await updateProfileStore(
-        context.summary.profile,
-        "additional-delegations",
-        async (records) => {
-          const state = await importState(context, input.requestId);
-          if (!state.ok) return { records, result: state.result };
-          if (state.sessionDid !== sessionDid || normalizeHost(state.host) !== normalizeHost(host)) {
-            return {
-              records,
-              result: audienceMismatch(state.sessionDid, sessionDid)
+      return await withProfileLock(context.summary.profile, async () => {
+        const previousRecords = await readAdditionalDelegations(context.summary.profile);
+        const result = await updateProfileStore(
+          context.summary.profile,
+          "additional-delegations",
+          async (records) => {
+            const state = await importState(context, input.requestId);
+            if (!state.ok) return { records, result: state.result };
+            if (state.sessionDid !== sessionDid || normalizeHost(state.host) !== normalizeHost(host)) {
+              return {
+                records,
+                result: audienceMismatch(state.sessionDid, sessionDid)
+              };
+            }
+            if (state.request.profile !== context.summary.profile || !samePrincipal(state.request.sessionDid, sessionDid) || normalizeHost(state.request.host) !== normalizeHost(host) || JSON.stringify(canonicalizeOperationCapabilities(state.request.requested, resolveSpace2)) !== JSON.stringify(canonicalizeOperationCapabilities(request.requested, resolveSpace2))) {
+              return {
+                records,
+                result: operationFailure(
+                  "DELEGATION_ARTIFACT_INVALID",
+                  "The delegation does not reference a current stored request."
+                )
+              };
+            }
+            const record = {
+              delegation: activated.delegation,
+              permissions: activated.effectivePermissions,
+              authorityRequest: {
+                requestId: request.requestId,
+                requested: request.requested
+              }
             };
-          }
-          if (state.request.profile !== context.summary.profile || !samePrincipal(state.request.sessionDid, sessionDid) || normalizeHost(state.request.host) !== normalizeHost(host) || JSON.stringify(canonicalizeOperationCapabilities(state.request.requested, resolveSpace2)) !== JSON.stringify(canonicalizeOperationCapabilities(request.requested, resolveSpace2))) {
+            const position = records.findIndex((entry) => delegationCid(entry) === activated.cid);
+            const alreadyPresent = position !== -1;
+            const others = records.filter((entry) => delegationCid(entry) !== activated.cid);
             return {
-              records,
-              result: operationFailure(
-                "DELEGATION_ARTIFACT_INVALID",
-                "The delegation does not reference a current stored request."
-              )
+              records: alreadyPresent ? [...others.slice(0, position), record, ...others.slice(position)] : [...records, record],
+              result: {
+                status: "ok",
+                output: {
+                  cid: activated.cid,
+                  effectivePermissions,
+                  expiry: activated.expiry.toISOString(),
+                  audience: activated.audience,
+                  host: activated.host,
+                  activated: true,
+                  alreadyPresent
+                }
+              }
             };
           }
-          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 ? [...others.slice(0, position), record, ...others.slice(position)] : [...records, record],
-            result: {
-              status: "ok",
-              output: {
-                cid: activated.cid,
-                effectivePermissions,
-                expiry: activated.expiry.toISOString(),
-                audience: activated.audience,
-                host: activated.host,
-                activated: true,
-                alreadyPresent
-              }
-            }
-          };
+        );
+        if (activated.expiry.getTime() <= Date.now()) {
+          await updateProfileStore(
+            context.summary.profile,
+            "additional-delegations",
+            () => ({ records: previousRecords, result: void 0 })
+          );
+          return expiredDelegation();
         }
-      );
+        return result;
+      });
     } catch {
       return internalImportFailure();
     }
@@ -5831,6 +5876,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 [{
@@ -6198,19 +6270,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 {
@@ -6259,11 +6318,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();
@@ -6565,6 +6624,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(
@@ -6631,27 +6875,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",
@@ -6696,6 +6927,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;
@@ -6723,6 +6995,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(),
@@ -6774,6 +7047,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);
@@ -7086,15 +7547,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;
@@ -7110,29 +7571,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),
@@ -7140,13 +7601,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),
@@ -7154,88 +7615,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",
@@ -7335,6 +7796,8 @@ var init_contract = __esm({
       "resources_mismatch",
       "unsupported",
       "activation_rejected",
+      "activation_unavailable",
+      "activation_unauthenticated",
       "invalid"
     ];
     DELEGATION_CID_PATTERN = "^bafkr4i[a-z2-7]{52}$";
@@ -7437,6 +7900,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();
@@ -7477,7 +7943,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;
   }
@@ -7511,7 +7977,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);
@@ -7543,7 +8009,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) {
@@ -7560,7 +8026,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) => {
@@ -7595,13 +8061,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();
@@ -7742,35 +8208,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();
@@ -7814,7 +8280,8 @@ function registeredOperationDefinitions() {
     ...authOperationDefinitions,
     ...explorationOperationDefinitions,
     ...sqlOperationDefinitions,
-    ...secretsGetOperationDefinitions
+    ...secretsGetOperationDefinitions,
+    ...secretsStatusOperationDefinitions
   ]);
   return operationDefinitions;
 }
@@ -7846,6 +8313,7 @@ var init_registry = __esm({
     init_auth();
     init_exploration();
     init_secrets_get();
+    init_secrets_status();
     init_sql();
     init_status();
   }
@@ -7898,6 +8366,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,
@@ -7982,11 +8453,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),
@@ -8064,7 +8538,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,
@@ -8088,11 +8564,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;
   }
@@ -8136,14 +8713,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();
@@ -8166,6 +8744,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;
@@ -8242,7 +8823,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
@@ -8324,7 +8923,7 @@ async function invokeOperation(operationId, operationVersion, invocationTarget,
       operationError("INPUT_INVALID", "The invocation target is invalid.")
     );
   }
-  return withTinyCloudStateRoot(target.stateRoot, async () => {
+  const run = withTinyCloudStateRoot(target.stateRoot, async () => {
     const prepared = await prepareInvocation(
       operationId,
       operationVersion,
@@ -8334,6 +8933,33 @@ async function invokeOperation(operationId, operationVersion, invocationTarget,
     if (isPreparedError(prepared)) return prepared.result;
     return withRuntimeWarnings(await executePreparedInvocation(prepared), prepared);
   });
+  const { lookupOperation: lookupOperation2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const lookup = lookupOperation2(operationId, operationVersion);
+  const deadlineMs = lookup.status === "found" ? lookup.definition.deadlineMs : void 0;
+  if (deadlineMs === void 0) return run;
+  return withResponseDeadline(run, deadlineMs, () => errorResult(
+    { operationId, operationVersion },
+    unresolvedContextSummary(target),
+    operationError(
+      "NODE_UNREACHABLE",
+      `The operation did not finish within ${deadlineMs / 1e3} s.`,
+      { retryable: true }
+    )
+  ));
+}
+async function withResponseDeadline(run, deadlineMs, expired) {
+  run.catch(() => {
+  });
+  let timer;
+  const deadline = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(expired()), deadlineMs);
+    timer.unref();
+  });
+  try {
+    return await Promise.race([run, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 function withRuntimeWarnings(result, prepared) {
   const warnings = prepared.runtimeResolution.context.runtime?.warnings;
@@ -8408,7 +9034,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,
@@ -8418,15 +9044,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(
@@ -8813,6 +9439,15 @@ function exactCapabilities2(value) {
 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.