@parall/parall 1.63.0 → 1.64.0

package/dist/index.bundle.mjs

@@ -52286,6 +52286,41 @@ function buildForkResultPrefix(results) {
   return blocks.join("\n\n") + "\n\n---\n\n";
 }
 
+// ../agent-core/dist/dispatch-recovery.js
+var DispatchRecovery = class {
+  scan;
+  stopped;
+  onError;
+  running = false;
+  requested = false;
+  constructor(scan, stopped, onError) {
+    this.scan = scan;
+    this.stopped = stopped;
+    this.onError = onError;
+  }
+  request = () => {
+    if (this.stopped())
+      return;
+    this.requested = true;
+    if (this.running)
+      return;
+    this.running = true;
+    void this.run();
+  };
+  async run() {
+    try {
+      while (this.requested && !this.stopped()) {
+        this.requested = false;
+        await this.scan();
+      }
+    } catch (err) {
+      this.onError(err);
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
 // ../agent-core/dist/gateway-base.js
 import * as os from "node:os";
 
@@ -52325,6 +52360,7 @@ function browserViewerRequestOptions(command, opts) {
 
 // ../sdk/dist/clip-connection-endpoints.js
 var clipConnectionEndpoints = {
+  ORG_CLIP_MCP_OAUTH_ATTEMPT: (orgId, clipId, attemptId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/mcp-oauth-attempts/${attemptId}`,
   CLIP_CONNECTIONS: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/connections`,
   CLIP_CONNECTION_ACCESS: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}/access`,
   CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`
@@ -52625,6 +52661,7 @@ var ENDPOINTS = {
   TRIGGER: (orgId, triggerId) => `${API_BASE2}/orgs/${orgId}/external-triggers/${triggerId}`,
   /** @deprecated Use TRIGGER. Same compatibility path. */
   EXTERNAL_TRIGGER: (orgId, triggerId) => `${API_BASE2}/orgs/${orgId}/external-triggers/${triggerId}`,
+  PLATFORM_TRIGGER_SCHEMA: (orgId) => `${API_BASE2}/orgs/${orgId}/platform-trigger-schema`,
   TRIGGER_RUNS: (orgId) => `${API_BASE2}/orgs/${orgId}/external-trigger-runs`,
   /** @deprecated Use TRIGGER_RUNS. Same compatibility path. */
   EXTERNAL_TRIGGER_RUNS: (orgId) => `${API_BASE2}/orgs/${orgId}/external-trigger-runs`,
@@ -52802,6 +52839,8 @@ var ENDPOINTS = {
   BILLING_CHECKOUT: (orgId) => `${API_BASE2}/orgs/${orgId}/billing/checkout`,
   BILLING_AUTO_RELOAD: (orgId) => `${API_BASE2}/orgs/${orgId}/billing/auto-reload`,
   BILLING_SETUP_INTENT: (orgId) => `${API_BASE2}/orgs/${orgId}/billing/setup-intent`,
+  BILLING_USAGE_DAILY: (orgId) => `${API_BASE2}/orgs/${orgId}/billing/usage-daily`,
+  BILLING_USAGE_HEATMAP: (orgId) => `${API_BASE2}/orgs/${orgId}/billing/usage-heatmap`,
   COMPUTE_PRICING: () => `${API_BASE2}/billing/compute-pricing`,
   // Runtime capability table (public, no auth) — SSOT for the create/settings
   // interlock: per-runtime compute modes, native model family, cross-family
@@ -52836,16 +52875,6 @@ var ENDPOINTS = {
   BROWSER_PROFILE_VIEWER_COMMAND: (orgId, profileId) => `${API_BASE2}/orgs/${orgId}/browser-profiles/${profileId}/viewer/command`,
   // Edge device endpoints
   ...edgeEndpoints,
-  ORG_BROWSER_ALIASES: (orgId) => `/api/v1/orgs/${orgId}/browser-aliases`,
-  ORG_BROWSER_ALIAS: (orgId, aliasId) => `/api/v1/orgs/${orgId}/browser-aliases/${aliasId}`,
-  ORG_BROWSER_ALIAS_READINESS_CHECKS: (orgId, aliasId) => `/api/v1/orgs/${orgId}/browser-aliases/${aliasId}/readiness-checks`,
-  ORG_BROWSER_ALIAS_READINESS_CHECK: (orgId, aliasId, checkId) => `/api/v1/orgs/${orgId}/browser-aliases/${aliasId}/readiness-checks/${checkId}`,
-  ORG_API_KEY_BROWSER_ALIAS_GRANTS: (orgId, keyId) => `/api/v1/orgs/${orgId}/api-keys/${keyId}/browser-alias-grants`,
-  ORG_API_KEY_BROWSER_ALIAS_GRANT: (orgId, keyId, aliasId) => `/api/v1/orgs/${orgId}/api-keys/${keyId}/browser-alias-grants/${aliasId}`,
-  ORG_MANAGED_ALIASES: (orgId) => `/api/v1/orgs/${orgId}/aliases`,
-  ORG_MANAGED_ALIAS: (orgId, aliasName) => `/api/v1/orgs/${orgId}/aliases/${encodeURIComponent(aliasName)}`,
-  ORG_BROWSER_ALIAS_EXECUTIONS: (orgId) => `/api/v1/orgs/${orgId}/executions`,
-  ORG_BROWSER_ALIAS_EXECUTION: (orgId, requestId) => `/api/v1/orgs/${orgId}/executions/${encodeURIComponent(requestId)}`,
   ORG_BROWSER_USE_OPERATIONS: (orgId) => `/api/v1/orgs/${orgId}/browser-use/operations`,
   ORG_BROWSER_USE_OPERATION: (orgId, operationId) => `/api/v1/orgs/${orgId}/browser-use/operations/${encodeURIComponent(operationId)}`,
   // Per-profile egress proxy (hosted Cloud Profiles; manager-only, human-only).
@@ -53392,10 +53421,62 @@ var ClipConnectionClient = class extends ChannelConversationClient {
   async putClipConnectionAccess(orgId, connId, input) {
     return this.request("PUT", ENDPOINTS.CLIP_CONNECTION_ACCESS(orgId, connId), input);
   }
+  /** Start OAuth using the reviewed platform app or provider registration ladder.
+   * Allow discovery (30s), persistence (10s), and network overhead to finish. */
+  async createClipMCPOAuthConnection(orgId, clipId, serverUrl, alias, oauthClient) {
+    return this.request("POST", ENDPOINTS.ORG_CLIP_MCP_CONFIGS(orgId, clipId), {
+      server_url: serverUrl,
+      auth_type: "oauth",
+      ...alias ? { alias } : {},
+      ...oauthClient ? { oauth_client: oauthClient } : {}
+    }, void 0, false, { timeoutMs: 5e4 });
+  }
+  /** Cancel exactly one pending attempt; requires its initiator or an org admin. */
+  async cancelClipMCPOAuthAttempt(orgId, clipId, attemptId) {
+    return this.request("DELETE", ENDPOINTS.ORG_CLIP_MCP_OAUTH_ATTEMPT(orgId, clipId, attemptId));
+  }
 };
 
 // ../sdk/dist/browser-profile-client.js
 var BrowserProfileClient = class extends ClipConnectionClient {
+  /** Metadata-only compatibility discovery. Management scope errors propagate;
+   * callers with a known Profile can execute without this discovery chain. */
+  async listBrowserUseProfiles(orgId, profileId) {
+    const me = await this.request("GET", ENDPOINTS.USERS_ME);
+    const devices = await this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
+    const data = [];
+    for (const device of devices.data) {
+      const personal = device.managed_by === "member";
+      if (personal && device.owner_user_id !== me.id)
+        continue;
+      const profiles = await this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, device.id));
+      for (const profile of profiles) {
+        if (profileId && profile.id !== profileId)
+          continue;
+        const access = personal ? null : await this.getBrowserProfileAccess(orgId, device.id, profile.name);
+        if (!personal && !access?.org_public && !(access?.grants ?? []).some((g) => g.user_id === me.id && g.grants.length > 0))
+          continue;
+        data.push({
+          profile_id: profile.id,
+          name: profile.name,
+          device_name: device.name,
+          placement: device.placement ?? "byoc",
+          lifecycle_state: profile.lifecycle_state,
+          can_access: true,
+          availability: device.placement === "hosted" ? device.hosted_state ?? "unknown" : device.status
+        });
+      }
+    }
+    return { data };
+  }
+  /** Submit once: even refresh-enabled clients must not replay browser actions. */
+  async createBrowserUseOperation(orgId, request3) {
+    return this.request("POST", ENDPOINTS.ORG_BROWSER_USE_OPERATIONS(orgId), request3, void 0, true);
+  }
+  /** Recover proof/data without creating a new browser operation. */
+  async getBrowserUseOperation(orgId, operationId, opts) {
+    return this.request("GET", ENDPOINTS.ORG_BROWSER_USE_OPERATION(orgId, operationId), void 0, void 0, false, opts);
+  }
   async getBrowserProfileAccess(orgId, edgeId, profileName) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILE_ACCESS(orgId, edgeId, profileName));
   }
@@ -53839,8 +53920,8 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
     return this.request("POST", ENDPOINTS.AUTH_OAUTH_EXCHANGE, { code });
   }
   // ---- WebSocket ----
-  async getWsTicket() {
-    return this.request("POST", ENDPOINTS.WS_TICKET);
+  async getWsTicket(req) {
+    return this.request("POST", ENDPOINTS.WS_TICKET, req);
   }
   // ---- Users ----
   async getMe() {
@@ -54827,8 +54908,8 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
    * no_action sweep otherwise. Idempotent.
    *
    * @deprecated Legacy ok-only alias — use {@link completeDispatch} with the
-   * `sources` form, which also carries `turn_outcome`. The endpoint retires
-   * at S3b (dispatch-convergence-design.md §3).
+   * `sources` form, which also carries `turn_outcome`. Retirement conditions:
+   * agent-dispatch-idempotency-design.md#compatibility.
    */
   async completeDispatchSources(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);
@@ -55071,6 +55152,9 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   async getTriggerSchema(orgId, connectionId) {
     return this.request("GET", ENDPOINTS.TRIGGER_SCHEMA(orgId, connectionId));
   }
+  async getPlatformTriggerSchema(orgId, eventTypes) {
+    return this.request("GET", ENDPOINTS.PLATFORM_TRIGGER_SCHEMA(orgId), void 0, eventTypes && eventTypes.length > 0 ? { event_types: eventTypes.join(",") } : void 0);
+  }
   async listTriggerIngressEvents(orgId, filters) {
     return this.request("GET", ENDPOINTS.TRIGGER_INGRESS_EVENTS(orgId), void 0, filters);
   }
@@ -55172,8 +55256,8 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
       return url;
     return `${this.baseUrlFor(url)}${url}`;
   }
-  async getWikiBlob(orgId, wikiId, params) {
-    const blob = await this.request("GET", ENDPOINTS.WIKI_BLOB(orgId, wikiId), void 0, params);
+  async getWikiBlob(orgId, wikiId, params, opts) {
+    const blob = await this.request("GET", ENDPOINTS.WIKI_BLOB(orgId, wikiId), void 0, params, false, opts);
     if (blob.signed_url)
       blob.signed_url = this.absoluteMediaUrl(blob.signed_url);
     return blob;
@@ -55546,6 +55630,21 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   async getBilling(orgId) {
     return this.request("GET", ENDPOINTS.BILLING(orgId));
   }
+  async getUsageDaily(orgId, opts) {
+    const params = new URLSearchParams();
+    params.set("start_date", opts.start_date);
+    params.set("end_date", opts.end_date);
+    return this.request("GET", `${ENDPOINTS.BILLING_USAGE_DAILY(orgId)}?${params}`);
+  }
+  async getUsageHeatmap(orgId, opts) {
+    const params = new URLSearchParams();
+    params.set("start_time", opts.start_time);
+    if (opts.limit != null)
+      params.set("limit", String(opts.limit));
+    if (opts.offset != null)
+      params.set("offset", String(opts.offset));
+    return this.request("GET", `${ENDPOINTS.BILLING_USAGE_HEATMAP(orgId)}?${params}`);
+  }
   async listBillingTransactions(orgId, opts) {
     const params = new URLSearchParams();
     if (opts?.cursor)
@@ -55715,12 +55814,14 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   }
   // ---- Clip registry (v3, api-server org registry — `crg_` entries) ----
   /**
-   * List registry clips visible to the org: its own plus public+approved
-   * cross-org entries. This is the surface `installRegistryClip` and clip
-   * connections operate on.
+   * List one page of registry clips visible to the org: its own plus
+   * public+approved cross-org entries, used by installs and connections.
    */
-  async listOrgRegistryClips(orgId) {
-    const resp = await this.request("GET", `${ENDPOINTS.ORG_CLIP_REGISTRY(orgId)}?limit=100`);
+  async listOrgRegistryClips(orgId, opts) {
+    const params = new URLSearchParams({ limit: String(opts?.limit ?? 100) });
+    if (opts?.offset !== void 0)
+      params.set("offset", String(opts.offset));
+    const resp = await this.request("GET", `${ENDPOINTS.ORG_CLIP_REGISTRY(orgId)}?${params}`);
     return resp ?? [];
   }
   /**
@@ -55801,7 +55902,6 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   /**
    * Read a clip's per-org exec access (by user id — humans and agents alike).
    * Org-member readable, so a denied caller can learn why exec answered
-   * `CONNECTION_NOT_ALLOWED` (retired: `CLIP_NOT_ALLOWED` / `CLIP_CONNECTION_NOT_ALLOWED`) (agents:
    * `CLIP_AGENT_NOT_ALLOWED` / `CLIP_AGENT_CONNECTION_NOT_ALLOWED`). Writing
    * it (`putClipAgentExecAccess`) is an org owner/admin's act.
    */
@@ -55882,69 +55982,6 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   async getEdgeProfileOperation(orgId, edgeId, operationId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILE_OPERATION(orgId, edgeId, operationId));
   }
-  /** Create and atomically materialize one Local BYOC Browser Alias. A replay
-   * with the same idempotency key and body returns the original stable ccn_. */
-  async createBrowserAlias(orgId, request3) {
-    return this.request("POST", ENDPOINTS.ORG_BROWSER_ALIASES(orgId), request3);
-  }
-  async listBrowserAliases(orgId) {
-    return this.request("GET", ENDPOINTS.ORG_BROWSER_ALIASES(orgId));
-  }
-  async getBrowserAlias(orgId, aliasId) {
-    return this.request("GET", ENDPOINTS.ORG_BROWSER_ALIAS(orgId, aliasId));
-  }
-  async renameBrowserAlias(orgId, aliasId, request3) {
-    return this.request("PATCH", ENDPOINTS.ORG_BROWSER_ALIAS(orgId, aliasId), request3);
-  }
-  async deleteBrowserAlias(orgId, aliasId, request3) {
-    return this.request("DELETE", ENDPOINTS.ORG_BROWSER_ALIAS(orgId, aliasId), request3);
-  }
-  /** Start one durable readiness check. The key is carried as the standard
-   * Idempotency-Key header; the request body is intentionally empty. */
-  async createBrowserAliasReadinessCheck(orgId, aliasId, request3) {
-    return this.request("POST", ENDPOINTS.ORG_BROWSER_ALIAS_READINESS_CHECKS(orgId, aliasId), void 0, void 0, false, { headers: { "Idempotency-Key": request3.idempotency_key } });
-  }
-  /** Sole durable recovery surface for one readiness request. */
-  async getBrowserAliasReadinessCheck(orgId, aliasId, checkId) {
-    return this.request("GET", ENDPOINTS.ORG_BROWSER_ALIAS_READINESS_CHECK(orgId, aliasId, checkId));
-  }
-  /** Organization Owner view. Hashes, reviewed snapshots and deltas are
-   * intentionally available only on this human-JWT management surface. */
-  async listBrowserAliasGrants(orgId, keyId) {
-    return this.request("GET", ENDPOINTS.ORG_API_KEY_BROWSER_ALIAS_GRANTS(orgId, keyId));
-  }
-  async getBrowserAliasGrant(orgId, keyId, aliasId) {
-    return this.request("GET", ENDPOINTS.ORG_API_KEY_BROWSER_ALIAS_GRANT(orgId, keyId, aliasId));
-  }
-  async replaceBrowserAliasGrant(orgId, keyId, aliasId, request3) {
-    return this.request("PUT", ENDPOINTS.ORG_API_KEY_BROWSER_ALIAS_GRANT(orgId, keyId, aliasId), request3);
-  }
-  /** Managed-key discovery. The response is already grant-filtered and never
-   * carries contract hashes, review snapshots, Edge IDs or Profile IDs. */
-  async listManagedBrowserAliases(orgId) {
-    return this.request("GET", ENDPOINTS.ORG_MANAGED_ALIASES(orgId));
-  }
-  async getManagedBrowserAlias(orgId, aliasName) {
-    return this.request("GET", ENDPOINTS.ORG_MANAGED_ALIAS(orgId, aliasName));
-  }
-  /** Accept and dispatch one @alias command. request_id is generated by the
-   * caller before local validation and is also the sole durable recovery key. */
-  async createBrowserAliasExecution(orgId, request3) {
-    return this.request("POST", ENDPOINTS.ORG_BROWSER_ALIAS_EXECUTIONS(orgId), request3);
-  }
-  async getBrowserAliasExecution(orgId, requestId) {
-    return this.request("GET", ENDPOINTS.ORG_BROWSER_ALIAS_EXECUTION(orgId, requestId));
-  }
-  /** Accept one idempotent Browser Use operation for an explicit Profile.
-   * JWT, personal, agent and managed keys use profile access. The Server resolves Profile→Edge. */
-  async createBrowserUseOperation(orgId, request3) {
-    return this.request("POST", ENDPOINTS.ORG_BROWSER_USE_OPERATIONS(orgId), request3);
-  }
-  /** Recover the durable receipt. Successful data is present only inside the
-   * Server's short encrypted result TTL; terminal proof remains afterwards. */
-  async getBrowserUseOperation(orgId, operationId) {
-    return this.request("GET", ENDPOINTS.ORG_BROWSER_USE_OPERATION(orgId, operationId));
-  }
   /**
    * Read a hosted Cloud Profile's egress-proxy status (manager-only: hosted
    * human maintainer or org admin). Sanitized — the password never comes back.
@@ -56054,7 +56091,6 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
    * - `EDGE_HOSTED_DISABLED_FOR_ORG` 403, `EDGE_REPAIR` 503 (operator-held),
    *   `EDGE_RUNTIME_UNAVAILABLE` 503 (deployment has no hosted runtime).
    * - Access errors (before side effects): human `CONNECTION_NOT_ALLOWED`.
-   *   `CLIP_NOT_ALLOWED` / `CLIP_CONNECTION_NOT_ALLOWED` are retired.
    *   Agent principals receive the historical
    *   `CLIP_AGENT_NOT_ALLOWED` / `CLIP_AGENT_CONNECTION_NOT_ALLOWED` for one
    *   release. An org owner/admin can widen access in the clip's settings.
@@ -56138,17 +56174,6 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
       timeoutMs: 4e4
     });
   }
-  /** Start a new Official OAuth MCP connection with the platform-owned app.
-   * Omitting oauth_client is load-bearing: the server resolves the exact
-   * reviewed-version binding and never falls back to DCR/CIMD cross-org. */
-  async createClipMCPOAuthConnection(orgId, clipId, serverUrl, alias, oauthClient) {
-    return this.request("POST", ENDPOINTS.ORG_CLIP_MCP_CONFIGS(orgId, clipId), {
-      server_url: serverUrl,
-      auth_type: "oauth",
-      ...alias ? { alias } : {},
-      ...oauthClient ? { oauth_client: oauthClient } : {}
-    });
-  }
   /** Re-authorize an existing MCP credential slot. */
   async initiateClipMCPOAuthById(orgId, clipId, configId, serverUrl, expectedVersion, oauthClient) {
     const req = {
@@ -56337,6 +56362,11 @@ function describeWsStateDetail(detail) {
 function isRetryableNetworkError(err) {
   return err instanceof Error && err.name === "ApiError" && "status" in err && err.status === 0;
 }
+function authRejectionFrom(err) {
+  if (!(err instanceof ApiError) || err.status !== 401)
+    return null;
+  return { status: err.status, code: err.code, message: err.message };
+}
 function isBrowserRuntime() {
   return typeof window !== "undefined";
 }
@@ -56345,9 +56375,12 @@ var ParallWs = class {
   options;
   listeners = /* @__PURE__ */ new Map();
   stateListeners = /* @__PURE__ */ new Set();
+  authInvalidListeners = /* @__PURE__ */ new Set();
   heartbeatTimer = null;
   reconnectTimer = null;
   reconnectAttempts = 0;
+  /** Ticket attempts in the current auth-invalid episode (reset on success). */
+  authAttempts = 0;
   lastSeq = 0;
   _state = "disconnected";
   intentionalClose = false;
@@ -56360,6 +56393,7 @@ var ParallWs = class {
       reconnect: true,
       reconnectInterval: 1e3,
       maxReconnectInterval: 3e4,
+      maxAuthAttempts: 3,
       ...options
     };
     this.lastSeq = options.lastSeq ?? 0;
@@ -56369,12 +56403,25 @@ var ParallWs = class {
   }
   async connect() {
     this.intentionalClose = false;
+    if (this._state === "auth-invalid")
+      this.authAttempts = 0;
     this.setupBrowserListeners();
     this.setState("connecting");
     let ticket;
     try {
       ticket = await this.options.getTicket();
     } catch (err) {
+      const authRejection = authRejectionFrom(err);
+      if (authRejection) {
+        this.authAttempts += 1;
+        if (this.authAttempts < this.options.maxAuthAttempts && this.options.reconnect) {
+          console.warn(`WS ticket auth rejected (attempt ${this.authAttempts}/${this.options.maxAuthAttempts}):`, err);
+          this.scheduleReconnect({ cause: "ticket_failed" });
+        } else {
+          this.enterAuthInvalid(authRejection);
+        }
+        return;
+      }
       if (isBrowserRuntime() && isRetryableNetworkError(err)) {
         console.warn("Failed to get WS ticket:", err);
       } else {
@@ -56421,6 +56468,7 @@ var ParallWs = class {
     this.ws.onopen = () => {
       clearTimeout(connectTimeout);
       this.reconnectAttempts = 0;
+      this.authAttempts = 0;
       this.lastReceivedAt = Date.now();
       this.setState("connected");
     };
@@ -56508,6 +56556,20 @@ var ParallWs = class {
       this.stateListeners.delete(handler);
     };
   }
+  /**
+   * Subscribe to the auth-invalid transition. Fired exactly once when the
+   * client enters the terminal 'auth-invalid' state (a second episode after
+   * a recovered reconnect fires again — one event per transition edge).
+   * Consumers: runtime bridges exit for supervisor re-mint (see
+   * @parall/agent-core gateway-base), the daemon logs recovery guidance for
+   * its machine key, UIs surface a re-authenticate action.
+   */
+  onAuthInvalid(handler) {
+    this.authInvalidListeners.add(handler);
+    return () => {
+      this.authInvalidListeners.delete(handler);
+    };
+  }
   // ---- Internal ----
   send(frame) {
     if (this.ws?.readyState === WebSocket.OPEN) {
@@ -56553,6 +56615,8 @@ var ParallWs = class {
     }
   }
   scheduleReconnect(detail) {
+    if (this._state === "auth-invalid")
+      return;
     this.setState("reconnecting", { ...detail, attempt: this.reconnectAttempts + 1 });
     this.clearReconnect();
     const base = Math.min(this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectInterval);
@@ -56568,6 +56632,20 @@ var ParallWs = class {
       this.reconnectTimer = null;
     }
   }
+  /**
+   * Enter the terminal auth-invalid state and notify consumers once. Loud on
+   * purpose: before this branch existed, a revoked key produced an infinite
+   * silent connecting→reconnecting loop with no indication that the
+   * credential — not the network — was the problem.
+   */
+  enterAuthInvalid(event) {
+    this.clearReconnect();
+    this.setState("auth-invalid");
+    console.error(`WS auth-invalid: server rejected this credential (status ${event.status}${event.code ? `, code ${event.code}` : ""}) \u2014 ${event.message}. The key is invalid, expired, or revoked; retrying it cannot succeed, so reconnects are stopped. Recover by refreshing credentials (re-login, or issue a new API key), then connect again.`);
+    for (const listener of this.authInvalidListeners) {
+      listener(event);
+    }
+  }
   /** Force-close a dead/stale connection and trigger reconnect. */
   forceReconnect(cause) {
     this.stopHeartbeat();
@@ -56672,6 +56750,16 @@ var ParallWs = class {
   }
 };
 
+// ../sdk/dist/browser-use-contract.generated.js
+var browserUseContract = { "actions": { "read": { "grant": "browser.read", "target": "optional_tab", "params": { "required": [], "properties": { "url": { "type": "string", "min_length": 1, "max_length": 8192, "schemes": ["http", "https", "about:blank"] } }, "rules": ["exactly one of params.url or target is required", "params.url creates a hidden Profile-bound tab and closes it before terminal success or failure"], "additional_properties": false }, "success": { "base": null, "fields": { "profile_id": "ebp_identifier", "url": "string", "title": "string", "article": "nullable_article" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "tabs": { "grant": "browser.read", "target": "none", "params": { "required": [], "properties": {}, "additional_properties": false }, "success": { "base": null, "fields": { "tabs": "tab_summary_array" } }, "errors": ["TAB_GONE"] }, "wait": { "grant": "browser.read", "target": "tab", "params": { "required": [], "properties": { "selector": { "type": "string", "min_length": 1, "max_length": 4096 }, "state": { "enum": ["attached", "detached", "visible", "hidden", "load"], "default": "attached" }, "timeout_ms": { "type": "integer", "minimum": 1, "maximum": 3e4, "default": 1e4 } }, "rules": ["selector is required unless state=load", "state=load forbids selector"], "additional_properties": false }, "success": { "base": "tab_state", "fields": { "matched": { "const": true } } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "snapshot": { "grant": "browser.read", "target": "tab", "params": { "required": [], "properties": { "interactive": { "type": "boolean", "default": false }, "compact": { "type": "boolean", "default": false }, "depth": { "type": "integer", "minimum": 0, "maximum": 64 } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "snapshot": "string", "snapshot_id": "identifier" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "get": { "grant": "browser.read", "target": "tab_or_ref", "params": { "required": ["prop"], "properties": { "selector": { "type": "string", "min_length": 1, "max_length": 4096 }, "prop": { "enum": ["text", "html", "value", "attr", "title", "url"] }, "name": { "type": "string", "min_length": 1, "max_length": 256 } }, "rules": ["title/url forbid locator and name", "text/html/value require exactly one locator", "attr requires exactly one locator and name"], "additional_properties": false }, "success": { "base": "tab_state", "fields": { "value": "nullable_string" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "STALE_REF", "PAGE_LOAD_FAILED"] }, "screenshot": { "grant": "browser.read", "target": "tab", "params": { "required": [], "properties": {}, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "format": { "const": "png" }, "base64": "canonical_base64" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "open": { "grant": "browser.interact", "target": "none", "params": { "required": ["url"], "properties": { "url": { "type": "string", "min_length": 1, "max_length": 8192, "schemes": ["http", "https", "about:blank"] }, "hidden": { "type": "boolean", "default": false }, "viewport": { "type": "viewport" } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": {} }, "errors": ["PAGE_LOAD_FAILED"] }, "navigate": { "grant": "browser.interact", "target": "tab", "params": { "required": ["url"], "properties": { "url": { "type": "string", "min_length": 1, "max_length": 8192, "schemes": ["http", "https", "about:blank"] } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": {} }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "viewport": { "grant": "browser.interact", "target": "tab", "params": { "required": ["width", "height"], "properties": { "width": { "type": "integer", "minimum": 320, "maximum": 3840 }, "height": { "type": "integer", "minimum": 240, "maximum": 2160 } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "viewport": "viewport" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE"] }, "click": { "grant": "browser.interact", "target": "tab_or_ref", "params": { "required": [], "properties": { "selector": "selector" }, "rules": ["exactly one of params.selector or target.ref"], "additional_properties": false }, "success": { "base": "tab_state", "fields": { "clicked": { "const": true } } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "STALE_REF", "PAGE_LOAD_FAILED"] }, "fill": { "grant": "browser.interact", "target": "tab_or_ref", "params": { "required": ["text"], "properties": { "selector": "selector", "text": { "type": "string", "allow_empty": true } }, "rules": ["exactly one of params.selector or target.ref"], "additional_properties": false }, "success": { "base": "tab_state", "fields": { "filled": { "const": true }, "characters": "non_negative_integer" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "STALE_REF", "PAGE_LOAD_FAILED"] }, "type": { "grant": "browser.interact", "target": "tab_or_ref", "params": { "required": ["text"], "properties": { "selector": "selector", "text": { "type": "string", "min_length": 1 } }, "rules": ["exactly one of params.selector or target.ref"], "additional_properties": false }, "success": { "base": "tab_state", "fields": { "typed": { "const": true }, "characters": "non_negative_integer" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "STALE_REF", "PAGE_LOAD_FAILED"] }, "press": { "grant": "browser.interact", "target": "tab", "params": { "required": ["key"], "properties": { "key": "single_unicode_character_or_named_key" }, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "pressed": { "const": true } } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "scroll": { "grant": "browser.interact", "target": "tab", "params": { "required": [], "properties": { "direction": { "enum": ["up", "down", "left", "right"], "default": "down" }, "pixels": { "type": "integer", "minimum": 1, "maximum": 1e5, "default": 500 } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "scrolled": { "const": true } } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "close": { "grant": "browser.interact", "target": "tab", "params": { "required": [], "properties": {}, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "closed": { "const": true } } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE"] }, "recover": { "grant": "browser.interact", "target": "tab", "params": { "required": [], "properties": {}, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "recovered_from_tab_id": "identifier" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] }, "eval": { "grant": "browser.advanced", "target": "tab", "params": { "required": ["expression"], "properties": { "expression": { "type": "string", "min_length": 1 }, "timeout_ms": { "type": "integer", "minimum": 1, "maximum": 15e3, "default": 15e3 } }, "additional_properties": false }, "success": { "base": "tab_state", "fields": { "value": "json_value_max_256_kib" } }, "errors": ["TAB_NOT_FOUND", "TAB_GONE", "PAGE_LOAD_FAILED"] } }, "successShapes": { "tab_state": { "required": ["tab_id", "profile_id", "browser_generation", "document_generation", "url", "title"], "fields": { "tab_id": "identifier", "profile_id": "ebp_identifier", "browser_generation": "positive_integer", "document_generation": "positive_integer", "url": "string", "title": "string" }, "additional_properties": false }, "tab_summary": { "base": "tab_state", "required_additions": ["loading"], "fields": { "loading": "boolean" }, "additional_properties": false }, "article": { "required": ["title", "byline", "excerpt", "text", "published_time", "site_name", "length"], "fields": { "title": "nullable_string", "byline": "nullable_string", "excerpt": "nullable_string", "text": "string", "published_time": "nullable_string", "site_name": "nullable_string", "length": "non_negative_integer" }, "additional_properties": false } } };
+
+// ../sdk/dist/browser-use-validation.js
+var BROWSER_USE_ACTION_SCHEMAS = browserUseContract.actions;
+var BROWSER_USE_ACTIONS = Object.freeze(Object.keys(BROWSER_USE_ACTION_SCHEMAS));
+
+// ../sdk/dist/browser-use-receipt.js
+var KEYS = "contract_version operation_id request_id profile_id profile_version profile_config_revision action required_grant phase dispatched receipt_id receipt_digest occurred_at tab_id browser_generation duration_ms result_digest result_available result_expires_at data error deadline accepted_at started_at terminal_at updated_at".split(" ");
+
 // ../agent-core/dist/fork-state.js
 var FORK_CONTINUATION_RETRY_CAP = 256;
 function forkContinuationRetryKey(event) {
@@ -56803,12 +56891,209 @@ function isTypedEvent(event) {
   return event.type !== "message" && laneTargetUri(event) === void 0;
 }
 
-// ../agent-core/dist/lane-ledger.js
+// ../agent-core/dist/lane-outcome.js
 function errorWireClass(cls) {
   if (!cls || cls === "ok" || cls === "usage_limit")
     return void 0;
   return cls;
 }
+
+// ../agent-core/dist/runtime-instance.js
+function isTurnToken(token) {
+  return token.startsWith("turn_");
+}
+
+// ../agent-core/dist/lane-input-receipts.js
+var LaneInputReceipts = class {
+  opts;
+  confirmations;
+  constructor(opts, confirmations) {
+    this.opts = opts;
+    this.confirmations = confirmations;
+  }
+  lifecycle(lane, messageIds) {
+    const explicit = lane.coverageMode === "explicit";
+    const unique = [...new Set(messageIds)];
+    const dispatchEventIds = unique.map((messageId) => lane.folded.get(messageId)).filter((id) => Boolean(id));
+    if (explicit && dispatchEventIds.length !== unique.length) {
+      throw new Error(`explicit lane ${lane.lane} is missing a folded WorkItem mapping`);
+    }
+    if (!explicit && dispatchEventIds.length === 0)
+      return void 0;
+    return {
+      deliveryKey: dispatchEventIds.join(","),
+      dispatchEventIds,
+      update: explicit ? (state, failure) => this.updateInputState(lane, dispatchEventIds, state, failure) : async () => void 0
+    };
+  }
+  async updateInputState(lane, dispatchEventIds, state, failure) {
+    lane.observedInputs ??= /* @__PURE__ */ new Map();
+    for (const id of dispatchEventIds)
+      lane.observedInputs.set(id, state);
+    let confirmed;
+    const ids = [...dispatchEventIds];
+    const failed = new Set(state === "failed" ? ids : []);
+    const sourceIds = [...lane.folded].filter(([, id]) => failed.has(id)).map(([id]) => id);
+    const request3 = {
+      lane: lane.lane,
+      target_uri: lane.targetUri,
+      thread_root_id: lane.threadRootId,
+      dispatch_event_ids: ids,
+      state,
+      session_id: lane.sessionAmbiguous ? void 0 : lane.sessionId,
+      ...state === "failed" && failure ? {
+        outcome_class: errorWireClass(failure.outcomeClass),
+        detail: failure.detail ? redactSecrets(failure.detail, this.opts.knownSecrets).slice(0, 500) : void 0
+      } : {}
+    };
+    await this.confirmations.submit(lane.lane, {
+      label: `input ${state}`,
+      send: async () => {
+        const restore = sourceIds.length ? this.opts.releaseLocalClaims?.(sourceIds) : void 0;
+        let result;
+        try {
+          result = await this.opts.client.updateDispatchInputState(this.opts.orgId, request3);
+        } catch (err) {
+          restore?.();
+          throw err;
+        }
+        if (result.recognized !== ids.length && !isTurnToken(lane.lane)) {
+          restore?.();
+          throw new ApiError(409, "input acknowledgement scope changed", "INPUT_SCOPE_CHANGED");
+        }
+        if (state === "failed") {
+          for (const sourceId of sourceIds) {
+            lane.folded.delete(sourceId);
+            lane.seen.delete(sourceId);
+          }
+        }
+        confirmed = { retry: state === "failed" && result.released > 0 };
+      }
+    });
+    return confirmed ?? { retry: false, pending: true };
+  }
+  async syncAttribution(lane) {
+    if (lane.settlementMode !== "receipt" || lane.settling || lane.sessionAmbiguous || !lane.sessionId || !lane.observedInputs?.size)
+      return;
+    const sessionId = lane.sessionId;
+    const groups = /* @__PURE__ */ new Map();
+    for (const [id, state] of lane.observedInputs) {
+      const ids = groups.get(state) ?? [];
+      ids.push(id);
+      groups.set(state, ids);
+    }
+    for (const [state, ids] of groups) {
+      await this.confirmations.submit(lane.lane, {
+        label: "input session",
+        send: async () => {
+          await this.opts.client.updateDispatchInputState(this.opts.orgId, {
+            lane: lane.lane,
+            target_uri: lane.targetUri,
+            thread_root_id: lane.threadRootId,
+            dispatch_event_ids: ids,
+            state,
+            session_id: sessionId
+          });
+        }
+      });
+    }
+  }
+};
+
+// ../agent-core/dist/lane-confirmations.js
+var LaneConfirmations = class {
+  opts;
+  pending = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** Try once inline; a retained write returns without blocking native execution. */
+  async submit(token, write) {
+    if (this.disposed)
+      return;
+    let pending = this.pending.get(token);
+    if (pending) {
+      if (pending.blocked)
+        return;
+      pending.writes.push(write);
+      return;
+    }
+    pending = { writes: [write], failures: 0, blocked: false };
+    this.pending.set(token, pending);
+    await this.run(token, pending);
+  }
+  async run(token, pending) {
+    if (pending.running || pending.blocked || this.pending.get(token) !== pending)
+      return;
+    const recovered = pending.failures > 0;
+    pending.running = Promise.resolve().then(async () => {
+      while (pending.writes.length && this.pending.get(token) === pending) {
+        const write = pending.writes[0];
+        try {
+          await write.send();
+          pending.writes.shift();
+        } catch (err) {
+          if (this.pending.get(token) !== pending)
+            return;
+          if (err instanceof ApiError && err.status === 409 && err.code === "STALE_LANE") {
+            this.pending.delete(token);
+            this.opts.onStale(token);
+            this.opts.onRecovered?.();
+            return;
+          }
+          const transient = !(err instanceof ApiError) || err.status === 0 || err.status >= 500 || err.status === 408 || err.status === 429;
+          if (!transient) {
+            pending.blocked = true;
+            this.opts.log?.error(`lane ${write.label} rejected for ${token}; confirmation retained: ${String(err)}`);
+            return;
+          }
+          pending.failures += 1;
+          this.opts.log?.warn(`lane ${write.label} unconfirmed for ${token}; retry ${pending.failures}: ${String(err)}`);
+          const delays = this.opts.delaysMs?.length ? this.opts.delaysMs : [2e3, 1e4, 3e4, 6e4, 12e4];
+          const delay = delays[Math.min(pending.failures - 1, delays.length - 1)];
+          pending.timer = setTimeout(() => {
+            pending.timer = void 0;
+            void this.run(token, pending);
+          }, delay);
+          pending.timer.unref?.();
+          return;
+        }
+      }
+      if (this.pending.get(token) === pending)
+        this.pending.delete(token);
+      if (recovered)
+        this.opts.onRecovered?.();
+    });
+    try {
+      await pending.running;
+    } finally {
+      pending.running = void 0;
+    }
+  }
+  /** Reconnect/shutdown may accelerate retries; permanent rejections stay visible. */
+  async retryNow() {
+    await Promise.all([...this.pending].map(async ([token, pending]) => {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      pending.timer = void 0;
+      await this.run(token, pending);
+    }));
+  }
+  forget(token) {
+    const pending = this.pending.get(token);
+    if (pending?.timer)
+      clearTimeout(pending.timer);
+    this.pending.delete(token);
+  }
+  dispose() {
+    this.disposed = true;
+    for (const token of this.pending.keys())
+      this.forget(token);
+  }
+};
+
+// ../agent-core/dist/lane-ledger.js
 var LedgerUnsupportedError = class extends Error {
 };
 function bindLaneSession(lane, agentSessionId) {
@@ -56834,8 +57119,24 @@ function isEndpointMissing2(err) {
 var LaneLedger = class {
   opts;
   lanes = /* @__PURE__ */ new Map();
+  confirmations;
+  inputs;
+  claimResponses = /* @__PURE__ */ new Map();
+  claims = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.opts = opts;
+    this.confirmations = new LaneConfirmations({
+      delaysMs: opts.terminalRetryDelaysMs,
+      log: opts.log,
+      onRecovered: opts.onRecovered,
+      onStale: (token) => {
+        for (const lane of this.lanes.values()) {
+          if (lane.lane === token)
+            this.forgetLane(lane);
+        }
+      }
+    });
+    this.inputs = new LaneInputReceipts(opts, this.confirmations);
   }
   get contextDir() {
     return this.opts.contextDir;
@@ -56934,7 +57235,16 @@ ${frame}` : frame;
    * incumbent completes.
    */
   async ensureLane(events) {
-    return this.ensureLaneAttempt(events, false);
+    const key = this.laneKeyFor(events[events.length - 1]);
+    const prior = this.claims.get(key);
+    const claim = (prior ? prior.catch(() => null) : Promise.resolve()).then(() => this.ensureLaneAttempt(events, false));
+    this.claims.set(key, claim);
+    try {
+      return await claim;
+    } finally {
+      if (this.claims.get(key) === claim)
+        this.claims.delete(key);
+    }
   }
   /**
    * One ensureLane pass. `reclaimed` marks the arbitration retry: STALE_LANE
@@ -56952,22 +57262,22 @@ ${frame}` : frame;
     const trigger = events[events.length - 1];
     const laneKey = this.laneKeyFor(trigger);
     let lane = this.lanes.get(laneKey);
+    if (lane?.settling)
+      return null;
     const reused = lane != null;
     if (!lane) {
       const targetUri = laneTargetUri(trigger) ?? `prll://${trigger.targetId}`;
-      let res;
-      try {
-        res = await this.opts.client.claimDispatch(this.opts.orgId, {
-          target_uri: targetUri,
-          thread_root_id: trigger.threadRootId,
-          limit: 100,
-          coverage_mode: this.opts.coverageMode ?? "implicit"
-        });
-      } catch (err) {
-        if (isEndpointMissing2(err))
-          throw new LedgerUnsupportedError("claim endpoint unavailable");
-        throw err;
-      }
+      const res = await this.claimRecoverably(laneKey, {
+        target_uri: targetUri,
+        thread_root_id: trigger.threadRootId,
+        limit: 100,
+        coverage_mode: this.opts.coverageMode ?? "implicit",
+        settlement_mode: this.opts.instanceId ? this.opts.settlementMode : void 0,
+        resume_received: this.opts.instanceId ? true : void 0,
+        instance_id: this.opts.instanceId
+      });
+      if (!res)
+        return null;
       if (!res.claimed || !res.lane) {
         if (res.reason === "empty") {
           this.opts.log?.warn(`claim for ${targetUri} came back empty \u2014 nothing foldable; leaving to the reconciler`);
@@ -56990,6 +57300,7 @@ ${frame}` : frame;
         targetUri,
         threadRootId: trigger.threadRootId,
         coverageMode: actualCoverage,
+        settlementMode: res.settlement_mode ?? "legacy",
         folded: /* @__PURE__ */ new Map(),
         framed: [],
         seen: /* @__PURE__ */ new Set(),
@@ -57024,9 +57335,8 @@ ${frame}` : frame;
           }
           return null;
         }
-        this.opts.log?.warn(`steer fold failed for ${ev.messageId} \u2014 failing closed, releasing lane: ${String(err)}`);
-        await this.release(laneKey, "steer_failed");
-        return null;
+        this.opts.log?.warn(`steer fold failed for ${ev.messageId}; preserving prior members: ${String(err)}`);
+        continue;
       }
     }
     return lane;
@@ -57040,7 +57350,7 @@ ${frame}` : frame;
   async steerLive(event) {
     const laneKey = this.laneKeyFor(event);
     const lane = this.lanes.get(laneKey);
-    if (!lane)
+    if (!lane || lane.settling)
       return null;
     if (lane.seen.has(event.messageId))
       return null;
@@ -57086,54 +57396,7 @@ ${frame}` : frame;
    * prompt or injection actually delivers (frame coverage ∪ buffered group).
    */
   inputLifecycleFor(lane, messageIds) {
-    const explicit = lane.coverageMode === "explicit";
-    const unique = [...new Set(messageIds)];
-    const dispatchEventIds = unique.map((messageId) => lane.folded.get(messageId)).filter((id) => Boolean(id));
-    if (explicit && dispatchEventIds.length !== unique.length) {
-      throw new Error(`explicit lane ${lane.lane} is missing a folded WorkItem mapping`);
-    }
-    if (!explicit && dispatchEventIds.length === 0)
-      return void 0;
-    return {
-      deliveryKey: dispatchEventIds.join(","),
-      dispatchEventIds,
-      update: explicit ? (state, failure) => this.updateInputState(lane, dispatchEventIds, state, failure) : async () => void 0
-    };
-  }
-  async updateInputState(lane, dispatchEventIds, state, failure) {
-    const failed = new Set(state === "failed" ? dispatchEventIds : []);
-    const failedSourceIds = [...lane.folded].filter(([, dispatchEventId]) => failed.has(dispatchEventId)).map(([sourceId]) => sourceId);
-    const restoreLocalClaims = failedSourceIds.length > 0 ? this.opts.releaseLocalClaims?.(failedSourceIds) : void 0;
-    try {
-      const result = await this.opts.client.updateDispatchInputState(this.opts.orgId, {
-        lane: lane.lane,
-        target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId,
-        dispatch_event_ids: dispatchEventIds,
-        state,
-        ...state === "failed" && failure ? {
-          outcome_class: errorWireClass(failure.outcomeClass),
-          detail: failure.detail ? redactSecrets(failure.detail, this.opts.knownSecrets).slice(0, 500) : void 0
-        } : {}
-      });
-      if (result.recognized !== dispatchEventIds.length) {
-        throw new Error(`input lifecycle ${state} recognized ${result.recognized}/${dispatchEventIds.length} WorkItems`);
-      }
-      if (state === "failed" && result.released === 0) {
-        restoreLocalClaims?.();
-        return { retry: false };
-      }
-    } catch (err) {
-      restoreLocalClaims?.();
-      throw err;
-    }
-    if (state === "failed") {
-      for (const [sourceId, dispatchEventId] of lane.folded) {
-        if (failed.has(dispatchEventId))
-          lane.folded.delete(sourceId);
-      }
-    }
-    return { retry: state === "failed" };
+    return this.inputs.lifecycle(lane, messageIds);
   }
   /** Carry the runtime error into the lane's forced completion. */
   markTurnError(laneKey, info = {}) {
@@ -57162,62 +57425,62 @@ ${frame}` : frame;
     const lane = this.lanes.get(laneKey);
     if (!lane || hasMoreLocal)
       return;
-    this.lanes.delete(laneKey);
-    this.removeLaneContext(lane);
+    if (lane.settling)
+      return;
+    lane.settling = true;
     const deferred = !lane.turnError && !this.deferredUnsupported ? lane.turnDeferred : void 0;
     const outcome = lane.turnError ? "error" : lane.turnDeferred ? this.deferredUnsupported ? "error" : "deferred" : "ok";
-    try {
-      const res = await this.opts.client.completeDispatch(this.opts.orgId, {
-        lane: lane.lane,
-        target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId,
-        // An error turn releases its members for retry; a deferred turn
-        // re-delivers them at retry_at without burning redrive budget
-        // (ignored by older servers, which 400 on the unknown enum — see the
-        // fallback below).
-        turn_outcome: outcome,
-        ...deferred ? {
-          outcome_class: deferred.outcomeClass,
-          ...deferred.retryAt ? { retry_at: deferred.retryAt } : {}
-        } : {},
-        // An error complete carries the bridge's classification and redacted
-        // evidence so the server can persist WHY on the released row
-        // (agent-health-alerting-design.md §4.5). usage_limit never travels
-        // with error: it is the deferred contract, and a server that rejected
-        // deferred (deferredUnsupported) also predates the class field.
-        ...outcome === "error" && lane.turnError ? {
-          ...errorWireClass(lane.turnError.outcomeClass) ? { outcome_class: errorWireClass(lane.turnError.outcomeClass) } : {},
-          ...lane.turnError.detail ? { detail: lane.turnError.detail.slice(0, 500) } : {}
-        } : {},
-        session_id: lane.sessionAmbiguous ? void 0 : lane.sessionId
-      });
-      if (res.swept_no_action > 0 || res.redriven) {
-        this.opts.log?.info(`lane complete for ${lane.targetUri}: swept ${res.swept_no_action} no_action, redriven=${res.redriven}`);
-      }
-    } catch (err) {
-      if (isStaleLane(err)) {
-        this.opts.log?.info(`lane complete skipped for ${lane.targetUri} \u2014 taken over`);
-        return;
-      }
-      if (outcome === "deferred" && err instanceof ApiError && err.status === 400) {
-        this.deferredUnsupported = true;
-        this.opts.log?.warn(`server rejected turn_outcome=deferred for ${lane.targetUri} \u2014 falling back to error completes`);
+    const request3 = {
+      lane: lane.lane,
+      target_uri: lane.targetUri,
+      thread_root_id: lane.threadRootId,
+      // An error turn releases its members for retry; a deferred turn
+      // re-delivers them at retry_at without burning redrive budget
+      // (ignored by older servers, which 400 on the unknown enum — see the
+      // fallback below).
+      turn_outcome: outcome,
+      ...deferred ? {
+        outcome_class: deferred.outcomeClass,
+        ...deferred.retryAt ? { retry_at: deferred.retryAt } : {}
+      } : {},
+      // An error complete carries the bridge's classification and redacted
+      // evidence so the server can persist WHY on the released row
+      // (agent-health-alerting-design.md §4.5). usage_limit never travels
+      // with error: it is the deferred contract, and a server that rejected
+      // deferred (deferredUnsupported) also predates the class field.
+      ...outcome === "error" && lane.turnError ? {
+        ...errorWireClass(lane.turnError.outcomeClass) ? { outcome_class: errorWireClass(lane.turnError.outcomeClass) } : {},
+        ...lane.turnError.detail ? { detail: lane.turnError.detail.slice(0, 500) } : {}
+      } : {},
+      session_id: lane.sessionAmbiguous ? void 0 : lane.sessionId
+    };
+    let fallback = false;
+    await this.confirmations.submit(lane.lane, {
+      label: "complete",
+      send: async () => {
         try {
-          await this.opts.client.completeDispatch(this.opts.orgId, {
-            lane: lane.lane,
-            target_uri: lane.targetUri,
-            thread_root_id: lane.threadRootId,
+          await this.opts.client.completeDispatch(this.opts.orgId, fallback ? {
+            lane: request3.lane,
+            target_uri: request3.target_uri,
+            thread_root_id: request3.thread_root_id,
             turn_outcome: "error"
-          });
-        } catch (fallbackErr) {
-          if (isStaleLane(fallbackErr))
-            return;
-          this.opts.log?.warn(`lane complete (deferred fallback) failed for ${lane.targetUri}: ${String(fallbackErr)}`);
+          } : request3);
+        } catch (err) {
+          if (!fallback && outcome === "deferred" && err instanceof ApiError && err.status === 400) {
+            this.deferredUnsupported = true;
+            fallback = true;
+            await this.opts.client.completeDispatch(this.opts.orgId, {
+              lane: request3.lane,
+              target_uri: request3.target_uri,
+              thread_root_id: request3.thread_root_id,
+              turn_outcome: "error"
+            });
+          } else
+            throw err;
         }
-        return;
+        this.forgetLane(lane);
       }
-      this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
-    }
+    });
   }
   /**
    * Renew one lane by its key — the external runtime-activity hook for
@@ -57239,6 +57502,8 @@ ${frame}` : frame;
    * write's incumbency check anyway.
    */
   maybeRenew(lane) {
+    if (isTurnToken(lane.lane))
+      return;
     const now = Date.now();
     const ttl = lane.leaseTtlMs ?? 10 * 6e4;
     const until = lane.leaseUntilMs ?? now;
@@ -57269,26 +57534,40 @@ ${frame}` : frame;
    */
   async release(laneKey, reason = "unspecified", info) {
     const lane = this.lanes.get(laneKey);
-    if (!lane)
+    if (!lane || lane.settling)
       return;
-    this.lanes.delete(laneKey);
-    this.removeLaneContext(lane);
-    try {
-      const wireClass = errorWireClass(info?.outcomeClass);
-      const outcome = info && (wireClass || info.detail) ? {
-        ...wireClass ? { outcome_class: wireClass } : {},
-        ...info.detail ? { detail: info.detail } : {}
-      } : void 0;
-      await this.opts.client.releaseDispatchLane(this.opts.orgId, lane.lane, reason, outcome);
-    } catch (err) {
-      this.opts.log?.warn(`lane release (${reason}) failed for ${lane.targetUri}: ${String(err)}`);
-    }
+    lane.settling = true;
+    const wireClass = errorWireClass(info?.outcomeClass);
+    const outcome = info && (wireClass || info.detail) ? {
+      ...wireClass ? { outcome_class: wireClass } : {},
+      ...info.detail ? { detail: redactSecrets(info.detail, this.opts.knownSecrets).slice(0, 500) } : {}
+    } : void 0;
+    await this.confirmations.submit(lane.lane, {
+      label: "release",
+      send: async () => {
+        await this.opts.client.releaseDispatchLane(this.opts.orgId, lane.lane, reason, outcome);
+        this.forgetLane(lane);
+      }
+    });
   }
   async releaseAll(reason = "shutdown") {
+    await this.confirmations.retryNow();
     const keys = [...this.lanes.keys()];
     for (const key of keys) {
       await this.release(key, reason);
     }
+    for (const [key, claim] of this.claimResponses) {
+      if (!claim.response?.lane)
+        continue;
+      const token = claim.response.lane;
+      await this.confirmations.submit(token, {
+        label: "unconsumed claim release",
+        send: async () => {
+          await this.opts.client.releaseDispatchLane(this.opts.orgId, token, reason);
+          this.claimResponses.delete(key);
+        }
+      });
+    }
   }
   /** True when any lane is currently active (used by shutdown logging). */
   get activeCount() {
@@ -57303,18 +57582,57 @@ ${frame}` : frame;
    * — the caller must skip processing.
    */
   async claimTyped(ref) {
-    let res;
+    const key = `typed:${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`}`;
+    if (this.claims.has(key))
+      return null;
+    if (ref.dispatchEventId && this.lanes.has(laneKeyForTarget(`dsp:${ref.dispatchEventId}`)))
+      return null;
+    const claim = this.claimTypedAttempt(ref);
+    this.claims.set(key, claim);
     try {
-      res = await this.opts.client.claimDispatch(this.opts.orgId, {
-        dispatch_event_id: ref.dispatchEventId,
-        source_type: ref.dispatchEventId ? void 0 : ref.sourceType,
-        source_id: ref.dispatchEventId ? void 0 : ref.sourceId
+      return await claim;
+    } finally {
+      this.claims.delete(key);
+    }
+  }
+  async claimRecoverably(key, request3) {
+    let claim = this.claimResponses.get(key);
+    if (!claim) {
+      claim = { request: request3 };
+      this.claimResponses.set(key, claim);
+      const captured = claim;
+      await this.confirmations.submit(`claim:${key}`, {
+        label: "claim",
+        send: async () => {
+          try {
+            captured.response = await this.opts.client.claimDispatch(this.opts.orgId, request3);
+          } catch (err) {
+            if (isEndpointMissing2(err))
+              captured.unsupported = true;
+            else
+              throw err;
+          }
+        }
       });
-    } catch (err) {
-      if (isEndpointMissing2(err))
-        throw new LedgerUnsupportedError("claim endpoint unavailable");
-      throw err;
     }
+    if (claim.unsupported) {
+      this.claimResponses.delete(key);
+      throw new LedgerUnsupportedError("claim endpoint unavailable");
+    }
+    if (!claim.response)
+      return null;
+    this.claimResponses.delete(key);
+    return claim.response;
+  }
+  async claimTypedAttempt(ref) {
+    const res = await this.claimRecoverably(`typed:${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`}`, {
+      dispatch_event_id: ref.dispatchEventId,
+      source_type: ref.dispatchEventId ? void 0 : ref.sourceType,
+      source_id: ref.dispatchEventId ? void 0 : ref.sourceId,
+      instance_id: this.opts.instanceId
+    });
+    if (!res)
+      return null;
     if (!res.claimed || !res.lane || !res.events?.length) {
       if (res.reason === "stale") {
         this.opts.log?.info(`typed dispatch ${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`} resolved by the server as stale (${res.stale_reason ?? "unspecified"})`);
@@ -57326,6 +57644,8 @@ ${frame}` : frame;
     }
     const workItem = res.events[0];
     const targetUri = `dsp:${workItem.id}`;
+    if (this.lanes.has(laneKeyForTarget(targetUri)))
+      return null;
     const leaseUntilMs = Date.parse(res.lease_until ?? "");
     const lane = {
       laneKey: laneKeyForTarget(targetUri),
@@ -57354,7 +57674,34 @@ ${frame}` : frame;
     const lane = this.lanes.get(laneKey);
     if (!lane)
       return;
-    this.lanes.delete(laneKey);
+    this.confirmations.forget(lane.lane);
+    this.forgetLane(lane);
+  }
+  syncInputAttribution(lane) {
+    return this.inputs.syncAttribution(lane);
+  }
+  async confirmTyped(lane, send) {
+    if (lane.settling)
+      return;
+    lane.settling = true;
+    await this.confirmations.submit(lane.lane, {
+      label: "typed complete",
+      send: async () => {
+        await send();
+        this.forgetLane(lane);
+      }
+    });
+  }
+  retryConfirmations() {
+    return this.confirmations.retryNow();
+  }
+  dispose() {
+    this.confirmations.dispose();
+  }
+  forgetLane(lane) {
+    if (this.lanes.get(lane.laneKey) !== lane)
+      return;
+    this.lanes.delete(lane.laneKey);
     this.removeLaneContext(lane);
   }
   /**
@@ -58297,7 +58644,7 @@ async function dispatchLaneGroup(host, opts) {
 }
 async function dispatchLaneGroupInner(host, opts) {
   const ledger = host.laneLedger;
-  const event = opts.events[opts.events.length - 1];
+  let event = opts.events[opts.events.length - 1];
   let lane;
   try {
     lane = await runInPhaseSpan("claim", () => ledger.ensureLane(opts.events));
@@ -58315,18 +58662,51 @@ async function dispatchLaneGroupInner(host, opts) {
     }
     return "foreign";
   }
+  const foldedEvents = opts.events.filter((ev) => lane.folded.has(ev.messageId));
+  for (const ev of opts.events) {
+    if (!lane.folded.has(ev.messageId))
+      host.dispatchedMessages.delete(ev.messageId);
+  }
+  if (foldedEvents.length === 0) {
+    await ledger.completeIfIdle(lane.laneKey, unsettledInjections(host, opts.sessionKey) || opts.hasMoreLocal());
+    return "foreign";
+  }
+  opts = { ...opts, events: foldedEvents, earlier: foldedEvents.slice(0, -1) };
+  event = foldedEvents[foldedEvents.length - 1];
   const pending = ledger.takeFrame(lane);
   const frame = pending.frame;
   if (!frame && opts.events.every((ev) => lane.seen.has(ev.messageId))) {
     host.opts.log?.info(`lane group for ${event.messageId} already rendered by the server frame \u2014 no turn`);
     const acknowledge = host.opts.dispatchAdapter.acknowledgeDiscardedInjection?.bind(host.opts.dispatchAdapter);
+    const withdrawn = [];
     if (acknowledge) {
-      for (const ev of opts.events) {
-        const deliveryKey = lane.folded.get(ev.messageId);
-        if (deliveryKey)
-          acknowledge(opts.sessionKey, deliveryKey);
-      }
+      try {
+        for (const ev of opts.events) {
+          const deliveryKey = lane.folded.get(ev.messageId);
+          if (!deliveryKey)
+            continue;
+          if (await acknowledge(opts.sessionKey, deliveryKey) === "cancelled")
+            withdrawn.push(ev);
+        }
+      } catch (err) {
+        host.opts.log?.warn(`discarded input acknowledgement failed for ${event.messageId}: ${String(err)}`);
+      }
+    }
+    if (withdrawn.length > 0 && !opts.withdrawnRetry) {
+      for (const ev of withdrawn)
+        host.dispatchedMessages.delete(ev.messageId);
+      await ledger.completeIfIdle(lane.laneKey, unsettledInjections(host, opts.sessionKey));
+      if (ledger.getForEvent(event))
+        return "no_turn";
+      return dispatchLaneGroupInner(host, {
+        ...opts,
+        events: withdrawn,
+        earlier: withdrawn.slice(0, -1),
+        withdrawnRetry: true
+      });
     }
+    for (const ev of opts.events)
+      host.dispatchedMessages.delete(ev.messageId);
     await runInPhaseSpan("settle", () => ledger.completeIfIdle(lane.laneKey, unsettledInjections(host, opts.sessionKey) || opts.hasMoreLocal()));
     return "no_turn";
   }
@@ -58512,17 +58892,24 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
           viaLegacyAck = true;
           resolved = settleAck(await runInPhaseSpan("settle", () => hooks.legacyAck(claimed.typedDispatchEventId)));
         } else {
-          const outcome = await runInPhaseSpan("settle", () => resolveDispatchByID(host, claimed.typedDispatchEventId, claimed.lane));
-          if (outcome === "unsupported") {
-            host.typedByIdCompleteUnsupported = true;
-            host.opts.log?.warn("server predates the by-id dispatch complete \u2014 falling back to the legacy typed ack");
-            viaLegacyAck = true;
-            resolved = settleAck(await runInPhaseSpan("settle", () => hooks.legacyAck(claimed.typedDispatchEventId)));
-          } else if (outcome === "stale") {
-            resolved = true;
-          } else {
-            resolved = outcome === "ok";
-          }
+          await runInPhaseSpan("settle", () => ledger.confirmTyped(claimed, async () => {
+            try {
+              await host.opts.client.completeDispatch(host.opts.config.org_id, {
+                dispatch_event_id: claimed.typedDispatchEventId,
+                lane: claimed.lane,
+                turn_outcome: "ok"
+              });
+            } catch (err) {
+              if (!isByIDCompleteUnsupported(err))
+                throw err;
+              host.typedByIdCompleteUnsupported = true;
+              if (!settleAck(await hooks.legacyAck(claimed.typedDispatchEventId))) {
+                throw new Error("legacy typed acknowledgement unconfirmed");
+              }
+              await host.opts.client.releaseDispatchLane(host.opts.config.org_id, claimed.lane);
+            }
+          }));
+          resolved = true;
         }
       }
     } catch (err) {
@@ -58532,7 +58919,8 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
       settle(resolved);
       span.setAttribute("dispatch.lane_result", resolved ? "dispatched" : "released");
       if (resolved && !viaLegacyAck) {
-        ledger.dropLocal(claimed.laneKey);
+        if (!claimed.settling)
+          ledger.dropLocal(claimed.laneKey);
       } else {
         await runInPhaseSpan("settle", () => ledger.completeIfIdle(claimed.laneKey, false).catch(() => {
         }));
@@ -58972,6 +59360,19 @@ var DispatchInactivityDeadline = class {
       this.onExpire();
     }, delayMs);
   }
+  /**
+   * Re-arm after an expiry that was only reported, not acted on (the
+   * no-abort default: a long silent turn is logged at intervals, never
+   * killed — attached-turn-ownership).
+   */
+  rearm() {
+    if (this.disposed || this.timeoutMs <= 0)
+      return;
+    this.expired = false;
+    this.lastActivityAt = Date.now();
+    if (!this.timer)
+      this.arm(this.timeoutMs);
+  }
   dispose() {
     if (this.disposed)
       return;
@@ -59881,6 +60282,7 @@ function recordToolCall(sessionKey) {
 }
 
 // ../agent-core/dist/gateway-base.js
+var AUTH_INVALID_EXIT_CODE = 86;
 var TYPED_EVENT_KINDS = {
   task_assign: { type: "task", ackSourceType: "task_activity" },
   task_update: { type: "task", ackSourceType: "task_activity" },
@@ -60050,14 +60452,9 @@ var ParallAgentGateway = class {
   pendingRestartNotification = null;
   laneLedger;
   stepPersister;
-  // Single entry point for session active/idle writes — serialized
-  // desired-state reconciler (see session-lifecycle.ts). The gateway only
-  // declares turn boundaries; ordering, retries and stale-finish rejection
-  // live in the coordinator.
+  // Session lifecycle owns ordering, retries and stale-finish rejection.
   sessionLifecycle;
-  // Normal fork teardown use case: seal → drain → close → release. The
-  // gateway only triggers it; ordering and ownership live in the finalizer
-  // (see fork-session-finalizer.ts).
+  // ForkSessionFinalizer owns seal → drain → close → release.
   forkFinalizer;
   // Sticky fallback: flipped when the server predates the ledger (claim
   // endpoint 404) so every subsequent dispatch uses the legacy flow.
@@ -60073,10 +60470,12 @@ var ParallAgentGateway = class {
   SHUTDOWN_DEADLINE_MS;
   FORK_DEADLINE_MS;
   DISPATCH_DEADLINE_MS;
+  INACTIVITY_WARN_MS;
   constructor(opts) {
     this.opts = opts;
     opts = this.opts = { ...opts, log: redactLogger(opts.log, [opts.config.api_key]) };
     if (opts.dispatchContextDir) {
+      const recovery = new DispatchRecovery(() => this.catchUpFromDispatch(), () => this.shuttingDown, (err) => opts.log?.warn(`dispatch recovery failed: ${String(err)}`));
       this.laneLedger = new LaneLedger({
         client: opts.client,
         orgId: opts.config.org_id,
@@ -60084,12 +60483,17 @@ var ParallAgentGateway = class {
         log: opts.log,
         knownSecrets: [opts.config.api_key],
         coverageMode: opts.dispatchAdapter.inputLifecycleMode ?? "implicit",
+        settlementMode: opts.dispatchAdapter.inputSettlementMode,
+        instanceId: opts.instanceId,
+        terminalRetryDelaysMs: opts.laneTerminalRetryDelaysMs,
+        onRecovered: recovery.request,
         releaseLocalClaims: (sourceIds) => releaseLocalMessageClaims(this.dispatchedMessages, sourceIds)
       });
     }
     this.SHUTDOWN_DEADLINE_MS = opts.shutdownDeadlineMs ?? 6e4;
-    this.FORK_DEADLINE_MS = opts.forkDeadlineMs ?? 2 * 60 * 6e4;
-    this.DISPATCH_DEADLINE_MS = opts.dispatchDeadlineMs ?? 20 * 6e4;
+    this.FORK_DEADLINE_MS = opts.forkDeadlineMs ?? 0;
+    this.DISPATCH_DEADLINE_MS = opts.dispatchDeadlineMs ?? 0;
+    this.INACTIVITY_WARN_MS = opts.inactivityWarnMs ?? 30 * 6e4;
     this.unsubscribeRuntimeActivity = opts.dispatchAdapter.subscribeRuntimeActivity?.((event) => this.handleRuntimeActivity(event));
     this.stepPersister = new StepPersister({
       client: opts.client,
@@ -60167,12 +60571,34 @@ var ParallAgentGateway = class {
       }
     });
     this.opts.log?.info(`connecting to ${this.opts.connectionLabel ?? "Parall WS"}...`);
+    let settled = false;
+    let onSettled = null;
+    const finish = async (opts) => {
+      if (settled)
+        return;
+      settled = true;
+      await this.shutdown(opts);
+      onSettled?.();
+    };
+    ws.onAuthInvalid((event) => {
+      const exitCode = this.opts.authInvalidExitCode === void 0 ? AUTH_INVALID_EXIT_CODE : this.opts.authInvalidExitCode;
+      log?.error(`AUTH-INVALID agent=${this.opts.agentUserId} status=${event.status}${event.code ? ` code=${event.code}` : ""} \u2014 the server rejected this runtime's credential (${event.message}); the key is invalid, expired, or revoked.`);
+      if (exitCode === null) {
+        log?.error("AUTH-INVALID: reconnects are stopped and this account gateway has shut down. Refresh this account\u2019s credential and start it again; other accounts in this process are unaffected.");
+      } else {
+        log?.error(`AUTH-INVALID: reconnects are stopped. Exiting with code ${exitCode} so the supervisor can re-mint the launch credential and restart this agent; if no supervisor manages this process, replace its PRLL_API_KEY and start it again.`);
+        process.exitCode = exitCode;
+      }
+      void finish({ skipDrain: true });
+    });
     await ws.connect();
     return new Promise((resolve3) => {
-      abortSignal.addEventListener("abort", async () => {
-        await this.shutdown();
+      if (settled) {
         resolve3();
-      });
+        return;
+      }
+      onSettled = resolve3;
+      abortSignal.addEventListener("abort", () => void finish());
     });
   }
   tryClaimMessage(id) {
@@ -60590,6 +61016,7 @@ var ParallAgentGateway = class {
         step_id: null,
         dispatch_event_id: activeLane?.typedDispatchEventId ?? activeLane?.folded.get(event.messageId) ?? null,
         lane: activeLane?.lane ?? null,
+        settlement_mode: activeLane?.settlementMode ?? "legacy",
         target_uri: activeLane?.targetUri ?? null,
         thread_root_id: activeLane?.threadRootId ?? null,
         // Typed binding hint for the CLI: which task this dispatch is about
@@ -60609,13 +61036,19 @@ var ParallAgentGateway = class {
         threadRootId: contextBody.thread_root_id
       });
       this.inFlightDispatches++;
-      const dispatchDeadline = this.dispatchInactivityDeadlines.start(sessionKey, this.DISPATCH_DEADLINE_MS, () => {
-        this.opts.log?.warn(`dispatch inactivity deadline exceeded (${this.DISPATCH_DEADLINE_MS}ms) for ${event.messageId} on ${sessionKey}; aborting`);
-        try {
-          this.opts.dispatchAdapter.abortDispatch?.(sessionKey);
-        } catch (err) {
-          this.opts.log?.warn(`abortDispatch threw for ${sessionKey}: ${String(err)}`);
+      const abortAfterMs = this.DISPATCH_DEADLINE_MS;
+      const dispatchDeadline = this.dispatchInactivityDeadlines.start(sessionKey, abortAfterMs > 0 ? abortAfterMs : this.INACTIVITY_WARN_MS, () => {
+        if (abortAfterMs > 0) {
+          this.opts.log?.warn(`dispatch inactivity deadline exceeded (${abortAfterMs}ms) for ${event.messageId} on ${sessionKey}; aborting`);
+          try {
+            this.opts.dispatchAdapter.abortDispatch?.(sessionKey);
+          } catch (err) {
+            this.opts.log?.warn(`abortDispatch threw for ${sessionKey}: ${String(err)}`);
+          }
+          return;
         }
+        this.opts.log?.warn(`no runtime output for ${Math.round(this.INACTIVITY_WARN_MS / 6e4)} min on ${sessionKey} (${event.messageId}); the turn stays open \u2014 only the runtime finishing or a process restart ends it`);
+        dispatchDeadline.rearm();
       });
       let binding = this.sessionBindings.get(sessionKey);
       let inputStepsCreated = false;
@@ -60646,6 +61079,7 @@ var ParallAgentGateway = class {
               binding = await runInPhaseSpan("session", () => this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2));
               if (activeLane) {
                 bindLaneSession(activeLane, binding.agentSessionId);
+                await this.laneLedger?.syncInputAttribution(activeLane);
               }
               if (event.targetType === "channel_conversation" && binding.agentSessionId !== priorAgentSessionId) {
                 try {
@@ -61285,9 +61719,11 @@ var ParallAgentGateway = class {
         const activeFork = createActiveForkState(fork, event.targetId, continuationPrefix);
         this.forkStates.set(event.targetId, activeFork);
         this.dispatchState.activeForks.set(event.targetId, fork.sessionKey);
-        activeFork.deadlineTimer = setTimeout(() => {
-          this.abortFork(event.targetId, `deadline exceeded (${this.FORK_DEADLINE_MS}ms)`);
-        }, this.FORK_DEADLINE_MS);
+        if (this.FORK_DEADLINE_MS > 0) {
+          activeFork.deadlineTimer = setTimeout(() => {
+            this.abortFork(event.targetId, `deadline exceeded (${this.FORK_DEADLINE_MS}ms)`);
+          }, this.FORK_DEADLINE_MS);
+        }
         const firstEventPromise = new Promise((resolve3) => {
           activeFork.queue.push({ event, resolve: resolve3 });
         });
@@ -61486,12 +61922,16 @@ ${fullSummary}` : fullSummary;
     this.sessionId = data.session_id ?? "";
     if (this.forkStates.size > 0) {
       const targetIds = [...this.forkStates.keys()];
-      log?.info(`aborting ${targetIds.length} active fork(s) on reconnect`);
-      for (const targetId of targetIds) {
-        this.abortFork(targetId, "ws reconnect");
+      if (this.opts.instanceId) {
+        log?.info(`${targetIds.length} active fork(s) continue across the reconnect`);
+      } else {
+        log?.info(`aborting ${targetIds.length} active fork(s) on reconnect`);
+        for (const targetId of targetIds) {
+          this.abortFork(targetId, "ws reconnect");
+        }
       }
     }
-    if (this.laneLedger && this.inFlightDispatches === 0 && this.laneLedger.activeCount > 0) {
+    if (this.laneLedger && !this.opts.instanceId && this.inFlightDispatches === 0 && this.laneLedger.activeCount > 0) {
       log?.info(`releasing ${this.laneLedger.activeCount} stale lane(s) on reconnect`);
       await this.laneLedger.releaseAll();
     }
@@ -61538,6 +61978,7 @@ ${fullSummary}` : fullSummary;
           uptime: os.uptime()
         });
       }, intervalSec * 1e3);
+      await this.laneLedger?.retryConfirmations();
       this.catchUpFromDispatch().catch((err) => {
         log?.warn(`dispatch catch-up failed: ${String(err)}`);
       });
@@ -61623,10 +62064,12 @@ ${fullSummary}` : fullSummary;
   notifyDrainWaiters() {
     this.drainGate.notify();
   }
-  async shutdown() {
+  async shutdown(opts = { skipDrain: false }) {
     this.shuttingDown = true;
     this.idleCompact.abort?.();
-    if (!this.isDrained()) {
+    if (opts.skipDrain && !this.isDrained()) {
+      this.opts.log?.warn(`skipping drain (credential rejected): ${this.inFlightDispatches} dispatch(es), ${this.inFlightRuntimeTurns} runtime-initiated turn(s) abandoned to server redelivery`);
+    } else if (!this.isDrained()) {
       this.opts.log?.info(`draining ${this.inFlightDispatches} in-flight dispatch(es), ${this.inFlightRuntimeTurns} runtime-initiated turn(s), runtime busy=${this.adapterBusy()}, deadline ${this.SHUTDOWN_DEADLINE_MS}ms`);
       await this.drainGate.wait(this.SHUTDOWN_DEADLINE_MS);
       if (!this.isDrained()) {
@@ -61637,7 +62080,7 @@ ${fullSummary}` : fullSummary;
     }
     if (this.heartbeatTimer)
       clearInterval(this.heartbeatTimer);
-    if (this.laneLedger && this.laneLedger.activeCount > 0) {
+    if (this.laneLedger) {
       this.opts.log?.info(`releasing ${this.laneLedger.activeCount} lane(s) on shutdown`);
       await this.laneLedger.releaseAll();
     }
@@ -61657,6 +62100,8 @@ ${fullSummary}` : fullSummary;
       this.opts.log?.warn(`${lifecycleRemaining} session lifecycle write(s) unreconciled at shutdown`);
     }
     this.sessionLifecycle.dispose();
+    await this.laneLedger?.retryConfirmations();
+    this.laneLedger?.dispose();
     this.opts.ws.disconnect();
     this.unsubscribeRuntimeActivity?.();
     this.opts.log?.info(`disconnected`);
@@ -63429,13 +63874,18 @@ var parallGateway = {
         runtimeKey: orchestratorKey,
         runtimeRef: { hostname: os2.hostname(), pid: process.pid },
         dispatchAdapter,
+        // One OpenClaw host embeds many account gateways in one process: a
+        // rejected credential stops THIS account's gateway only — it must
+        // not set the host-wide process exit code or claim the process is
+        // exiting.
+        authInvalidExitCode: null,
         // Opts openclaw into the dispatch ledger (claim/fold/complete +
         // idempotent reply effects) — the same shared-gateway machinery
         // claude/codex ride; openclaw stays buffer-only (no mid-turn steer),
         // which the ledger does not require. Replies already flow through
         // @parall/cli, which reads PRLL_CONTEXT_DIR (injected in hooks.ts)
         // to bind dispatch_lane + reply effect keys.
-        // Design: docs/engineering-design/dispatch-convergence-design.md §7 (S2).
+        // Design: docs/engineering-design/agent-dispatch-idempotency-design.md#effects.
         dispatchContextDir: dispatchLaneContextDir(stateDir),
         // Per-session context file (PRLL_CONTEXT_FILE contract) — the CLI's
         // TYPED dispatch binding (parall tasks update → task_update effect)