@standardagents/builder 0.26.0 → 0.27.1

package/dist/index.js

@@ -1097,6 +1097,25 @@ async function awaitBounded(work, budgetMs, label) {
     if (timer) clearTimeout(timer);
   }
 }
+function chunkCarriesPayload(chunk) {
+  switch (chunk.type) {
+    case "content-delta":
+    case "reasoning-delta":
+      return typeof chunk.delta === "string" && chunk.delta.length > 0;
+    case "tool-call-delta":
+      return typeof chunk.argumentsDelta === "string" && chunk.argumentsDelta.length > 0;
+    case "tool-call-start":
+    case "tool-call-done":
+    case "finish":
+    case "image-done":
+    case "web-search-done":
+    case "provider-tool-done":
+    case "error":
+      return true;
+    default:
+      return false;
+  }
+}
 function modelSupportsImageInput(modelDef) {
   const supportsImages = modelDef.capabilities?.supportsImages;
   if (typeof supportsImages === "boolean") {
@@ -1908,7 +1927,7 @@ var init_LLMRequest = __esm({
                 if (next.done) break;
                 const chunk = next.value;
                 state.thread.instance.noteExecutionProgress?.();
-                if (firstChunkAt === 0) {
+                if (firstChunkAt === 0 && chunkCarriesPayload(chunk)) {
                   firstChunkAt = Date.now();
                   emitLogPatch({ time_to_first_token_ms: firstChunkAt - requestSentAt });
                 }
@@ -13166,6 +13185,38 @@ var init_ThreadStateImpl = __esm({
         }
         await this._threadInstance.setValue(key, value);
       }
+      // Account-wide sibling of the thread KV: values scoped to the thread's user,
+      // shared across every thread that user owns (backed by the singleton
+      // DurableAgentBuilder `user_values` table).
+      async getUserValue(key) {
+        const userId = this._metadata.user_id;
+        if (!userId) return null;
+        const stub = this._getAgentBuilderStub();
+        if (typeof stub.getUserValue !== "function") {
+          throw new Error("getUserValue is not supported by this runtime");
+        }
+        return await stub.getUserValue(userId, key);
+      }
+      async setUserValue(key, value) {
+        const userId = this._metadata.user_id;
+        if (!userId) {
+          throw new Error("setUserValue requires a thread with an associated user");
+        }
+        const stub = this._getAgentBuilderStub();
+        if (typeof stub.setUserValue !== "function") {
+          throw new Error("setUserValue is not supported by this runtime");
+        }
+        await stub.setUserValue(userId, key, value);
+      }
+      async listUserValues(options = {}) {
+        const userId = this._metadata.user_id;
+        if (!userId) return { entries: [], total: 0 };
+        const stub = this._getAgentBuilderStub();
+        if (typeof stub.listUserValues !== "function") {
+          throw new Error("listUserValues is not supported by this runtime");
+        }
+        return stub.listUserValues(userId, options);
+      }
       // ─────────────────────────────────────────────────────────────────────────
       // Client-forwarded tools
       // ─────────────────────────────────────────────────────────────────────────
@@ -13209,7 +13260,7 @@ var init_ThreadStateImpl = __esm({
         const instance = this._threadInstance;
         const toolCallId = this._flowState?.currentToolCall?.id;
         const mustPark = request.requestPermission != null && await this.forwardedCallNeedsApproval(request);
-        if (mustPark && toolCallId && this._executionState && typeof instance.dispatchClientTool === "function" && typeof instance.hasBridge === "function" && instance.hasBridge()) {
+        if (mustPark && toolCallId && this._executionState && typeof instance.dispatchClientTool === "function" && typeof instance.hasBridge === "function" && await instance.hasBridge()) {
           const side = this._flowState?.currentSide === "b" ? "b" : "a";
           await instance.dispatchClientTool(request, toolCallId, side);
           this._executionState.stop();
@@ -23259,8 +23310,38 @@ var migration33 = {
   }
 };
 
+// src/durable-objects/migrations/034_add_owner_fencing.ts
+var migration34 = {
+  version: 34,
+  name: "add_owner_fencing",
+  async up(sql) {
+    sql.exec(`
+      CREATE TABLE IF NOT EXISTS pending_client_calls (
+        tool_call_id TEXT PRIMARY KEY,
+        tool TEXT NOT NULL,
+        args TEXT,
+        request_permission TEXT,
+        risk INTEGER,
+        side TEXT NOT NULL DEFAULT 'a',
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL
+      )
+    `);
+    const tableInfo = sql.exec(`PRAGMA table_info(pending_client_calls)`).toArray();
+    const hasColumn = (name) => tableInfo.some((col) => col.name === name);
+    if (!hasColumn("dispatched_client_id")) {
+      sql.exec(`ALTER TABLE pending_client_calls ADD COLUMN dispatched_client_id TEXT`);
+    }
+    if (!hasColumn("dispatched_generation")) {
+      sql.exec(
+        `ALTER TABLE pending_client_calls ADD COLUMN dispatched_generation INTEGER NOT NULL DEFAULT 0`
+      );
+    }
+  }
+};
+
 // src/durable-objects/migrations/index.ts
-var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17, migration18, migration19, migration20, migration21, migration22, migration23, migration24, migration25, migration26, migration27, migration28, migration29, migration30, migration31, migration32, migration33];
+var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17, migration18, migration19, migration20, migration21, migration22, migration23, migration24, migration25, migration26, migration27, migration28, migration29, migration30, migration31, migration32, migration33, migration34];
 var LATEST_SCHEMA_VERSION = migrations.length;
 
 // src/durable-objects/DurableThread.ts
@@ -24060,6 +24141,61 @@ function isQualifiedName(name) {
 
 // src/durable-objects/DurableThread.ts
 init_sessionTools();
+
+// src/durable-objects/bridge-owner.ts
+var EXECUTION_OWNER_KEY = "execution_owner";
+var CLAIM_MODES = /* @__PURE__ */ new Set([
+  "none",
+  "if_unowned",
+  "if_stale",
+  "takeover"
+]);
+function parseBridgeClientParams(url) {
+  const readParam = (name) => {
+    const raw = url.searchParams.get(name);
+    if (raw == null) return null;
+    const trimmed = raw.trim().slice(0, 256);
+    return trimmed.length > 0 ? trimmed : null;
+  };
+  const clientId = readParam("client_id");
+  const info = {
+    clientId,
+    clientName: readParam("client_name"),
+    clientKind: readParam("client_kind")
+  };
+  const rawClaim = readParam("claim");
+  let claim;
+  if (rawClaim && CLAIM_MODES.has(rawClaim)) {
+    claim = rawClaim;
+  } else {
+    claim = clientId ? "if_unowned" : "none";
+  }
+  return { info, claim };
+}
+function resolveBridgeClaim(options) {
+  const { clientId, claim, owner, ownerHasLiveSocket } = options;
+  if (!clientId || claim === "none") return false;
+  if (!owner) return true;
+  if (owner.client_id === clientId) return true;
+  if (claim === "takeover") return true;
+  if (claim === "if_stale") return !ownerHasLiveSocket;
+  return false;
+}
+function selectBridgeSocket(candidates, ownerClientId) {
+  if (ownerClientId == null) {
+    return candidates.length > 0 ? candidates[0].socket : null;
+  }
+  let legacyFallback = null;
+  for (const candidate of candidates) {
+    if (candidate.clientId === ownerClientId) return candidate.socket;
+    if (candidate.clientId == null && legacyFallback == null) {
+      legacyFallback = candidate.socket;
+    }
+  }
+  return legacyFallback;
+}
+
+// src/durable-objects/DurableThread.ts
 init_code_execution();
 var DEFAULT_CLIENT_TOOL_TIMEOUT_MS = 5 * 60 * 1e3;
 var BRIDGE_LIVENESS_TIMEOUT_MS = 20 * 1e3;
@@ -24225,6 +24361,14 @@ var DurableThread = class _DurableThread extends DurableObject {
   // Last time we heard anything (incl. heartbeat pings) from each bridge socket,
   // used to detect a dead/half-open client quickly while a tool is in flight.
   bridgeLastSeen = /* @__PURE__ */ new Map();
+  // Identity each bridge socket presented at connect (`client_id` etc.). Legacy
+  // clients present nothing and map to null fields. Restored from the socket
+  // attachment after hibernation.
+  bridgeClientInfo = /* @__PURE__ */ new Map();
+  // In-memory mirror of the thread-KV `execution_owner` record. `undefined`
+  // means "not loaded yet"; `null` means "loaded, no owner". Kept coherent by
+  // setValue() so external KV writes (release/reassign) invalidate it too.
+  executionOwnerCache = void 0;
   pendingClientCalls = /* @__PURE__ */ new Map();
   alarmQueue;
   alarmQueueRearmed = false;
@@ -24295,6 +24439,11 @@ var DurableThread = class _DurableThread extends DurableObject {
       } else if (attachment?.type === "bridge") {
         this.bridgeSockets.add(ws);
         this.bridgeLastSeen.set(ws, Date.now());
+        this.bridgeClientInfo.set(ws, {
+          clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
+          clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
+          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
+        });
       }
     }
   }
@@ -24788,6 +24937,9 @@ var DurableThread = class _DurableThread extends DurableObject {
   async setValue(key, value) {
     await this.ensureMigrated();
     this.assertValidThreadValueKey(key);
+    if (key === EXECUTION_OWNER_KEY) {
+      this.executionOwnerCache = this.parseExecutionOwner(value);
+    }
     const updatedAt = Date.now() * 1e3;
     if (value === null || value === void 0) {
       await this.ctx.storage.sql.exec(`DELETE FROM thread_values WHERE key = ?`, key);
@@ -25435,9 +25587,9 @@ var DurableThread = class _DurableThread extends DurableObject {
    * Each migration is run in order, starting from the current version + 1.
    */
   async runMigrations(fromVersion) {
-    for (const migration44 of migrations) {
-      if (migration44.version > fromVersion) {
-        await migration44.up(this.ctx.storage.sql);
+    for (const migration46 of migrations) {
+      if (migration46.version > fromVersion) {
+        await migration46.up(this.ctx.storage.sql);
       }
     }
   }
@@ -27484,20 +27636,208 @@ ${resultContent}${attachmentSummary}`;
   async handleBridgeWebSocketUpgrade(request) {
     const pair = new WebSocketPair();
     const [client, server] = Object.values(pair);
+    const requestUrl2 = new URL(request.url);
+    const { info, claim } = parseBridgeClientParams(requestUrl2);
+    const routeThreadId = requestUrl2.pathname.match(/\/api\/threads\/([^/]+)\//)?.[1] ?? null;
     this.ctx.acceptWebSocket(server);
-    server.serializeAttachment({ type: "bridge" });
+    server.serializeAttachment({
+      type: "bridge",
+      clientId: info.clientId,
+      clientName: info.clientName,
+      clientKind: info.clientKind
+    });
     this.bridgeSockets.add(server);
     this.bridgeLastSeen.set(server, Date.now());
+    this.bridgeClientInfo.set(server, info);
+    if (info.clientId) {
+      for (const ws of Array.from(this.bridgeSockets)) {
+        if (ws === server) continue;
+        if ((this.bridgeClientInfo.get(ws)?.clientId ?? null) !== info.clientId) continue;
+        this.bridgeSockets.delete(ws);
+        this.bridgeLastSeen.delete(ws);
+        this.bridgeClientInfo.delete(ws);
+        try {
+          ws.send(JSON.stringify({ type: "superseded" }));
+        } catch {
+        }
+        try {
+          ws.close(4001, "Superseded by a newer connection from this client");
+        } catch {
+        }
+      }
+    }
+    let owner = await this.getExecutionOwner();
+    let claimRefused = null;
+    const shouldClaim = resolveBridgeClaim({
+      clientId: info.clientId,
+      claim,
+      owner,
+      ownerHasLiveSocket: owner ? this.hasLiveBridgeSocketForClient(owner.client_id, server) : false
+    });
+    if (shouldClaim && info.clientId) {
+      const changed = !owner || owner.client_id !== info.clientId;
+      const ownerLive = owner ? this.hasLiveBridgeSocketForClient(owner.client_id, server) : false;
+      if (changed && ownerLive && await this.hasInFlightClientCalls()) {
+        claimRefused = "in_flight";
+      } else {
+        const previous = owner;
+        const next = {
+          client_id: info.clientId,
+          client_name: info.clientName,
+          client_kind: info.clientKind,
+          claimed_at: Date.now(),
+          generation: changed ? (owner?.generation ?? 0) + 1 : owner?.generation ?? 1
+        };
+        await this.setExecutionOwner(next);
+        owner = next;
+        if (changed) {
+          this.broadcastOwnerChanged(next, server);
+          if (previous) await this.failStalePendingWork(previous, routeThreadId);
+        }
+      }
+    }
+    const isOwner = owner ? info.clientId === owner.client_id : true;
     try {
-      server.send(JSON.stringify({ type: "bridge_ready", threadId: this.ctx.id.toString() }));
+      server.send(
+        JSON.stringify({
+          type: "bridge_ready",
+          threadId: this.ctx.id.toString(),
+          owner: isOwner,
+          ...claimRefused ? { claim_refused: claimRefused } : {},
+          current_owner: owner ? {
+            client_id: owner.client_id,
+            client_name: owner.client_name ?? null,
+            client_kind: owner.client_kind ?? null,
+            generation: owner.generation
+          } : null
+        })
+      );
     } catch {
     }
-    void this.resendPendingClientCalls(server);
+    if (isOwner) {
+      void this.resendPendingClientCalls(server);
+    }
     return new Response(null, {
       status: 101,
       webSocket: client
     });
   }
+  /** Parse a raw KV value into an {@link ExecutionOwner}, or null. */
+  parseExecutionOwner(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const record = value;
+    if (typeof record.client_id !== "string" || record.client_id.length === 0) {
+      return null;
+    }
+    return {
+      client_id: record.client_id,
+      client_name: typeof record.client_name === "string" ? record.client_name : null,
+      client_kind: typeof record.client_kind === "string" ? record.client_kind : null,
+      claimed_at: typeof record.claimed_at === "number" ? record.claimed_at : 0,
+      generation: typeof record.generation === "number" ? record.generation : 0
+    };
+  }
+  /** Load (and cache) the thread's persisted execution-owner record. */
+  async getExecutionOwner() {
+    if (this.executionOwnerCache !== void 0) return this.executionOwnerCache;
+    const raw = await this.getValue(EXECUTION_OWNER_KEY);
+    this.executionOwnerCache = this.parseExecutionOwner(raw);
+    return this.executionOwnerCache;
+  }
+  /** Owner id from the in-memory mirror only (for sync paths); null when
+   *  unloaded or unowned — both degrade to the historical any-socket rule. */
+  currentExecutionOwnerId() {
+    return this.executionOwnerCache?.client_id ?? null;
+  }
+  /** Persist + cache the execution-owner record (null releases ownership). */
+  async setExecutionOwner(owner) {
+    await this.setValue(EXECUTION_OWNER_KEY, owner);
+  }
+  /** Whether the given client id has a live bridge socket (excluding `except`). */
+  hasLiveBridgeSocketForClient(clientId, except) {
+    const now = Date.now();
+    for (const ws of this.bridgeSockets) {
+      if (ws === except) continue;
+      if (ws.readyState !== WebSocket.OPEN) continue;
+      const lastSeen = this.bridgeLastSeen.get(ws) ?? 0;
+      if (now - lastSeen > BRIDGE_LIVENESS_TIMEOUT_MS) continue;
+      if ((this.bridgeClientInfo.get(ws)?.clientId ?? null) === clientId) return true;
+    }
+    return false;
+  }
+  /** Tell every other bridge socket that execution ownership moved. */
+  broadcastOwnerChanged(owner, except) {
+    const frame = JSON.stringify({
+      type: "owner_changed",
+      owner: {
+        client_id: owner.client_id,
+        client_name: owner.client_name ?? null,
+        client_kind: owner.client_kind ?? null,
+        generation: owner.generation
+      }
+    });
+    for (const ws of this.bridgeSockets) {
+      if (ws === except) continue;
+      try {
+        if (ws.readyState === WebSocket.OPEN) ws.send(frame);
+      } catch {
+      }
+    }
+  }
+  /** Whether any forwarded call is mid-flight (blocking await or parked). */
+  async hasInFlightClientCalls() {
+    if (this.pendingClientCalls.size > 0) return true;
+    await this.ensureMigrated();
+    await this.ensurePendingClientTable();
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM pending_client_calls WHERE status = 'pending'`
+    );
+    return Number(cursor.toArray()[0]?.total ?? 0) > 0;
+  }
+  /**
+   * Ownership moved away from a dead client: settle everything that was
+   * dispatched to it. In-memory blocking calls fail immediately; parked
+   * durable calls get an error result and the turn resumes — re-sending them
+   * to the NEW owner would silently re-run the operation on a different
+   * machine's filesystem, which is worse than an honest retryable error.
+   */
+  async failStalePendingWork(previous, threadId) {
+    for (const id of Array.from(this.pendingClientCalls.keys())) {
+      this.settleClientCall(id, {
+        ok: false,
+        error: "The client executing this operation was replaced before it finished.",
+        data: { noClient: true }
+      });
+    }
+    try {
+      await this.ensureMigrated();
+      await this.ensurePendingClientTable();
+      const cursor = await this.ctx.storage.sql.exec(
+        `SELECT tool_call_id FROM pending_client_calls
+          WHERE status = 'pending' AND dispatched_client_id = ?`,
+        previous.client_id
+      );
+      const sides = /* @__PURE__ */ new Set();
+      for (const row of cursor.toArray()) {
+        const delivered = await this.deliverClientToolResult(
+          row.tool_call_id,
+          false,
+          void 0,
+          "The client executing this operation was replaced before it finished. Retry if the work is still needed.",
+          previous.client_id,
+          previous.generation
+        );
+        if (delivered) sides.add(delivered.side);
+      }
+      if (threadId) {
+        for (const side of sides) {
+          await this.continueExecution(threadId, side);
+        }
+      }
+    } catch (error) {
+      console.error("[DurableThread] failStalePendingWork:", error);
+    }
+  }
   /**
    * Forward a tool operation to a connected bridge client and await its result.
    *
@@ -27506,7 +27846,8 @@ ${resultContent}${attachmentSummary}`;
    * denial) for the model to reason about.
    */
   async callClientTool(request) {
-    const socket = this.getOpenBridgeSocket();
+    const owner = await this.getExecutionOwner();
+    const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
     if (!socket) {
       return {
         ok: false,
@@ -27537,7 +27878,7 @@ ${resultContent}${attachmentSummary}`;
           });
         }
       }, 5e3);
-      this.pendingClientCalls.set(id, { resolve: resolve2, timer, liveness });
+      this.pendingClientCalls.set(id, { resolve: resolve2, timer, liveness, socket });
       const frame = JSON.stringify({
         type: "tool_request",
         id,
@@ -27571,6 +27912,7 @@ ${resultContent}${attachmentSummary}`;
   markBridgeDead(socket) {
     this.bridgeSockets.delete(socket);
     this.bridgeLastSeen.delete(socket);
+    this.bridgeClientInfo.delete(socket);
     try {
       socket.close();
     } catch {
@@ -27578,33 +27920,42 @@ ${resultContent}${attachmentSummary}`;
     this.failPendingClientCallsIfNoBridge();
   }
   /**
-   * Return the first bridge socket that is open AND still proving liveness,
-   * pruning dead ones. A half-open client (idle NAT/proxy drop) keeps a
+   * Return the bridge socket a forwarded call should be dispatched to, pruning
+   * dead ones. A half-open client (idle NAT/proxy drop) keeps a
    * `readyState === OPEN` socket that never fires close/error, so we also treat
    * a socket we haven't heard from within {@link BRIDGE_LIVENESS_TIMEOUT_MS} as
    * dead. The CLI heartbeats every few seconds, so this only trips on a truly
    * gone client — and it means we won't dispatch a forwarded call into the void.
+   *
+   * With an execution owner recorded, only the owner's socket (or, as a
+   * back-compat fallback, an unidentified legacy socket) is eligible; with no
+   * owner, the first live socket wins as it always has.
    */
-  getOpenBridgeSocket() {
+  getOpenBridgeSocket(ownerClientId) {
     const now = Date.now();
+    const live = [];
     for (const ws of Array.from(this.bridgeSockets)) {
       const lastSeen = this.bridgeLastSeen.get(ws) ?? 0;
       if (ws.readyState === WebSocket.OPEN && now - lastSeen <= BRIDGE_LIVENESS_TIMEOUT_MS) {
-        return ws;
+        live.push({ socket: ws, clientId: this.bridgeClientInfo.get(ws)?.clientId ?? null });
+        continue;
       }
       this.bridgeSockets.delete(ws);
       this.bridgeLastSeen.delete(ws);
+      this.bridgeClientInfo.delete(ws);
       try {
         ws.close();
       } catch {
       }
     }
-    return null;
+    return selectBridgeSocket(live, ownerClientId);
   }
   /** Resolve an in-flight forwarded tool call from a client `tool_response`. */
-  resolveClientCall(payload) {
+  resolveClientCall(ws, payload) {
     const id = typeof payload.id === "string" ? payload.id : null;
     if (!id) return;
+    const pending = this.pendingClientCalls.get(id);
+    if (pending?.socket && pending.socket !== ws) return;
     this.settleClientCall(id, {
       ok: payload.ok === true,
       result: typeof payload.result === "string" ? payload.result : void 0,
@@ -27613,11 +27964,14 @@ ${resultContent}${attachmentSummary}`;
     });
   }
   /**
-   * When the last bridge client disconnects, fail any in-flight forwarded tool
-   * calls so the agent loop doesn't hang waiting on a client that is gone.
+   * When the last bridge client that could serve forwarded calls disconnects,
+   * fail any in-flight ones so the agent loop doesn't hang waiting on a client
+   * that is gone. Uses the in-memory owner mirror (sync path); when the mirror
+   * isn't loaded this degrades to the historical any-socket check, and the
+   * per-call liveness interval still catches a dead dispatch target.
    */
   failPendingClientCallsIfNoBridge() {
-    if (this.getOpenBridgeSocket()) return;
+    if (this.getOpenBridgeSocket(this.currentExecutionOwnerId())) return;
     for (const id of Array.from(this.pendingClientCalls.keys())) {
       this.settleClientCall(id, {
         ok: false,
@@ -27626,9 +27980,11 @@ ${resultContent}${attachmentSummary}`;
       });
     }
   }
-  /** Whether a bridge client is connected right now (used to decide durable park). */
-  hasBridge() {
-    return this.getOpenBridgeSocket() !== null;
+  /** Whether a bridge client that can execute forwarded calls is connected
+   *  right now (used to decide durable park). */
+  async hasBridge() {
+    const owner = await this.getExecutionOwner();
+    return this.getOpenBridgeSocket(owner?.client_id ?? null) !== null;
   }
   // ─── Durable forwarded tool calls (park & resume) ──────────────────────────
   // A permission-gated forwarded call must not hold the agent loop open across
@@ -27645,7 +28001,9 @@ ${resultContent}${attachmentSummary}`;
         risk INTEGER,
         side TEXT NOT NULL DEFAULT 'a',
         status TEXT NOT NULL DEFAULT 'pending',
-        created_at INTEGER NOT NULL
+        created_at INTEGER NOT NULL,
+        dispatched_client_id TEXT,
+        dispatched_generation INTEGER NOT NULL DEFAULT 0
       )
     `);
   }
@@ -27670,13 +28028,31 @@ ${resultContent}${attachmentSummary}`;
       side,
       Date.now()
     );
-    return { dispatched: this.sendClientToolRequest(toolCallId, request) };
+    return { dispatched: await this.sendClientToolRequest(toolCallId, request) };
   }
-  /** Send one durable `tool_request` frame to the bridge if a client is connected. */
-  sendClientToolRequest(toolCallId, request) {
-    const socket = this.getOpenBridgeSocket();
+  /**
+   * Send one durable `tool_request` frame to the bridge if a client is
+   * connected — and stamp the pending row with the identity+generation it was
+   * dispatched to, fencing the eventual HTTP delivery to that client. A
+   * legacy (unidentified) executor leaves the row unstamped, keeping the
+   * historical accept-anything delivery for old CLIs.
+   */
+  async sendClientToolRequest(toolCallId, request) {
+    const owner = await this.getExecutionOwner();
+    const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
     if (!socket) return false;
+    const socketClientId = this.bridgeClientInfo.get(socket)?.clientId ?? null;
+    const fenced = owner && socketClientId === owner.client_id;
+    const generation = fenced ? owner.generation : 0;
     try {
+      await this.ctx.storage.sql.exec(
+        `UPDATE pending_client_calls
+            SET dispatched_client_id = ?, dispatched_generation = ?
+          WHERE tool_call_id = ? AND status = 'pending'`,
+        fenced ? owner.client_id : null,
+        generation,
+        toolCallId
+      );
       socket.send(
         JSON.stringify({
           type: "tool_request",
@@ -27685,7 +28061,8 @@ ${resultContent}${attachmentSummary}`;
           tool: request.tool,
           args: request.args ?? {},
           requestPermission: request.requestPermission ?? null,
-          risk: typeof request.risk === "number" ? request.risk : null
+          risk: typeof request.risk === "number" ? request.risk : null,
+          generation
         })
       );
       this.bridgeLastSeen.set(socket, Date.now());
@@ -27721,9 +28098,21 @@ ${resultContent}${attachmentSummary}`;
   /** Re-send all pending durable requests to a freshly connected bridge socket. */
   async resendPendingClientCalls(socket) {
     try {
+      const owner = await this.getExecutionOwner();
+      const socketClientId = this.bridgeClientInfo.get(socket)?.clientId ?? null;
+      const fenced = owner && socketClientId === owner.client_id;
+      const generation = fenced ? owner.generation : 0;
       const pending = await this.getPendingClientCalls();
       for (const p of pending) {
         if (socket.readyState !== WebSocket.OPEN) break;
+        await this.ctx.storage.sql.exec(
+          `UPDATE pending_client_calls
+              SET dispatched_client_id = ?, dispatched_generation = ?
+            WHERE tool_call_id = ? AND status = 'pending'`,
+          fenced ? owner.client_id : null,
+          generation,
+          p.toolCallId
+        );
         socket.send(
           JSON.stringify({
             type: "tool_request",
@@ -27732,7 +28121,8 @@ ${resultContent}${attachmentSummary}`;
             tool: p.tool,
             args: p.args,
             requestPermission: p.requestPermission,
-            risk: p.risk
+            risk: p.risk,
+            generation
           })
         );
       }
@@ -27745,15 +28135,21 @@ ${resultContent}${attachmentSummary}`;
    * call resolved. Returns the side to continue, or null if there is no pending
    * call (unknown id or already resolved — the delivery is idempotent).
    */
-  async deliverClientToolResult(toolCallId, ok, result, error) {
+  async deliverClientToolResult(toolCallId, ok, result, error, deliveredByClientId, deliveredGeneration) {
     await this.ensureMigrated();
     await this.ensurePendingClientTable();
     const pendingCursor = await this.ctx.storage.sql.exec(
-      `SELECT side, status FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
+      `SELECT side, status, dispatched_client_id, dispatched_generation
+         FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
       toolCallId
     );
     const pending = pendingCursor.toArray()[0];
     if (!pending || pending.status !== "pending") return null;
+    if (pending.dispatched_client_id) {
+      if (pending.dispatched_client_id !== deliveredByClientId || Number(pending.dispatched_generation ?? 0) !== (deliveredGeneration ?? -1)) {
+        return null;
+      }
+    }
     const side = pending.side === "b" ? "b" : "a";
     const content = ok ? result ?? "" : `Error: ${error ?? "tool failed"}`;
     const toolStatus = ok ? "success" : "error";
@@ -27989,7 +28385,7 @@ ${resultContent}${attachmentSummary}`;
           parsed = null;
         }
         if (parsed && parsed.type === "tool_response") {
-          this.resolveClientCall(parsed);
+          this.resolveClientCall(ws, parsed);
           return;
         }
       }
@@ -28011,6 +28407,7 @@ ${resultContent}${attachmentSummary}`;
     } else if (attachment?.type === "bridge") {
       this.bridgeSockets.delete(ws);
       this.bridgeLastSeen.delete(ws);
+      this.bridgeClientInfo.delete(ws);
       this.failPendingClientCallsIfNoBridge();
     }
   }
@@ -28031,6 +28428,7 @@ ${resultContent}${attachmentSummary}`;
     } else if (attachment?.type === "bridge") {
       this.bridgeSockets.delete(ws);
       this.bridgeLastSeen.delete(ws);
+      this.bridgeClientInfo.delete(ws);
       this.failPendingClientCallsIfNoBridge();
     }
   }
@@ -29591,7 +29989,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
 };
 
 // src/durable-objects/agentbuilder-migrations/0001_initial.ts
-var migration34 = {
+var migration35 = {
   version: 1,
   async up(sql) {
     sql.exec(`
@@ -29690,7 +30088,7 @@ var migration34 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0002_add_tenvs_properties.ts
-var migration35 = {
+var migration36 = {
   version: 2,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN tenvs TEXT`);
@@ -29702,7 +30100,7 @@ var migration35 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0003_add_parent_and_terminated.ts
-var migration36 = {
+var migration37 = {
   version: 3,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN parent TEXT REFERENCES threads(id)`);
@@ -29715,7 +30113,7 @@ var migration36 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0004_add_env_tables.ts
-var migration37 = {
+var migration38 = {
   version: 4,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN env TEXT`);
@@ -29739,7 +30137,7 @@ var migration37 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0005_add_pending_subagent_env_requests.ts
-var migration38 = {
+var migration39 = {
   version: 5,
   async up(sql) {
     sql.exec(`
@@ -29765,7 +30163,7 @@ var migration38 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0006_add_env_value_types.ts
-var migration39 = {
+var migration40 = {
   version: 6,
   async up(sql) {
     sql.exec(
@@ -29780,7 +30178,7 @@ var migration39 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0007_platform_identity_replica.ts
-var migration40 = {
+var migration41 = {
   version: 7,
   async up(sql) {
     sql.exec(`ALTER TABLE users ADD COLUMN platform_user_id TEXT`);
@@ -29809,7 +30207,7 @@ var migration40 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0008_add_skills.ts
-var migration41 = {
+var migration42 = {
   version: 8,
   async up(sql) {
     sql.exec(`
@@ -29840,7 +30238,7 @@ var migration41 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0009_add_user_permissions.ts
-var migration42 = {
+var migration43 = {
   version: 9,
   async up(sql) {
     sql.exec(`ALTER TABLE users ADD COLUMN permissions TEXT`);
@@ -29851,7 +30249,7 @@ var migration42 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0010_add_device_logins.ts
-var migration43 = {
+var migration44 = {
   version: 10,
   async up(sql) {
     sql.exec(`
@@ -29870,9 +30268,32 @@ var migration43 = {
   }
 };
 
+// src/durable-objects/agentbuilder-migrations/0011_add_user_values.ts
+var migration45 = {
+  version: 11,
+  async up(sql) {
+    sql.exec(`
+      CREATE TABLE IF NOT EXISTS user_values (
+        user_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (user_id, key)
+      )
+    `);
+    sql.exec(`
+      CREATE INDEX IF NOT EXISTS idx_user_values_user ON user_values(user_id)
+    `);
+    sql.exec(`
+      INSERT OR REPLACE INTO _metadata (key, value) VALUES ('schema_version', '11')
+    `);
+  }
+};
+
 // src/durable-objects/agentbuilder-migrations/index.ts
-var migrations2 = [migration34, migration35, migration36, migration37, migration38, migration39, migration40, migration41, migration42, migration43];
-var LATEST_SCHEMA_VERSION2 = 10;
+var migrations2 = [migration35, migration36, migration37, migration38, migration39, migration40, migration41, migration42, migration43, migration44, migration45];
+var LATEST_SCHEMA_VERSION2 = 11;
 
 // src/utils/crypto.ts
 var CryptoUtil = class {
@@ -30634,9 +31055,9 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     }
   }
   async runMigrations(fromVersion) {
-    for (const migration44 of migrations2) {
-      if (migration44.version > fromVersion) {
-        await migration44.up(this.ctx.storage.sql);
+    for (const migration46 of migrations2) {
+      if (migration46.version > fromVersion) {
+        await migration46.up(this.ctx.storage.sql);
       }
     }
   }
@@ -31180,6 +31601,117 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
   async patchUserEnv(userId, params) {
     await this.patchScopedEnv("user", userId, params);
   }
+  // ============================================================
+  // Per-user durable key-value store (account-wide, not thread-tied)
+  //
+  // The account-scoped sibling of the per-thread `thread_values` store:
+  // JSON documents keyed by (user_id, key), for state a user carries across
+  // every thread on the instance (e.g. a coding client's machine/daemon
+  // registry). Mirrors thread-KV semantics — null/undefined deletes.
+  // ============================================================
+  assertValidUserValueKey(key) {
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("User value key must be a non-empty string");
+    }
+    if (key.length > 512) {
+      throw new Error("User value key must be at most 512 characters");
+    }
+  }
+  assertValidUserValueUserId(userId) {
+    if (typeof userId !== "string" || userId.length === 0) {
+      throw new Error("User value user_id must be a non-empty string");
+    }
+  }
+  /** Read one JSON value from a user's account-wide key-value store. */
+  async getUserValue(userId, key) {
+    await this.ensureMigrated();
+    this.assertValidUserValueUserId(userId);
+    this.assertValidUserValueKey(key);
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT value FROM user_values WHERE user_id = ? AND key = ? LIMIT 1`,
+      userId,
+      key
+    );
+    const raw = cursor.toArray()[0]?.value;
+    if (raw === void 0) return null;
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      throw new Error(
+        `Stored user value for key "${key}" is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /** Write one JSON value to a user's account-wide store; null/undefined deletes. */
+  async setUserValue(userId, key, value) {
+    await this.ensureMigrated();
+    this.assertValidUserValueUserId(userId);
+    this.assertValidUserValueKey(key);
+    if (value === null || value === void 0) {
+      await this.ctx.storage.sql.exec(
+        `DELETE FROM user_values WHERE user_id = ? AND key = ?`,
+        userId,
+        key
+      );
+      return;
+    }
+    let serialized;
+    try {
+      serialized = JSON.stringify(value);
+    } catch (error) {
+      throw new Error(
+        `User value for key "${key}" is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (typeof serialized !== "string") {
+      throw new Error(`User value for key "${key}" is not JSON-serializable`);
+    }
+    const now = Date.now();
+    await this.ctx.storage.sql.exec(
+      `INSERT INTO user_values (user_id, key, value, created_at, updated_at)
+       VALUES (?1, ?2, ?3, ?4, ?4)
+       ON CONFLICT(user_id, key) DO UPDATE SET
+         value = excluded.value,
+         updated_at = excluded.updated_at`,
+      userId,
+      key,
+      serialized,
+      now
+    );
+  }
+  /** List a user's account-wide values, optionally filtered by key prefix. */
+  async listUserValues(userId, options = {}) {
+    await this.ensureMigrated();
+    this.assertValidUserValueUserId(userId);
+    const limit = Math.min(Math.max(Math.trunc(options.limit ?? 100), 1), 500);
+    const offset = Math.max(Math.trunc(options.offset ?? 0), 0);
+    const prefix = typeof options.prefix === "string" && options.prefix.length > 0 ? options.prefix : null;
+    const escapedPrefix = prefix ? `${prefix.replace(/[\\%_]/g, (m) => `\\${m}`)}%` : null;
+    const where = escapedPrefix ? `WHERE user_id = ? AND key LIKE ? ESCAPE '\\'` : `WHERE user_id = ?`;
+    const whereArgs = escapedPrefix ? [userId, escapedPrefix] : [userId];
+    const totalCursor = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM user_values ${where}`,
+      ...whereArgs
+    );
+    const total = Number(totalCursor.toArray()[0]?.total ?? 0);
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT key, value, updated_at FROM user_values ${where}
+       ORDER BY key ASC LIMIT ? OFFSET ?`,
+      ...whereArgs,
+      limit,
+      offset
+    );
+    const entries = cursor.toArray().map((row) => {
+      let value = null;
+      try {
+        value = JSON.parse(row.value);
+      } catch {
+        value = null;
+      }
+      return { key: row.key, value, updated_at: Number(row.updated_at) };
+    });
+    return { entries, total, limit, offset };
+  }
   async getMissingRequiredScopedSubagentEnv(params) {
     await this.ensureMigrated();
     const requiredScoped = await this.getRequiredScopedVariableNamesForAgent(