negotium 0.22.2 → 0.22.4

package/dist/runtime/src/mcp-runtime-host.ts

@@ -2,6 +2,7 @@
 export { createAskUserToolDefinition } from "#agents/mcp-tools/ask-user";
 export { errorResult, textResult } from "#agents/mcp-tools/common";
 export { createPublishHtmlToolDefinitions } from "#agents/mcp-tools/publish-html";
+export { createRequestVaultToolDefinition } from "#agents/mcp-tools/request-vault";
 export type { SelfConfigContext } from "#agents/mcp-tools/self-config";
 export { createSelfConfigToolDefinitions } from "#agents/mcp-tools/self-config";
 export {

package/dist/runtime/src/node-host.ts

@@ -5,6 +5,11 @@ export {
   startAskUserQuestionGateOwner,
   stopAskUserQuestionGateOwner,
 } from "#agents/mcp-tools/ask-user";
+export {
+  reconcilePendingRequestVaultGates,
+  startRequestVaultGateOwner,
+  stopRequestVaultGateOwner,
+} from "#agents/mcp-tools/request-vault";
 export { sweepStaleSubagentCards } from "#agents/mcp-tools/spawn-subagent";
 export {
   RuntimeGatewayIdempotencyConflictError,

package/dist/runtime/src/runtime/inbox.ts

@@ -23,7 +23,7 @@ import { deliverPeerReply, type RemoteReplyRoute } from "#mcp/session-comm/peer-
 import { type CoalescingRunner, createCoalescingRunner } from "#outbox/coalescing-runner";
 import { deleteProcessingFile, drainOutboxFile, parseOutboxLine } from "#outbox/file-ops";
 import { watchDir } from "#outbox/utils";
-import { resolveTopicWorkspaceDir, SESSION_INBOX_DIR } from "#platform/config";
+import { SESSION_INBOX_DIR } from "#platform/config";
 import { FROM_AUTO_CONTINUE, FROM_SELF_SCHEDULE } from "#platform/constants";
 import { appendJsonlEntry, readJsonlLines } from "#platform/jsonl";
 import { logger } from "#platform/logger";
@@ -123,16 +123,22 @@ export function normalizeAskTarget(target: unknown): "main" | "cron" | null {
 }
 
 /**
- * Main-session asks run as a normal turn on the target topic's own session
+ * Every ask now runs as a normal turn on the target's own session
  * (tell_session-style, visible in the target) instead of on a fork. Codex
  * scopes its prompt cache to the thread, so a fork's first request never
  * reused the parent's cache and every ask paid full input price; running on
- * the target session keeps the cache warm and gives every agent the same
- * ask semantics. Cron asks keep the fork path so they never mutate the shared
- * cron session.
+ * the target session keeps the cache warm.
+ *
+ * Cron asks (2026-10-20) dropped the fork too, trading it for
+ * `turnConcurrency: "isolated"` so the ask doesn't queue behind the topic's
+ * main visible turn. This does NOT serialize against a scheduled cron run
+ * landing on the identical session at the same moment — the fork used to
+ * sidestep that by mutating a private copy instead of the shared session.
+ * Treat a corrupted/interleaved cron rollout as a known residual risk until
+ * the cron scheduler itself gets a per-session lock.
  */
-export function askRunsOnTargetSession(target: "main" | "cron"): boolean {
-  return target === "main";
+export function askRunsOnTargetSession(_target: "main" | "cron"): boolean {
+  return true;
 }
 
 export function resolveAskParentSessionId(
@@ -1070,33 +1076,16 @@ async function handleAskEntry(
   const { getTopic } = await import("#storage/api-topics");
   const fullTopic = getTopic(topic.id);
   const agentOverride = (fullTopic?.agent ?? topic.agent ?? undefined) as AgentKind | undefined;
-  const cwd = resolveTopicWorkspaceDir(topic.id);
   if (!agentOverride) {
     clearPendingAskForEntry(scope, entry, topicName, "target-agent-missing");
     await notifyAskDrop(scope, entry, topicName, "(error: target topic has no agent)");
     return;
   }
 
-  // Fork immediately — snapshot the target topic's state at the moment the
-  // inbox entry is consumed (just like clawgram). The ask session reads the
-  // history that exists right now, not after any in-flight user turn finishes.
-  const { cleanupAgentFork, forkAgentSession } = await import("#agents/fork");
-  const { getRegistry, getRegistryOperations } = await import("#agents/registry");
-  const { resolveModelForAgent } = await import("#agents/model-catalog");
-  const { getApiTopicConfig } = await import("#storage/api-topic-config");
-  const { readConversation } = await import("#storage/conversations");
-  const registry = getRegistry(agentOverride);
-  const topicConfig = getApiTopicConfig(topic.id);
-  const model = resolveModelForAgent(
-    agentOverride,
-    topicConfig?.model ?? fullTopic?.defaultModel,
-    registry,
-  );
-  const requestedEffort = topicConfig?.effort ?? fullTopic?.defaultEffort;
-  const effort =
-    requestedEffort && registry.validateEffort(requestedEffort)
-      ? requestedEffort
-      : registry.defaultEffort;
+  // Every ask runs as a normal turn on the target's own session (see
+  // askRunsOnTargetSession above), so no fork/model/effort resolution is
+  // needed here — triggerTopicAiTurn below resolves those itself, same as
+  // a regular tell_session.
   const cronSession =
     askTarget === "cron" ? getRegisteredCronSession(topic.id, agentOverride) : null;
   const parentSessionId =
@@ -1161,6 +1150,17 @@ async function handleAskEntry(
         label: `Ask from ${fromLabel}`,
         message: entry.message,
       },
+      // cron: target the cron session explicitly and run it isolated from
+      // the topic's main visible turn (no fork — see askRunsOnTargetSession's
+      // doc comment for the residual concurrency tradeoff). main: default to
+      // the topic's own session/turn slot, same as tell_session.
+      ...(askTarget === "cron"
+        ? {
+            sessionId: parentSessionId,
+            sessionScope: "isolated" as const,
+            turnConcurrency: "isolated" as const,
+          }
+        : {}),
       onSettled,
       onDispatched,
     });
@@ -1171,149 +1171,11 @@ async function handleAskEntry(
     return;
   }
 
-  const forkNative = parentSessionId
-    ? () =>
-        forkAgentSession({
-          agent: agentOverride,
-          parentSessionId,
-          cwd,
-          userId: scope.userId,
-          topicName,
-          title: `ask: ${entry.from} -> ${targetLabel}`,
-          model,
-          ...(effort ? { effort } : {}),
-        })
-    : undefined;
-
-  let forkPlan: AskForkPlan;
-  try {
-    forkPlan = await createAskForkPlan({
-      // Read once: queued/replayed asks must keep the history visible at inbox
-      // consumption time even if the target topic advances while they wait.
-      entries: askTarget === "cron" ? [] : readConversation(scope.userId, topicName),
-      ...(forkNative ? { forkNative } : {}),
-      ...(askTarget === "cron" && forkNative ? { prepareSession: forkNative } : {}),
-      synthesize: async (entries) => {
-        if (askTarget === "cron") {
-          throw new Error("cron session fork failed");
-        }
-        const rollout = getRegistryOperations(agentOverride).writeRollout({
-          cwd,
-          entries,
-          model,
-          ...(effort ? { effort } : {}),
-        });
-        return {
-          agent: agentOverride,
-          forkId: rollout.sessionId,
-          rolloutPath: rollout.rolloutPath,
-        };
-      },
-      onNativeForkError: (err) => {
-        logger.warn(
-          { err, topicName, from: entry.from, requestId, parentSessionId },
-          "session-inbox: native target fork failed",
-        );
-      },
-    });
-  } catch (err) {
-    // This entry has already been claimed. Convert preparation failure into a
-    // terminal ask result so processTopicInbox can delete its `.processing`
-    // file instead of leaving the request undiscoverable until another write.
-    logger.error(
-      { err, topicName, from: entry.from, requestId, parentSessionId },
-      "session-inbox: failed to prepare target ask session",
-    );
-    try {
-      clearPendingAskForEntry(scope, entry, topicName, "target-session-prepare-failed");
-    } catch (clearError) {
-      logger.warn(
-        { err: clearError, topicName, from: entry.from, requestId },
-        "session-inbox: failed to clear ask after session preparation failure",
-      );
-    }
-    const message = "(error: target session could not be prepared)";
-    if (remoteReply) {
-      try {
-        const delivered = await deliverPeerReply(remoteReply, targetLabel, message, "error");
-        if (!delivered) {
-          logger.warn(
-            { topicName, from: entry.from, requestId },
-            "session-inbox: failed to deliver remote ask preparation error",
-          );
-        }
-      } catch (deliveryError) {
-        logger.warn(
-          { err: deliveryError, topicName, from: entry.from, requestId },
-          "session-inbox: remote ask preparation error delivery threw",
-        );
-      }
-    } else {
-      try {
-        await notifyAskDrop(scope, entry, targetLabel, message);
-      } catch (deliveryError) {
-        logger.warn(
-          { err: deliveryError, topicName, from: entry.from, requestId },
-          "session-inbox: local ask preparation error delivery threw",
-        );
-      }
-    }
-    return;
-  }
-
-  if (askTarget === "cron") {
-    const currentCronSession = getRegisteredCronSession(topic.id, agentOverride);
-    if (
-      !cronSession ||
-      !currentCronSession ||
-      currentCronSession.sessionId !== cronSession.sessionId ||
-      currentCronSession.ownerUserId !== cronSession.ownerUserId
-    ) {
-      cleanupAgentFork(forkPlan.forkHandle);
-      clearPendingAskForEntry(scope, entry, topicName, "cron-session-changed-during-fork");
-      const message =
-        "(error: cron session changed while preparing the request; retry the request)";
-      if (remoteReply) {
-        await deliverPeerReply(remoteReply, targetLabel, message, "error");
-      } else {
-        await notifyAskDrop(scope, entry, targetLabel, message);
-      }
-      return;
-    }
-  }
-
-  // Trigger the AI turn immediately with the pre-forked session.
-  triggerTopicAiTurn(
-    topic.id,
-    String(scope.userId),
-    prompt,
-    (agentOverride ?? topic.agent ?? undefined) as Parameters<typeof triggerTopicAiTurn>[3],
-    {
-      origin: entry.from,
-      requestId,
-      contextId: entry.contextId,
-      depth: (entry.fromDepth ?? 0) + 1,
-      silent: true,
-      sessionId: forkPlan.forkHandle.forkId,
-      // The fork is read-only and session-isolated, so it does not need the
-      // target topic's visible execution slot. Answer immediately even while
-      // that topic is processing a user turn.
-      turnConcurrency: "isolated",
-      forkHandle: forkPlan.forkHandle,
-      // Keep a regeneration recipe even though the first fork is eager. The
-      // isolated room prevents user preemption; the recipe remains available
-      // for a clean retry if the provider reports an expired session.
-      prepareSession: forkPlan.prepareSession,
-      cwd,
-      onSettled,
-      onDispatched,
-    },
-  );
-
-  logger.info(
-    { topicName, from: entry.from, requestId, callerTopicId },
-    "session-inbox: ask delivered",
-  );
+  // Every ask now runs on the target's own session (see
+  // askRunsOnTargetSession above) — the fork-and-copy path this used to
+  // fall through to for ask_cron was removed 2026-10-20. createAskForkPlan
+  // itself is kept (still exported + unit-tested) in case a future caller
+  // needs a true read-only copy again.
 }
 
 // ── Bootstrap ───────────────────────────────────────────────────────

package/dist/runtime/src/runtime/turn-event-stream.ts

@@ -9,6 +9,7 @@ import {
   scheduleIdleCompactForTopic,
 } from "#agents/idle-compact";
 import { cancelPendingAskUserQuestions } from "#agents/mcp-tools/ask-user";
+import { cancelPendingVaultSecretRequests } from "#agents/mcp-tools/request-vault";
 import {
   settleSubagentFailure,
   settleSubagentSuccess,
@@ -935,6 +936,7 @@ export async function runTurnEventStream(
     const stillCurrent = getRoomQuery(roomId)?.queryId === queryId;
     clearRoomQuery(roomId, queryId);
     cancelPendingAskUserQuestions(topicId, queryId);
+    cancelPendingVaultSecretRequests(topicId, queryId);
     if (stillCurrent && roomId === topicId) clearQueryState(userId, topicId, topicTitle);
     // Stop typing only if this turn still owns the room. A superseded turn may
     // finish cleanup after its replacement already broadcast a fresh start.

package/dist/runtime/src/storage/api-messages.ts

@@ -80,6 +80,9 @@ function initializeApiMessagesSchema(): void {
   try {
     db.exec("ALTER TABLE api_messages ADD COLUMN subagent_card TEXT");
   } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN vault_secret_request TEXT");
+  } catch {}
   // Index on topic_id; SQLite appends the implicit rowid to every index entry,
   // so `WHERE topic_id=? AND rowid>? ORDER BY rowid` stays index-driven.
   db.exec("CREATE INDEX IF NOT EXISTS idx_api_messages_topic ON api_messages(topic_id)");
@@ -111,6 +114,7 @@ export interface ApiMessageRow {
   ask_user_question: string | null;
   tell_card: string | null;
   subagent_card: string | null;
+  vault_secret_request: string | null;
   mentions: string | null;
   thread_root_id: string | null;
   created_at: string;
@@ -166,6 +170,7 @@ function rowToDto(r: ApiMessageRow): MessageDto {
     askUserQuestion: r.ask_user_question ? JSON.parse(r.ask_user_question) : undefined,
     tellCard: r.tell_card ? JSON.parse(r.tell_card) : undefined,
     subagentCard: r.subagent_card ? JSON.parse(r.subagent_card) : undefined,
+    vaultSecretRequest: r.vault_secret_request ? JSON.parse(r.vault_secret_request) : undefined,
     mentions: r.mentions ? JSON.parse(r.mentions) : undefined,
     threadRootId: r.thread_root_id ?? undefined,
     createdAt: r.created_at,
@@ -200,8 +205,8 @@ export function appendApiMessage(msg: MessageDto, options: AppendApiMessageOptio
     const result = db
       .query(
         `INSERT INTO api_messages
-         (id, topic_id, parent_id, author_id, source_adapter, source_node, source_message_id, text, query_id, agent_type, model, attachments, usage, deleted, edited_at, reactions, kind, ask_user_question, tell_card, subagent_card, mentions, thread_root_id, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         (id, topic_id, parent_id, author_id, source_adapter, source_node, source_message_id, text, query_id, agent_type, model, attachments, usage, deleted, edited_at, reactions, kind, ask_user_question, tell_card, subagent_card, vault_secret_request, mentions, thread_root_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO NOTHING`,
       )
       .run(
@@ -225,6 +230,7 @@ export function appendApiMessage(msg: MessageDto, options: AppendApiMessageOptio
         msg.askUserQuestion ? JSON.stringify(msg.askUserQuestion) : null,
         msg.tellCard ? JSON.stringify(msg.tellCard) : null,
         msg.subagentCard ? JSON.stringify(msg.subagentCard) : null,
+        msg.vaultSecretRequest ? JSON.stringify(msg.vaultSecretRequest) : null,
         msg.mentions?.length ? JSON.stringify(msg.mentions) : null,
         msg.threadRootId ?? null,
         msg.createdAt,

package/dist/runtime/src/storage/vault-request-gates.ts

@@ -0,0 +1,359 @@
+import { db } from "#storage/forum-db";
+import { registerStorageSchemaInitializer } from "#storage/storage-host";
+import type { VaultSecretRequestDto } from "#types/api";
+
+export type VaultRequestGateState =
+  | "pending"
+  | "claimed"
+  | "answered"
+  | "cancelled"
+  | "quarantined";
+
+export interface VaultRequestGateRecord {
+  gateId: string;
+  topicId: string;
+  queryId?: string;
+  idempotencyKey: string;
+  bodyHash: string;
+  messageId: string;
+  ownerId: string;
+  state: VaultRequestGateState;
+  outcome?: "fulfilled" | "declined";
+  answeredBy?: string;
+}
+
+interface VaultRequestGateRow {
+  gate_id: string;
+  topic_id: string;
+  query_id: string | null;
+  idempotency_key: string;
+  body_hash: string;
+  message_id: string;
+  owner_id: string;
+  state: VaultRequestGateState;
+  outcome: "fulfilled" | "declined" | null;
+  answered_by: string | null;
+}
+
+export interface VaultRequestGateCardUpdate {
+  topicId: string;
+  messageId: string;
+  vaultSecretRequest: VaultSecretRequestDto;
+  editedAt: string;
+}
+
+function initializeVaultRequestGateSchema(): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS vault_request_gates (
+      gate_id TEXT PRIMARY KEY,
+      topic_id TEXT NOT NULL REFERENCES api_topics(id) ON DELETE CASCADE,
+      query_id TEXT,
+      idempotency_key TEXT NOT NULL,
+      body_hash TEXT NOT NULL,
+      message_id TEXT NOT NULL UNIQUE,
+      owner_id TEXT NOT NULL,
+      state TEXT NOT NULL,
+      outcome TEXT,
+      answered_by TEXT,
+      claim_source TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_vault_request_gates_idempotency
+      ON vault_request_gates(topic_id, idempotency_key, created_at);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_request_gates_active_key
+      ON vault_request_gates(topic_id, idempotency_key)
+      WHERE state IN ('pending', 'claimed');
+  `);
+}
+
+registerStorageSchemaInitializer(initializeVaultRequestGateSchema, 32);
+
+function fromRow(row: VaultRequestGateRow): VaultRequestGateRecord {
+  return {
+    gateId: row.gate_id,
+    topicId: row.topic_id,
+    queryId: row.query_id ?? undefined,
+    idempotencyKey: row.idempotency_key,
+    bodyHash: row.body_hash,
+    messageId: row.message_id,
+    ownerId: row.owner_id,
+    state: row.state,
+    outcome: row.outcome ?? undefined,
+    answeredBy: row.answered_by ?? undefined,
+  };
+}
+
+function latestGate(topicId: string, idempotencyKey: string): VaultRequestGateRecord | null {
+  const row = db
+    .query(
+      `SELECT * FROM vault_request_gates
+       WHERE topic_id = ? AND idempotency_key = ?
+       ORDER BY rowid DESC LIMIT 1`,
+    )
+    .get(topicId, idempotencyKey) as VaultRequestGateRow | undefined;
+  return row ? fromRow(row) : null;
+}
+
+function expireVaultCard(
+  topicId: string,
+  messageId: string,
+  editedAt: string,
+): VaultRequestGateCardUpdate | null {
+  const row = db
+    .query(
+      `SELECT vault_secret_request FROM api_messages
+       WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'vault_secret_request'`,
+    )
+    .get(topicId, messageId) as { vault_secret_request: string | null } | undefined;
+  if (!row?.vault_secret_request) return null;
+  const request = JSON.parse(row.vault_secret_request) as VaultSecretRequestDto;
+  if (request.status !== "pending") return null;
+  const expired: VaultSecretRequestDto = { ...request, status: "expired" };
+  db.query(
+    `UPDATE api_messages SET vault_secret_request = ?, edited_at = ?
+     WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'vault_secret_request'`,
+  ).run(JSON.stringify(expired), editedAt, topicId, messageId);
+  return { topicId, messageId, vaultSecretRequest: expired, editedAt };
+}
+
+export type PrepareVaultRequestGateResult =
+  | { outcome: "created"; gate: VaultRequestGateRecord }
+  | { outcome: "pending"; gate: VaultRequestGateRecord }
+  | { outcome: "replay"; gate: VaultRequestGateRecord }
+  | { outcome: "conflict"; gate: VaultRequestGateRecord };
+
+export function prepareVaultRequestGate(args: {
+  gateId: string;
+  topicId: string;
+  queryId?: string;
+  idempotencyKey: string;
+  bodyHash: string;
+  messageId: string;
+  ownerId: string;
+  now: string;
+}): PrepareVaultRequestGateResult {
+  return db
+    .transaction(() => {
+      const latest = latestGate(args.topicId, args.idempotencyKey);
+      if (latest?.bodyHash !== undefined && latest.bodyHash !== args.bodyHash) {
+        return { outcome: "conflict", gate: latest } as const;
+      }
+      if (latest?.state === "answered") return { outcome: "replay", gate: latest } as const;
+      if (latest && (latest.state === "pending" || latest.state === "claimed")) {
+        return { outcome: "pending", gate: latest } as const;
+      }
+
+      db.query(
+        `INSERT INTO vault_request_gates
+       (gate_id, topic_id, query_id, idempotency_key, body_hash, message_id, owner_id, state, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+      ).run(
+        args.gateId,
+        args.topicId,
+        args.queryId ?? null,
+        args.idempotencyKey,
+        args.bodyHash,
+        args.messageId,
+        args.ownerId,
+        args.now,
+        args.now,
+      );
+      return {
+        outcome: "created",
+        gate: {
+          gateId: args.gateId,
+          topicId: args.topicId,
+          queryId: args.queryId,
+          idempotencyKey: args.idempotencyKey,
+          bodyHash: args.bodyHash,
+          messageId: args.messageId,
+          ownerId: args.ownerId,
+          state: "pending",
+        },
+      } as const;
+    })
+    .immediate();
+}
+
+export function quarantineVaultRequestGate(
+  gateId: string,
+  ownerId: string,
+  now = new Date().toISOString(),
+): VaultRequestGateCardUpdate | null {
+  return db
+    .transaction(() => {
+      const row = db.query("SELECT * FROM vault_request_gates WHERE gate_id = ?").get(gateId) as
+        | VaultRequestGateRow
+        | undefined;
+      if (!row || row.owner_id !== ownerId || !["pending", "claimed"].includes(row.state)) {
+        return null;
+      }
+      const result = db
+        .query(
+          `UPDATE vault_request_gates SET state = 'quarantined', updated_at = ?
+         WHERE gate_id = ? AND owner_id = ? AND state IN ('pending', 'claimed')`,
+        )
+        .run(now, gateId, ownerId);
+      if (Number(result.changes ?? 0) === 0) return null;
+      return expireVaultCard(row.topic_id, row.message_id, now);
+    })
+    .immediate();
+}
+
+export function quarantineForeignVaultRequestGates(
+  liveOwnerIds: ReadonlySet<string>,
+  now = new Date().toISOString(),
+): VaultRequestGateCardUpdate[] {
+  return db
+    .transaction(() => {
+      const rows = db
+        .query(
+          `SELECT * FROM vault_request_gates
+         WHERE state IN ('pending', 'claimed')`,
+        )
+        .all() as VaultRequestGateRow[];
+      const updates: VaultRequestGateCardUpdate[] = [];
+      for (const row of rows) {
+        if (liveOwnerIds.has(row.owner_id)) continue;
+        if (row.state === "claimed" && row.outcome && row.answered_by) {
+          db.query(
+            `UPDATE vault_request_gates SET state = 'answered', updated_at = ?
+           WHERE gate_id = ? AND state = 'claimed'`,
+          ).run(now, row.gate_id);
+          continue;
+        }
+        const result = db
+          .query(
+            `UPDATE vault_request_gates SET state = 'quarantined', updated_at = ?
+           WHERE gate_id = ? AND state IN ('pending', 'claimed')`,
+          )
+          .run(now, row.gate_id);
+        if (Number(result.changes ?? 0) === 0) continue;
+        const update = expireVaultCard(row.topic_id, row.message_id, now);
+        if (update) updates.push(update);
+      }
+      const legacyCards = db
+        .query(
+          `SELECT m.topic_id, m.id
+         FROM api_messages m
+         LEFT JOIN vault_request_gates g ON g.message_id = m.id
+         WHERE m.kind = 'vault_secret_request'
+           AND m.deleted = 0
+           AND g.gate_id IS NULL`,
+        )
+        .all() as { topic_id: string; id: string }[];
+      for (const card of legacyCards) {
+        const update = expireVaultCard(card.topic_id, card.id, now);
+        if (update) updates.push(update);
+      }
+      return updates;
+    })
+    .immediate();
+}
+
+export type ClaimVaultRequestGateResult =
+  | {
+      outcome: "claimed";
+      gate: VaultRequestGateRecord;
+      vaultSecretRequest: VaultSecretRequestDto;
+      editedAt: string;
+    }
+  | { outcome: "unavailable" };
+
+/**
+ * Claim the gate and mark the card's outcome. This never touches the secret
+ * value itself — the caller is responsible for writing to the vault (via
+ * `vaultSet`) *before* calling this, so the card only ever reflects
+ * "fulfilled"/"declined", never the plaintext.
+ */
+export function claimVaultRequestGateAndAnswer(args: {
+  topicId: string;
+  messageId: string;
+  outcome: "fulfilled" | "declined";
+  userId: string;
+  ownerId: string;
+  source: string;
+  now: string;
+}): ClaimVaultRequestGateResult {
+  return db
+    .transaction(() => {
+      const row = db
+        .query(
+          `SELECT * FROM vault_request_gates
+         WHERE topic_id = ? AND message_id = ?
+         ORDER BY rowid DESC LIMIT 1`,
+        )
+        .get(args.topicId, args.messageId) as VaultRequestGateRow | undefined;
+      if (!row || row.owner_id !== args.ownerId || row.state !== "pending") {
+        return { outcome: "unavailable" } as const;
+      }
+      const message = db
+        .query(
+          `SELECT vault_secret_request FROM api_messages
+         WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'vault_secret_request'`,
+        )
+        .get(args.topicId, args.messageId) as { vault_secret_request: string | null } | undefined;
+      if (!message?.vault_secret_request) return { outcome: "unavailable" } as const;
+      const request = JSON.parse(message.vault_secret_request) as VaultSecretRequestDto;
+      if (request.status !== "pending") return { outcome: "unavailable" } as const;
+
+      const claimed = db
+        .query(
+          `UPDATE vault_request_gates
+         SET state = 'answered', outcome = ?, answered_by = ?, claim_source = ?, updated_at = ?
+         WHERE gate_id = ? AND owner_id = ? AND state = 'pending'`,
+        )
+        .run(args.outcome, args.userId, args.source, args.now, row.gate_id, args.ownerId);
+      if (Number(claimed.changes ?? 0) === 0) return { outcome: "unavailable" } as const;
+
+      const answered: VaultSecretRequestDto = {
+        ...request,
+        status: args.outcome,
+        answeredBy: args.userId,
+      };
+      db.query(
+        `UPDATE api_messages SET vault_secret_request = ?, edited_at = ?
+       WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'vault_secret_request'`,
+      ).run(JSON.stringify(answered), args.now, args.topicId, args.messageId);
+      return {
+        outcome: "claimed",
+        gate: fromRow({
+          ...row,
+          state: "answered",
+          outcome: args.outcome,
+          answered_by: args.userId,
+        }),
+        vaultSecretRequest: answered,
+        editedAt: args.now,
+      } as const;
+    })
+    .immediate();
+}
+
+export function cancelVaultRequestGate(
+  topicId: string,
+  messageId: string,
+  ownerId: string,
+  now = new Date().toISOString(),
+): VaultRequestGateCardUpdate | null {
+  return db
+    .transaction(() => {
+      const row = db
+        .query(
+          `SELECT * FROM vault_request_gates
+         WHERE topic_id = ? AND message_id = ? ORDER BY rowid DESC LIMIT 1`,
+        )
+        .get(topicId, messageId) as VaultRequestGateRow | undefined;
+      if (!row || row.owner_id !== ownerId || row.state !== "pending") return null;
+      const result = db
+        .query(
+          `UPDATE vault_request_gates SET state = 'cancelled', updated_at = ?
+         WHERE gate_id = ? AND owner_id = ? AND state = 'pending'`,
+        )
+        .run(now, row.gate_id, ownerId);
+      if (Number(result.changes ?? 0) === 0) return null;
+      return expireVaultCard(topicId, messageId, now);
+    })
+    .immediate();
+}