@parall/parall 1.51.0 → 1.52.1

package/dist/index.bundle.mjs

@@ -51594,6 +51594,7 @@ var ENDPOINTS = {
   DISPATCH_BY_MESSAGES: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/by-messages`,
   DISPATCH_CLAIM: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/claim`,
   DISPATCH_STEER: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/steer`,
+  DISPATCH_INPUT_STATE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/input-state`,
   DISPATCH_COMPLETE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/complete`,
   DISPATCH_COMPLETE_SOURCES: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/complete-sources`,
   DISPATCH_RELEASE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/release`,
@@ -51691,7 +51692,11 @@ var ENDPOINTS = {
   // Pinix Hub catalog proxy above is a different, id-less surface)
   ORG_CLIP_REGISTRY: (orgId) => `/api/v1/orgs/${orgId}/clip-registry`,
   ORG_CLIP_INSTALL: (orgId) => `/api/v1/orgs/${orgId}/clips/install`,
-  ORG_CLIPS_INSTALLED: (orgId) => `/api/v1/orgs/${orgId}/clips/installed`
+  ORG_CLIPS_INSTALLED: (orgId) => `/api/v1/orgs/${orgId}/clips/installed`,
+  // MCP clip server config (cap:clip-mcp; publisher-org only — cross-org gets
+  // 403 MCP_CROSS_ORG_DISABLED on the whole family, reads included)
+  ORG_CLIP_MCP_CONFIG: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/mcp-config`,
+  ORG_CLIP_MCP_TOOLS_REFRESH: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/mcp-config/tools/refresh`
 };
 var WS_EVENTS = {
   // Client -> Server
@@ -52879,6 +52884,10 @@ var ParallClient = class _ParallClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
+  /** Advance exact runtime-input lifecycle for members of an explicit lane. */
+  async updateDispatchInputState(orgId, req) {
+    return this.request("POST", ENDPOINTS.DISPATCH_INPUT_STATE(orgId), req);
+  }
   async completeDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
   }
@@ -53844,12 +53853,17 @@ var ParallClient = class _ParallClient {
    * command RAN and failed — `error`/`error_code` describe why). Everything
    * else throws a typed {@link ApiError}; match on `err.code`:
    *
-   * Safe to retry (guaranteed nothing was dispatched):
-   * - `EDGE_ACTIVATING` 503 + `Retry-After` — cold cloud profile is starting.
-   *   Bounded backoff, same `correlation_id` across the loop.
-   * - `EDGE_BUSY` 409 — the device is executing another request.
-   * - `EDGE_CONCURRENCY_LIMIT` 429 — org at its concurrent-session limit.
-   * - `EDGE_UNAVAILABLE` 503 — session torn down / replaced mid-dispatch.
+   * Safe to retry (provably not executed). Exactly three carry `Retry-After`
+   * pacing ({@link ApiError.retryAfterSeconds}) — `EDGE_ACTIVATING`,
+   * `EDGE_BUSY`, `EDGE_CONCURRENCY_LIMIT`:
+   * - `EDGE_ACTIVATING` 503 — cold cloud profile is starting. Answered before
+   *   any dispatch. Bounded backoff, same `correlation_id` across the loop.
+   * - `EDGE_BUSY` 409 — the device is executing another request; the pod
+   *   refused this one before starting any script.
+   * - `EDGE_CONCURRENCY_LIMIT` 429 — org at its concurrent-session limit,
+   *   answered before any dispatch.
+   * - `EDGE_UNAVAILABLE` 503 — session torn down / replaced mid-dispatch. No
+   *   `Retry-After` (no slot to wait for — retry re-resolves routing).
    *
    * NOT retryable:
    * - `OUTCOME_UNKNOWN` 504 — dispatched, but no result arrived. The command
@@ -53888,6 +53902,60 @@ var ParallClient = class _ParallClient {
   async deleteClipConnection(orgId, connId) {
     return this.request("DELETE", ENDPOINTS.CLIP_CONNECTION(orgId, connId));
   }
+  // ---- MCP clip server config (cap:clip-mcp; publisher-org only) ----
+  /**
+   * Read the redacted MCP config. 404 NOT_FOUND when the clip has none yet;
+   * 403 MCP_CROSS_ORG_DISABLED for a cross-org installed clip (the whole
+   * mcp-config family is publisher-org property, reads included). `version`
+   * is the CAS token the mutations echo via If-Match.
+   */
+  async getClipMCPConfig(orgId, clipId) {
+    return this.request("GET", ENDPOINTS.ORG_CLIP_MCP_CONFIG(orgId, clipId));
+  }
+  /**
+   * Upsert the MCP config (human org-admin JWT only). Pass `expectedVersion`
+   * from the last GET; omit it ONLY on first create (no config exists yet).
+   * Save probes the remote server first — a probe failure persists nothing and
+   * surfaces as MCP_URL_FORBIDDEN / MCP_AUTH_FAILED / MCP_SERVER_UNREACHABLE /
+   * MCP_PROTOCOL_ERROR. Other typed conflicts: MCP_CONFIG_STALE (reload, then
+   * retry with the current version), MCP_CONFIG_BUSY (another change in
+   * flight — retry), MCP_CONNECTION_CONFLICT (a device-targeted default
+   * connection must be unbound first), SECRETBOX_UNCONFIGURED (503 — the
+   * server cannot store credentials safely).
+   */
+  async putClipMCPConfig(orgId, clipId, req, expectedVersion) {
+    return this.request("PUT", ENDPOINTS.ORG_CLIP_MCP_CONFIG(orgId, clipId), req, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"${expectedVersion}"` } : void 0,
+      // The server probes the remote MCP server inside the request on a fixed
+      // 30s budget; give the HTTP layer headroom past it so a slow-but-valid
+      // save isn't chopped locally into a fake transport error.
+      timeoutMs: 4e4
+    });
+  }
+  /**
+   * Delete the MCP config and every connection routed through it (one
+   * transaction — no orphaned target-less connections). `expectedVersion` is
+   * mandatory: deleting always mutates an existing config.
+   */
+  async deleteClipMCPConfig(orgId, clipId, expectedVersion) {
+    return this.request("DELETE", ENDPOINTS.ORG_CLIP_MCP_CONFIG(orgId, clipId), void 0, void 0, false, { headers: { "If-Match": `"${expectedVersion}"` } });
+  }
+  /**
+   * Re-run tools/list and replace the cached snapshot (org-admin only).
+   * Deliberately does NOT advance the CAS version, so an in-flight edit in
+   * another tab stays valid; on probe failure the old snapshot survives.
+   */
+  async refreshClipMCPTools(orgId, clipId) {
+    return this.request(
+      "POST",
+      ENDPOINTS.ORG_CLIP_MCP_TOOLS_REFRESH(orgId, clipId),
+      void 0,
+      void 0,
+      false,
+      // Same fixed 30s server-side probe budget as PUT (see putClipMCPConfig).
+      { timeoutMs: 4e4 }
+    );
+  }
 };
 function normalizeWikiChangeset(changeset) {
   return {
@@ -54293,10 +54361,221 @@ var ParallWs = class {
   }
 };
 
+// ../agent-core/dist/event-format.js
+function sanitizeMeta(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/[[\]|]/g, " ").trim();
+}
+function buildEventBody(event) {
+  const lines = [];
+  if (event.type === "message") {
+    lines.push(`[Event: message.new]`);
+    const chatLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
+    lines.push(`[Chat: ${chatLabel} | type: ${event.targetType ?? "unknown"}]`);
+    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
+    lines.push(`[Message ID: prll://${event.messageId}]`);
+    if (event.threadRootId) {
+      const threadMeta = [
+        `prll://${event.threadRootId}`,
+        event.threadReplyCount != null ? `${event.threadReplyCount} replies` : null,
+        event.threadUnreadCount != null && event.threadUnreadCount > 0 ? `${event.threadUnreadCount} unread` : null,
+        event.threadUnreadCount != null && event.threadUnreadCount > 0 && event.threadUnreadSince ? `since: prll://${event.threadUnreadSince}` : null
+      ].filter(Boolean).join(" | ");
+      lines.push(`[Thread: ${threadMeta}]`);
+    }
+    if (event.unreadCount != null && event.unreadCount > 1) {
+      const countStr = event.unreadCount >= 1e3 ? "999+" : String(event.unreadCount);
+      const sinceStr = event.unreadSince ? ` | since: prll://${event.unreadSince}` : "";
+      let line = `[Unread: ${countStr} messages${sinceStr}]`;
+      if (event.unreadCount > 50)
+        line += ` \u2014 fetch recent context with --limit, not all`;
+      lines.push(line);
+    }
+    if (event.noReply)
+      lines.push(`[Hint: no_reply]`);
+    if (event.attachments?.length) {
+      for (const att of event.attachments) {
+        const sizeStr = att.fileSize >= 1048576 ? `${(att.fileSize / 1048576).toFixed(1)}MB` : `${Math.round(att.fileSize / 1024)}KB`;
+        lines.push(`[Attachment: prll://${att.id} | ${sanitizeMeta(att.mimeType)} | ${sizeStr} | ${sanitizeMeta(att.fileName)}]`);
+      }
+    }
+    lines.push("", event.body);
+  } else if (event.type === "task_comment") {
+    lines.push(`[Event: task.comment.created]`);
+    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
+    lines.push(`[Task: ${taskLabel}]`);
+    if (event.deliveryReason)
+      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
+    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
+    lines.push(`[Comment ID: prll://${event.messageId}]`);
+    lines.push("", event.body);
+  } else if (event.type === "wiki_comment") {
+    lines.push(`[Event: wiki.comment.created]`);
+    const target = event.replyTargetUri ?? `prll://${event.targetId}`;
+    if (event.targetType === "changeset") {
+      lines.push(`[Wiki Changeset: ${target}]`);
+    } else {
+      lines.push(`[Wiki: ${event.targetName ? `${sanitizeMeta(event.targetName)} (${target})` : target}]`);
+    }
+    if (event.deliveryReason)
+      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
+    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
+    lines.push(`[Comment ID: prll://${event.messageId}]`);
+    lines.push("", event.body);
+  } else if (event.type === "approval") {
+    lines.push(`[Event: approval.decided]`);
+    lines.push(`[Approval: prll://${event.messageId}]`);
+    lines.push(`[Chat: prll://${event.targetId}]`);
+    lines.push(`[Decided by: ${event.senderName} (prll://${event.senderId})]`);
+    lines.push("", event.body);
+  } else if (event.type === "schedule") {
+    lines.push(`[Event: schedule.fired]`);
+    lines.push(`[Schedule: prll://${event.targetId}]`);
+    lines.push(`[Run: prll://${event.messageId}]`);
+    if (event.scheduledFireAt)
+      lines.push(`[Scheduled at: ${sanitizeMeta(event.scheduledFireAt)}]`);
+    if (event.attachedUri)
+      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
+    lines.push("", event.body);
+  } else if (event.type === "channel_message") {
+    lines.push(`[Event: channel.message]`);
+    const providerLabel = sanitizeMeta(event.channelProvider ?? "external IM");
+    const convLabel = event.channelExternalConversationId ? `${sanitizeMeta(event.channelExternalConversationId)} (${sanitizeMeta(event.channelConversationType ?? "conversation")})` : sanitizeMeta(event.channelConversationType ?? "conversation");
+    lines.push(`[Channel: ${providerLabel} | conversation: ${convLabel}]`);
+    lines.push(`[From: ${sanitizeMeta(event.senderName)} (external user, not a Parall member)]`);
+    if (event.channelExternalMessageId) {
+      lines.push(`[External message ID: ${sanitizeMeta(event.channelExternalMessageId)}]`);
+    }
+    lines.push(`[Audience: this conversation lives on ${providerLabel}, OUTSIDE Parall. Readers cannot open prll:// links, Parall cards, or internal attachments \u2014 never include them in replies. Write plain conversational text.]`);
+    lines.push("", event.body);
+  } else if (event.type === "external_trigger") {
+    lines.push(`[Event: external.trigger]`);
+    lines.push(`[Trigger: prll://${event.targetId}]`);
+    lines.push(`[Run: prll://${event.messageId}]`);
+    if (event.externalConnectionId) {
+      const label = event.externalConnectionDisplayName ? `${sanitizeMeta(event.externalConnectionDisplayName)} (prll://${event.externalConnectionId})` : `prll://${event.externalConnectionId}`;
+      lines.push(`[Connection: ${label}]`);
+    }
+    if (event.externalIngressEventId)
+      lines.push(`[Ingress: prll://${event.externalIngressEventId}]`);
+    if (event.attachedUri)
+      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
+    if (event.externalConnectionSourceType) {
+      lines.push(`[Source: ${sanitizeMeta(event.externalConnectionSourceType)}]`);
+    }
+    if (event.externalIngressEventType) {
+      lines.push(`[External event: ${sanitizeMeta(event.externalIngressEventType)}]`);
+    }
+    lines.push("", event.body);
+  } else {
+    lines.push(`[Event: task.assigned]`);
+    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
+    lines.push(`[Task: ${taskLabel}]`);
+    lines.push(`[Assigned by: ${event.senderName} (prll://${event.senderId})]`);
+    lines.push("", event.body);
+  }
+  return lines.join("\n") + buildSendMessageHint(event);
+}
+function buildEventBodyForForkResult(event) {
+  return buildEventBody(event).replace(/\n<system-reminder>[\s\S]*<\/system-reminder>$/, "");
+}
+function buildSendMessageHint(event) {
+  if (event.noReply)
+    return "";
+  if (event.type === "wiki_comment" && event.replyTargetUri) {
+    const where = event.targetType === "changeset" ? "this changeset comment" : "this wiki page";
+    return `
+<system-reminder>To reply on ${where}, run: \`parall comments add --target "${event.replyTargetUri}" --body "..."\` (read the thread first with \`parall comments list --target "${event.replyTargetUri}"\`). To message someone instead, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
+  }
+  if (event.targetId.startsWith("cht_")) {
+    if (event.threadRootId) {
+      return `
+<system-reminder>To reply in this thread, run \`parall messages send prll://${event.targetId} --thread-root-id ${sanitizeMeta(event.threadRootId)} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
+    }
+    return `
+<system-reminder>To reply, run \`parall messages send prll://${event.targetId} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
+  }
+  if (event.targetId.startsWith("tsk_")) {
+    return `
+<system-reminder>To respond, use the CLI: \`parall tasks update\` / \`parall tasks comments add\`. To message someone, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
+  }
+  if (event.targetId.startsWith("sch_")) {
+    return `
+<system-reminder>To communicate, use the CLI: \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
+  }
+  if (event.type === "channel_message") {
+    if (event.channelCliCapable) {
+      if (event.channelProvider === "slack") {
+        const channelArg = event.channelExternalConversationId ? ` --channel "${event.channelExternalConversationId}"` : " --channel <conversation id from this event>";
+        const replyTo = event.channelExternalMessageId ? ` --reply-to "${event.channelExternalMessageId}"` : "";
+        return `
+<system-reminder>To reply, use the platform verb: \`parall slack send${channelArg}${replyTo} --text <your reply>\`. In channels --reply-to is REQUIRED (the reply lands in that message's thread); in DMs it is optional (DMs are linear). \`parall slack send\` is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
+      }
+      if (!event.channelProvider) {
+        return `
+<system-reminder>To reply, use the channel capability granted in your system prompt \u2014 for Feishu conversations that is \`lark-cli im\`, for Slack it is \`parall slack send\` (pass the message id from this event as --reply-to). That capability is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
+      }
+      const convRef = event.channelExternalConversationId ? `chat_id "${event.channelExternalConversationId}"` : "the conversation id named in this event";
+      const threadAlt = event.channelExternalMessageId ? ` To reply threaded to this specific message, reference message_id "${event.channelExternalMessageId}".` : "";
+      return `
+<system-reminder>To reply, use the official Feishu CLI on your PATH: send a message to ${convRef} with \`lark-cli im\` (see \`lark-cli im --help\` for send syntax; auth is provisioned automatically).${threadAlt} lark-cli is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
+    }
+    const platform = event.channelProvider ?? "the external platform";
+    return `
+<system-reminder>This message arrived from ${platform}, but outbound replies are currently disabled for this org (no channel capability granted). Do NOT attempt to reply on the external platform. If action is needed, surface it inside Parall (\`parall messages send\` / \`parall dm\`). Your plain text output is not delivered anywhere.</system-reminder>`;
+  }
+  if (event.type === "external_trigger" || event.targetId.startsWith("xtr_")) {
+    return `
+<system-reminder>This external trigger is incoming-only. Your plain text output is not sent back to the external provider. To communicate in Parall, use \`parall messages send\` / \`parall dm\`; provider-specific outbound actions require a separate capability.</system-reminder>`;
+  }
+  return "";
+}
+function buildForkScopePrefix(event) {
+  const targetLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
+  return `[Fork scope: You are a parallel worker forked from the main session to handle ${targetLabel}. The conversation history above belongs to the main session's in-progress dispatch \u2014 do NOT continue it or complete it, or produce external output (comments, messages) for work visible there. The main session owns its own output.
+
+Only act on the event below within your target scope. If your event reveals findings about the main session's work, report them in your summary \u2014 do not post them externally.
+
+End with a brief "Fork summary" of actions taken and decisions made.]
+
+`;
+}
+function buildForkResultPrefix(results) {
+  if (!results.length)
+    return "";
+  const blocks = results.map((result) => {
+    const lines = [];
+    for (const body of result.eventBodies) {
+      lines.push(body);
+    }
+    lines.push(`[This event was handled by a parallel fork session. Do NOT re-handle, re-reply, or duplicate work for it.]`);
+    lines.push(`[Fork summary: ${result.agentSummary ? sanitizeMeta(result.agentSummary) : "No fork summary available \u2014 the fork completed without producing a text summary. Check the target chat/task for any actions the fork already took before acting."}]`);
+    if (result.actions.length)
+      lines.push(`[Fork actions: ${result.actions.join("; ")}]`);
+    if (result.historyPath)
+      lines.push(`[Fork history: ${result.historyPath}]`);
+    return lines.join("\n");
+  });
+  return blocks.join("\n\n") + "\n\n---\n\n";
+}
+
 // ../agent-core/dist/lane-ledger.js
 import * as fs from "node:fs";
 var LedgerUnsupportedError = class extends Error {
 };
+function bindLaneSession(lane, agentSessionId) {
+  if (lane.sessionId && lane.sessionId !== agentSessionId) {
+    lane.sessionAmbiguous = true;
+  } else if (!lane.sessionAmbiguous) {
+    lane.sessionId = agentSessionId;
+  }
+}
+function releaseLocalMessageClaims(claims, sourceIds) {
+  const released = sourceIds.filter((sourceId) => claims.delete(sourceId));
+  return () => {
+    for (const sourceId of released)
+      claims.add(sourceId);
+  };
+}
 function isStaleLane(err) {
   return err instanceof ApiError && err.status === 409 && err.code === "STALE_LANE";
 }
@@ -54346,7 +54625,8 @@ var LaneLedger = class {
         res = await this.opts.client.claimDispatch(this.opts.orgId, {
           target_uri: targetUri,
           thread_root_id: trigger.threadRootId,
-          limit: 100
+          limit: 100,
+          coverage_mode: this.opts.coverageMode ?? "implicit"
         });
       } catch (err) {
         if (isEndpointMissing(err))
@@ -54361,12 +54641,20 @@ var LaneLedger = class {
         }
         return null;
       }
+      const requestedCoverage = this.opts.coverageMode ?? "implicit";
+      const actualCoverage = res.coverage_mode ?? "implicit";
+      if (requestedCoverage === "explicit" && actualCoverage !== "explicit") {
+        await this.opts.client.releaseDispatchLane(this.opts.orgId, res.lane).catch(() => {
+        });
+        throw new Error(`server did not negotiate explicit input coverage for ${targetUri}; lane released`);
+      }
       const leaseUntilMs = Date.parse(res.lease_until ?? "");
       lane = {
         laneKey,
         lane: res.lane,
         targetUri,
         threadRootId: trigger.threadRootId,
+        coverageMode: actualCoverage,
         folded: /* @__PURE__ */ new Map(),
         ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
       };
@@ -54408,9 +54696,10 @@ var LaneLedger = class {
     const laneKey = this.laneKeyFor(event);
     const lane = this.lanes.get(laneKey);
     if (!lane)
-      return false;
-    if (lane.folded.has(event.messageId))
-      return true;
+      return null;
+    if (lane.folded.has(event.messageId)) {
+      return { inputLifecycle: this.inputLifecycle(lane, [event]) };
+    }
     try {
       const res = await this.opts.client.steerDispatch(this.opts.orgId, {
         lane: lane.lane,
@@ -54419,16 +54708,64 @@ var LaneLedger = class {
         ...event.dispatchEventId ? { dispatch_event_id: event.dispatchEventId } : { source_type: "message", source_id: event.messageId }
       });
       lane.folded.set(event.messageId, res.dispatch_event_id);
-      return true;
+      return { inputLifecycle: this.inputLifecycle(lane, [event]) };
     } catch (err) {
       if (isStaleLane(err)) {
         this.lanes.delete(laneKey);
       } else {
         this.opts.log?.warn(`live steer failed for ${event.messageId}: ${String(err)}`);
       }
-      return false;
+      return null;
     }
   }
+  /**
+   * Build the exact runtime-input lifecycle for one prompt/injection. A
+   * batched prompt covers every WorkItem represented in that single frame.
+   */
+  inputLifecycle(lane, events) {
+    if (lane.coverageMode !== "explicit")
+      return void 0;
+    const dispatchEventIds = events.map((event) => lane.folded.get(event.messageId)).filter((id) => Boolean(id));
+    if (dispatchEventIds.length !== events.length) {
+      throw new Error(`explicit lane ${lane.lane} is missing a folded WorkItem mapping`);
+    }
+    return {
+      deliveryKey: dispatchEventIds.join(","),
+      dispatchEventIds,
+      update: (state) => this.updateInputState(lane, dispatchEventIds, state)
+    };
+  }
+  async updateInputState(lane, dispatchEventIds, state) {
+    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
+      });
+      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" };
+  }
   /**
    * Complete the lane when no local work remains for it: the server sweeps
    * still-leased members as no_action, releases the occupancy row, and
@@ -54447,20 +54784,46 @@ var LaneLedger = class {
     if (lane)
       lane.turnError = true;
   }
+  /**
+   * Record that the turn on this lane ended on a self-healing usage limit.
+   * Like markTurnError this is transport state for the lane's final
+   * complete; an error bit set on the same lane outranks it.
+   */
+  markTurnDeferred(laneKey, info) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      lane.turnDeferred = info;
+  }
+  /**
+   * Sticky: the server rejected turn_outcome=deferred (predates it). Deferred
+   * completes fall back to the error form for the rest of the process — the
+   * members still release for retry, just on the redrive budget instead of
+   * the reset-time schedule.
+   */
+  deferredUnsupported = false;
   async completeIfIdle(laneKey, hasMoreLocal) {
     const lane = this.lanes.get(laneKey);
     if (!lane || hasMoreLocal)
       return;
     this.lanes.delete(laneKey);
     this.removeLaneContext(lane);
+    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 instead of sweeping
-        // them as handled (ignored by older servers).
-        turn_outcome: lane.turnError ? "error" : "ok"
+        // 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 } : {}
+        } : {},
+        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}`);
@@ -54470,6 +54833,23 @@ var LaneLedger = class {
         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`);
+        try {
+          await this.opts.client.completeDispatch(this.opts.orgId, {
+            lane: lane.lane,
+            target_uri: lane.targetUri,
+            thread_root_id: lane.threadRootId,
+            turn_outcome: "error"
+          });
+        } catch (fallbackErr) {
+          if (isStaleLane(fallbackErr))
+            return;
+          this.opts.log?.warn(`lane complete (deferred fallback) failed for ${lane.targetUri}: ${String(fallbackErr)}`);
+        }
+        return;
+      }
       this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
     }
   }
@@ -54571,6 +54951,7 @@ var LaneLedger = class {
       laneKey: laneKeyForTarget(targetUri),
       lane: res.lane,
       targetUri,
+      coverageMode: "implicit",
       folded: /* @__PURE__ */ new Map([[workItem.source_id, workItem.id]]),
       typedDispatchEventId: workItem.id,
       ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
@@ -54610,6 +54991,16 @@ var LaneLedger = class {
 };
 
 // ../agent-core/dist/gateway-lane-flow.js
+async function steerLaneMessage(host, event) {
+  const { laneLedger: ledger, opts } = host;
+  const adapter = opts.dispatchAdapter;
+  if (!ledger || !adapter.enqueueDuringDispatch)
+    return;
+  const folded = await ledger.steerLive(event);
+  if (folded && await adapter.enqueueDuringDispatch(opts.runtimeKey, buildEventBody(event), folded.inputLifecycle)) {
+    opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
+  }
+}
 async function dispatchLaneGroup(host, opts) {
   const ledger = host.laneLedger;
   const event = opts.events[opts.events.length - 1];
@@ -54642,7 +55033,8 @@ async function dispatchLaneGroup(host, opts) {
   host.noteSessionLane(opts.sessionKey, lane.laneKey);
   let dispatched = false;
   try {
-    dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
+    const inputLifecycle = ledger.inputLifecycle(lane, [...opts.earlier, event]);
+    dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText, inputLifecycle);
   } catch (err) {
     host.noteSessionLane(opts.sessionKey, null);
     await ledger.release(lane.laneKey).catch(() => {
@@ -54655,8 +55047,16 @@ async function dispatchLaneGroup(host, opts) {
   if (!dispatched) {
     return "shutdown";
   }
-  if (host.consumeTurnError(opts.sessionKey)) {
-    ledger.markTurnError(lane.laneKey);
+  const settled = host.consumeTurnOutcome(opts.sessionKey);
+  if (settled) {
+    if (settled.kind === "deferred") {
+      ledger.markTurnDeferred(lane.laneKey, {
+        outcomeClass: settled.outcomeClass,
+        ...settled.retryAt ? { retryAt: settled.retryAt } : {}
+      });
+    } else {
+      ledger.markTurnError(lane.laneKey);
+    }
     for (const msgId of lane.folded.keys()) {
       host.dispatchedMessages.delete(msgId);
     }
@@ -54665,7 +55065,7 @@ async function dispatchLaneGroup(host, opts) {
     } catch {
     }
     await ledger.completeIfIdle(lane.laneKey, false);
-    return "failed";
+    return settled.kind === "deferred" ? "deferred" : "failed";
   }
   const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
   await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
@@ -54866,6 +55266,8 @@ async function consumeMessageWorkItem(host, item) {
     return;
   if (!host.tryClaimMessage(item.source_id))
     return;
+  if (host.dispatchState.mainBuffer.some((event) => event.messageId === item.source_id))
+    return;
   const ackItem = () => {
     if (host.laneLedger && !host.ledgerDisabled && !host.typedByIdCompleteUnsupported) {
       void resolveDispatchByID(host, item.id).then((outcome) => {
@@ -55036,203 +55438,6 @@ function routeTrigger(event, state, strategy = defaultRoutingStrategy) {
   return strategy(event, state);
 }
 
-// ../agent-core/dist/event-format.js
-function sanitizeMeta(value) {
-  return value.replace(/[\r\n]+/g, " ").replace(/[[\]|]/g, " ").trim();
-}
-function buildEventBody(event) {
-  const lines = [];
-  if (event.type === "message") {
-    lines.push(`[Event: message.new]`);
-    const chatLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Chat: ${chatLabel} | type: ${event.targetType ?? "unknown"}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Message ID: prll://${event.messageId}]`);
-    if (event.threadRootId) {
-      const threadMeta = [
-        `prll://${event.threadRootId}`,
-        event.threadReplyCount != null ? `${event.threadReplyCount} replies` : null,
-        event.threadUnreadCount != null && event.threadUnreadCount > 0 ? `${event.threadUnreadCount} unread` : null,
-        event.threadUnreadCount != null && event.threadUnreadCount > 0 && event.threadUnreadSince ? `since: prll://${event.threadUnreadSince}` : null
-      ].filter(Boolean).join(" | ");
-      lines.push(`[Thread: ${threadMeta}]`);
-    }
-    if (event.unreadCount != null && event.unreadCount > 1) {
-      const countStr = event.unreadCount >= 1e3 ? "999+" : String(event.unreadCount);
-      const sinceStr = event.unreadSince ? ` | since: prll://${event.unreadSince}` : "";
-      let line = `[Unread: ${countStr} messages${sinceStr}]`;
-      if (event.unreadCount > 50)
-        line += ` \u2014 fetch recent context with --limit, not all`;
-      lines.push(line);
-    }
-    if (event.noReply)
-      lines.push(`[Hint: no_reply]`);
-    if (event.attachments?.length) {
-      for (const att of event.attachments) {
-        const sizeStr = att.fileSize >= 1048576 ? `${(att.fileSize / 1048576).toFixed(1)}MB` : `${Math.round(att.fileSize / 1024)}KB`;
-        lines.push(`[Attachment: prll://${att.id} | ${sanitizeMeta(att.mimeType)} | ${sizeStr} | ${sanitizeMeta(att.fileName)}]`);
-      }
-    }
-    lines.push("", event.body);
-  } else if (event.type === "task_comment") {
-    lines.push(`[Event: task.comment.created]`);
-    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Task: ${taskLabel}]`);
-    if (event.deliveryReason)
-      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Comment ID: prll://${event.messageId}]`);
-    lines.push("", event.body);
-  } else if (event.type === "wiki_comment") {
-    lines.push(`[Event: wiki.comment.created]`);
-    const target = event.replyTargetUri ?? `prll://${event.targetId}`;
-    if (event.targetType === "changeset") {
-      lines.push(`[Wiki Changeset: ${target}]`);
-    } else {
-      lines.push(`[Wiki: ${event.targetName ? `${sanitizeMeta(event.targetName)} (${target})` : target}]`);
-    }
-    if (event.deliveryReason)
-      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Comment ID: prll://${event.messageId}]`);
-    lines.push("", event.body);
-  } else if (event.type === "approval") {
-    lines.push(`[Event: approval.decided]`);
-    lines.push(`[Approval: prll://${event.messageId}]`);
-    lines.push(`[Chat: prll://${event.targetId}]`);
-    lines.push(`[Decided by: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push("", event.body);
-  } else if (event.type === "schedule") {
-    lines.push(`[Event: schedule.fired]`);
-    lines.push(`[Schedule: prll://${event.targetId}]`);
-    lines.push(`[Run: prll://${event.messageId}]`);
-    if (event.scheduledFireAt)
-      lines.push(`[Scheduled at: ${sanitizeMeta(event.scheduledFireAt)}]`);
-    if (event.attachedUri)
-      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
-    lines.push("", event.body);
-  } else if (event.type === "channel_message") {
-    lines.push(`[Event: channel.message]`);
-    const providerLabel = sanitizeMeta(event.channelProvider ?? "external IM");
-    const convLabel = event.channelExternalConversationId ? `${sanitizeMeta(event.channelExternalConversationId)} (${sanitizeMeta(event.channelConversationType ?? "conversation")})` : sanitizeMeta(event.channelConversationType ?? "conversation");
-    lines.push(`[Channel: ${providerLabel} | conversation: ${convLabel}]`);
-    lines.push(`[From: ${sanitizeMeta(event.senderName)} (external user, not a Parall member)]`);
-    if (event.channelExternalMessageId) {
-      lines.push(`[External message ID: ${sanitizeMeta(event.channelExternalMessageId)}]`);
-    }
-    lines.push(`[Audience: this conversation lives on ${providerLabel}, OUTSIDE Parall. Readers cannot open prll:// links, Parall cards, or internal attachments \u2014 never include them in replies. Write plain conversational text.]`);
-    lines.push("", event.body);
-  } else if (event.type === "external_trigger") {
-    lines.push(`[Event: external.trigger]`);
-    lines.push(`[Trigger: prll://${event.targetId}]`);
-    lines.push(`[Run: prll://${event.messageId}]`);
-    if (event.externalConnectionId) {
-      const label = event.externalConnectionDisplayName ? `${sanitizeMeta(event.externalConnectionDisplayName)} (prll://${event.externalConnectionId})` : `prll://${event.externalConnectionId}`;
-      lines.push(`[Connection: ${label}]`);
-    }
-    if (event.externalIngressEventId)
-      lines.push(`[Ingress: prll://${event.externalIngressEventId}]`);
-    if (event.attachedUri)
-      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
-    if (event.externalConnectionSourceType) {
-      lines.push(`[Source: ${sanitizeMeta(event.externalConnectionSourceType)}]`);
-    }
-    if (event.externalIngressEventType) {
-      lines.push(`[External event: ${sanitizeMeta(event.externalIngressEventType)}]`);
-    }
-    lines.push("", event.body);
-  } else {
-    lines.push(`[Event: task.assigned]`);
-    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Task: ${taskLabel}]`);
-    lines.push(`[Assigned by: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push("", event.body);
-  }
-  return lines.join("\n") + buildSendMessageHint(event);
-}
-function buildEventBodyForForkResult(event) {
-  return buildEventBody(event).replace(/\n<system-reminder>[\s\S]*<\/system-reminder>$/, "");
-}
-function buildSendMessageHint(event) {
-  if (event.noReply)
-    return "";
-  if (event.type === "wiki_comment" && event.replyTargetUri) {
-    const where = event.targetType === "changeset" ? "this changeset comment" : "this wiki page";
-    return `
-<system-reminder>To reply on ${where}, run: \`parall comments add --target "${event.replyTargetUri}" --body "..."\` (read the thread first with \`parall comments list --target "${event.replyTargetUri}"\`). To message someone instead, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("cht_")) {
-    if (event.threadRootId) {
-      return `
-<system-reminder>To reply in this thread, run \`parall messages send prll://${event.targetId} --thread-root-id ${sanitizeMeta(event.threadRootId)} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
-    }
-    return `
-<system-reminder>To reply, run \`parall messages send prll://${event.targetId} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("tsk_")) {
-    return `
-<system-reminder>To respond, use the CLI: \`parall tasks update\` / \`parall tasks comments add\`. To message someone, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("sch_")) {
-    return `
-<system-reminder>To communicate, use the CLI: \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.type === "channel_message") {
-    if (event.channelCliCapable) {
-      if (event.channelProvider === "slack") {
-        const channelArg = event.channelExternalConversationId ? ` --channel "${event.channelExternalConversationId}"` : " --channel <conversation id from this event>";
-        const replyTo = event.channelExternalMessageId ? ` --reply-to "${event.channelExternalMessageId}"` : "";
-        return `
-<system-reminder>To reply, use the platform verb: \`parall slack send${channelArg}${replyTo} --text <your reply>\`. In channels --reply-to is REQUIRED (the reply lands in that message's thread); in DMs it is optional (DMs are linear). \`parall slack send\` is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-      }
-      if (!event.channelProvider) {
-        return `
-<system-reminder>To reply, use the channel capability granted in your system prompt \u2014 for Feishu conversations that is \`lark-cli im\`, for Slack it is \`parall slack send\` (pass the message id from this event as --reply-to). That capability is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-      }
-      const convRef = event.channelExternalConversationId ? `chat_id "${event.channelExternalConversationId}"` : "the conversation id named in this event";
-      const threadAlt = event.channelExternalMessageId ? ` To reply threaded to this specific message, reference message_id "${event.channelExternalMessageId}".` : "";
-      return `
-<system-reminder>To reply, use the official Feishu CLI on your PATH: send a message to ${convRef} with \`lark-cli im\` (see \`lark-cli im --help\` for send syntax; auth is provisioned automatically).${threadAlt} lark-cli is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-    }
-    const platform = event.channelProvider ?? "the external platform";
-    return `
-<system-reminder>This message arrived from ${platform}, but outbound replies are currently disabled for this org (no channel capability granted). Do NOT attempt to reply on the external platform. If action is needed, surface it inside Parall (\`parall messages send\` / \`parall dm\`). Your plain text output is not delivered anywhere.</system-reminder>`;
-  }
-  if (event.type === "external_trigger" || event.targetId.startsWith("xtr_")) {
-    return `
-<system-reminder>This external trigger is incoming-only. Your plain text output is not sent back to the external provider. To communicate in Parall, use \`parall messages send\` / \`parall dm\`; provider-specific outbound actions require a separate capability.</system-reminder>`;
-  }
-  return "";
-}
-function buildForkScopePrefix(event) {
-  const targetLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
-  return `[Fork scope: You are a parallel worker forked from the main session to handle ${targetLabel}. The conversation history above belongs to the main session's in-progress dispatch \u2014 do NOT continue it or complete it, or produce external output (comments, messages) for work visible there. The main session owns its own output.
-
-Only act on the event below within your target scope. If your event reveals findings about the main session's work, report them in your summary \u2014 do not post them externally.
-
-End with a brief "Fork summary" of actions taken and decisions made.]
-
-`;
-}
-function buildForkResultPrefix(results) {
-  if (!results.length)
-    return "";
-  const blocks = results.map((result) => {
-    const lines = [];
-    for (const body of result.eventBodies) {
-      lines.push(body);
-    }
-    lines.push(`[This event was handled by a parallel fork session. Do NOT re-handle, re-reply, or duplicate work for it.]`);
-    lines.push(`[Fork summary: ${result.agentSummary ? sanitizeMeta(result.agentSummary) : "No fork summary available \u2014 the fork completed without producing a text summary. Check the target chat/task for any actions the fork already took before acting."}]`);
-    if (result.actions.length)
-      lines.push(`[Fork actions: ${result.actions.join("; ")}]`);
-    if (result.historyPath)
-      lines.push(`[Fork history: ${result.historyPath}]`);
-    return lines.join("\n");
-  });
-  return blocks.join("\n\n") + "\n\n---\n\n";
-}
-
 // ../agent-core/dist/prompt-fragments.js
 function identityFromMe(me) {
   return {
@@ -55424,6 +55629,22 @@ All three forms work \u2014 pick whichever fits:
 Bare URIs and empty-context refs are preferred in most cases \u2014 the platform
 resolves and renders the entity title automatically.
 
+### Mentioning people and agents
+
+A real member mention is a \`prll://usr_...\` reference. Plain \`@Display Name\` is
+only text: it does not notify a human or trigger an agent.
+
+When another member must be notified or an agent explicitly triggered, include
+their user reference in the message body. Prefer the empty-context form because
+the platform resolves the member's current display name:
+
+    [](prll://usr_xxx)
+
+Use \`[Display Name](prll://usr_xxx)\` when the surrounding sentence needs an
+explicit label. Find the user ID in the incoming message or with
+\`parall members list\`. Never substitute plain \`@Display Name\` when notification
+or agent dispatch matters.
+
 ### URI format
 
 \`prll://\` follows standard URI structure: \`scheme://authority/path?query#fragment\`.
@@ -55619,6 +55840,28 @@ function buildErrorStepContent(message) {
   return { text: message, suppressed: false, status: "error" };
 }
 
+// ../agent-core/dist/redact.js
+function redactSecrets(s, knownValues = []) {
+  let out = s;
+  for (const v of knownValues) {
+    if (typeof v === "string" && v.length >= 6)
+      out = out.split(v).join("***");
+  }
+  return out.replace(/\b(agk|mck|cpk)_[A-Za-z0-9_-]+/g, "$1_***").replace(/\b(sk|pk|rk)-[A-Za-z0-9_-]{8,}/g, "$1-***").replace(/\bAKIA[0-9A-Z]{16}\b/g, "AKIA***").replace(/\b(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi, "$1***").replace(/[A-Za-z0-9_-]{32,}/g, "***");
+}
+function redactTurnOutcome(event, knownValues) {
+  const redacted = { ...event };
+  if (redacted.detail)
+    redacted.detail = redactSecrets(redacted.detail, knownValues);
+  if (redacted.raw) {
+    redacted.raw = Object.fromEntries(Object.entries(redacted.raw).map(([k, v]) => [
+      k,
+      typeof v === "string" ? redactSecrets(v, knownValues) : v
+    ]));
+  }
+  return redacted;
+}
+
 // ../agent-core/dist/gateway-base.js
 import * as os from "node:os";
 import * as fs3 from "node:fs";
@@ -56480,6 +56723,8 @@ var tracer = null;
 var dispatchCounter = null;
 var dispatchDuration = null;
 var missingReplyCounter = null;
+var turnTokensCounter = null;
+var turnCostCounter = null;
 var otelLogger = null;
 function resolveTargetType(targetId) {
   if (targetId.startsWith("cht_"))
@@ -56554,6 +56799,12 @@ async function initAgentTelemetry(serviceName, runtimeType) {
     missingReplyCounter = meter.createCounter("parall.dispatch.missing_reply", {
       description: "Dispatches where agent produced text but sent no reply message"
     });
+    turnTokensCounter = meter.createCounter("parall.turn.tokens", {
+      description: "LLM tokens consumed per turn, by kind (input/output/cache_read/cache_creation)"
+    });
+    turnCostCounter = meter.createCounter("parall.turn.cost_usd", {
+      description: "LLM cost per turn in USD (when the runtime reports it)"
+    });
     initialized = true;
     shutdownFn = async () => {
       await tracerProvider.forceFlush();
@@ -56587,7 +56838,7 @@ function startDispatchSpan(event, runtimeType, sessionKey) {
     }
   });
 }
-function endDispatchSpan(span, metricsSnapshot, error) {
+function endDispatchSpan(span, metricsSnapshot, error, turnOutcome) {
   if (!span)
     return;
   if (metricsSnapshot) {
@@ -56601,27 +56852,77 @@ function endDispatchSpan(span, metricsSnapshot, error) {
       "dispatch.duration_ms": Date.now() - metricsSnapshot.started_at
     });
   }
+  if (turnOutcome) {
+    span.setAttribute("dispatch.outcome", turnOutcome.outcome);
+    if (turnOutcome.detail)
+      span.setAttribute("dispatch.outcome_detail", turnOutcome.detail);
+    if (turnOutcome.retryAt)
+      span.setAttribute("dispatch.retry_at", turnOutcome.retryAt);
+    if (turnOutcome.model)
+      span.setAttribute("dispatch.model", turnOutcome.model);
+    if (turnOutcome.raw && Object.keys(turnOutcome.raw).length > 0) {
+      try {
+        span.setAttribute("dispatch.outcome_raw", JSON.stringify(turnOutcome.raw));
+      } catch {
+      }
+    }
+    const u = turnOutcome.usage;
+    if (u) {
+      if (u.inputTokens !== void 0)
+        span.setAttribute("dispatch.tokens_input", u.inputTokens);
+      if (u.outputTokens !== void 0)
+        span.setAttribute("dispatch.tokens_output", u.outputTokens);
+      if (u.cacheReadTokens !== void 0)
+        span.setAttribute("dispatch.tokens_cache_read", u.cacheReadTokens);
+      if (u.cacheCreationTokens !== void 0)
+        span.setAttribute("dispatch.tokens_cache_creation", u.cacheCreationTokens);
+      if (u.costUsd !== void 0)
+        span.setAttribute("dispatch.cost_usd", u.costUsd);
+      if (u.durationApiMs !== void 0)
+        span.setAttribute("dispatch.duration_api_ms", u.durationApiMs);
+    }
+  }
   if (error) {
-    span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
-    span.recordException(error instanceof Error ? error : new Error(String(error)));
+    const safe = redactSecrets(String(error));
+    span.setStatus({ code: SpanStatusCode.ERROR, message: safe });
+    span.recordException(error instanceof Error ? new Error(safe) : new Error(safe));
   }
   span.end();
 }
-function recordDispatchMetric(event, runtimeType, durationMs) {
+function recordDispatchMetric(event, runtimeType, durationMs, outcome = "ok") {
   if (!initialized)
     return;
   const attrs = {
     target_type: resolveTargetType(event.targetId),
     event_type: event.type,
-    runtime_type: runtimeType
+    runtime_type: runtimeType,
+    outcome
   };
   dispatchCounter?.add(1, attrs);
   dispatchDuration?.record(durationMs, attrs);
 }
-function recordMissingReply(runtimeType) {
+function recordMissingReply(runtimeType, outcome = "ok") {
   if (!initialized)
     return;
-  missingReplyCounter?.add(1, { runtime_type: runtimeType });
+  missingReplyCounter?.add(1, { runtime_type: runtimeType, outcome });
+}
+function recordTurnUsage(usage, runtimeType) {
+  if (!initialized || !usage)
+    return;
+  const kinds = [
+    ["input", usage.inputTokens],
+    ["output", usage.outputTokens],
+    ["cache_read", usage.cacheReadTokens],
+    ["cache_creation", usage.cacheCreationTokens]
+  ];
+  for (const [kind, value] of kinds) {
+    if (value !== void 0 && value > 0) {
+      turnTokensCounter?.add(value, { kind, runtime_type: runtimeType });
+    }
+  }
+  if (usage.costUsd !== void 0 && usage.costUsd > 0) {
+    turnCostCounter?.add(usage.costUsd, { runtime_type: runtimeType });
+  }
 }
 var sessionKeyStorage = new AsyncLocalStorage();
 function runWithSessionKey(sessionKey, fn) {
@@ -56821,7 +57122,9 @@ var ParallAgentGateway = class {
         client: opts.client,
         orgId: opts.config.org_id,
         contextDir: opts.dispatchContextDir,
-        log: opts.log
+        log: opts.log,
+        coverageMode: opts.dispatchAdapter.inputLifecycleMode ?? "implicit",
+        releaseLocalClaims: (sourceIds) => releaseLocalMessageClaims(this.dispatchedMessages, sourceIds)
       });
     }
     this.SHUTDOWN_DEADLINE_MS = opts.shutdownDeadlineMs ?? 6e4;
@@ -57095,17 +57398,49 @@ var ParallAgentGateway = class {
     if (laneKey)
       this.laneLedger?.renewByKey(laneKey);
   }
-  /** Sessions whose in-flight turn surfaced a runtime error event. */
-  turnErrorSessions = /* @__PURE__ */ new Set();
   /**
-   * Consume (read-and-clear) the error marker for sessionKey's last turn.
+   * Settled LLM-layer outcome of each session's last turn — an error to
+   * release lane members on the redrive budget, or a deferred usage-limit
+   * wait (agent-turn-outcome-design.md). Absent = clean turn.
+   */
+  turnOutcomes = /* @__PURE__ */ new Map();
+  /**
+   * Consume (read-and-clear) the settled outcome for sessionKey's last turn.
    * Feeds complete's turn_outcome so an error turn's lane members are
-   * released for retry instead of no_action-swept (design §3). Consuming
-   * (rather than peeking) keeps one-shot fork session keys from accumulating
-   * in the set forever.
+   * released for retry (and a deferred turn's members re-deliver at retryAt)
+   * instead of being no_action-swept (design §3). Consuming (rather than
+   * peeking) keeps one-shot fork session keys from accumulating forever.
+   */
+  consumeTurnOutcome(sessionKey) {
+    const outcome = this.turnOutcomes.get(sessionKey);
+    this.turnOutcomes.delete(sessionKey);
+    return outcome;
+  }
+  /**
+   * Boolean view of consumeTurnOutcome for the typed/fork call sites, which
+   * have no deferred semantics: ANY non-clean outcome (error or deferred)
+   * counts as an errored turn there — release-for-retry beats a false
+   * "handled".
    */
   consumeTurnError(sessionKey) {
-    return this.turnErrorSessions.delete(sessionKey);
+    return this.consumeTurnOutcome(sessionKey) !== void 0;
+  }
+  /**
+   * Fold turn signals into the session's settled outcome. Two sources, one
+   * precedence rule: the bridge's explicit turn_outcome classification always
+   * wins (it may refine the SAME failure a generic `error` event already
+   * reported — e.g. Claude's result frame yields both), while a bare `error`
+   * event only fills the slot when no classification exists. Wire order makes
+   * this safe: every bridge emits its error events before the turn-boundary
+   * turn_outcome.
+   */
+  recordTurnErrorSignal(sessionKey) {
+    if (!this.turnOutcomes.has(sessionKey)) {
+      this.turnOutcomes.set(sessionKey, { kind: "error" });
+    }
+  }
+  recordTurnClassification(sessionKey, next) {
+    this.turnOutcomes.set(sessionKey, next);
   }
   async emitDispatchReceived(event) {
     const sourceType = event.ackSourceType ?? (event.type === "task" ? "task_activity" : "message");
@@ -57275,7 +57610,14 @@ var ParallAgentGateway = class {
           channel_message_id: event.messageId,
           provider: event.channelProvider,
           external_conversation_id: event.channelExternalConversationId
-        } : event.type === "approval" ? { approval_id: event.messageId } : { message_id: event.messageId },
+        } : event.type === "approval" ? { approval_id: event.messageId } : {
+          message_id: event.messageId,
+          // Thread context for the session→chat backlink:
+          // a thread reply can only be navigated to with
+          // its thread root (the chat surface rejects
+          // bare thread-message targets).
+          ...event.threadRootId ? { thread_root_id: event.threadRootId } : {}
+        },
         sender_id: event.senderId,
         sender_name: event.senderName,
         summary: event.body.substring(0, 200),
@@ -57482,7 +57824,7 @@ var ParallAgentGateway = class {
   // are shutting down. Callers MUST treat `false` as "not dispatched" and
   // skip the server-side ack so the event stays in the dispatch queue for
   // catch-up on the replacement pod — otherwise we silently drop work.
-  async runDispatch(event, sessionKey, bodyForAgent, earlierEvents = [], captureText) {
+  async runDispatch(event, sessionKey, bodyForAgent, earlierEvents = [], captureText, inputLifecycle) {
     if (this.shuttingDown) {
       this.opts.log?.info(`skipping dispatch for ${event.messageId} (shutting down) \u2014 leaving unacked for catch-up on replacement pod`);
       return false;
@@ -57492,7 +57834,7 @@ var ParallAgentGateway = class {
       this.pendingRestartNotification = null;
     }
     resetDispatchMetrics(sessionKey);
-    this.turnErrorSessions.delete(sessionKey);
+    this.turnOutcomes.delete(sessionKey);
     return runWithSessionKey(sessionKey, async () => {
       let dispatchSpan = null;
       setSessionChatId(sessionKey, event.targetId);
@@ -57537,6 +57879,8 @@ var ParallAgentGateway = class {
       let inputStepsCreated = false;
       let turnHandle;
       let dispatchError;
+      let turnOutcomeEvent;
+      let sawErrorEvent = false;
       const pendingSendCallIds = /* @__PURE__ */ new Set();
       const ensureTurnBegun = async () => {
         if (turnHandle || !binding)
@@ -57550,11 +57894,15 @@ var ParallAgentGateway = class {
           earlierEvents,
           bodyForAgent,
           sessionKey,
-          context: dispatchContext
+          context: dispatchContext,
+          inputLifecycle
         })) {
           if (runtimeEvent.type === "runtime_session") {
             const priorAgentSessionId = binding?.agentSessionId;
             binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2);
+            if (activeLane) {
+              bindLaneSession(activeLane, binding.agentSessionId);
+            }
             if (event.targetType === "channel_conversation" && binding.agentSessionId !== priorAgentSessionId) {
               try {
                 await this.opts.client.setChannelConversationSession(this.opts.config.org_id, event.targetId, binding.agentSessionId);
@@ -57572,6 +57920,36 @@ var ParallAgentGateway = class {
             }
             continue;
           }
+          if (runtimeEvent.type === "turn_outcome") {
+            const outcomeEvent = redactTurnOutcome(runtimeEvent, [this.opts.config.api_key]);
+            turnOutcomeEvent = outcomeEvent;
+            if (outcomeEvent.outcome === "ok") {
+              this.turnOutcomes.delete(sessionKey);
+              continue;
+            }
+            this.recordTurnClassification(sessionKey, outcomeEvent.outcome === "usage_limit" ? {
+              kind: "deferred",
+              outcomeClass: outcomeEvent.outcome,
+              ...outcomeEvent.retryAt ? { retryAt: outcomeEvent.retryAt } : {}
+            } : { kind: "error", outcomeClass: outcomeEvent.outcome });
+            const retryNote = outcomeEvent.retryAt ? `, retry at ${outcomeEvent.retryAt}` : "";
+            this.opts.log?.warn(`turn outcome: ${outcomeEvent.outcome}${retryNote}${outcomeEvent.detail ? ` \u2014 ${outcomeEvent.detail}` : ""}`);
+            if (binding) {
+              await ensureTurnBegun();
+              if (!inputStepsCreated) {
+                if (earlierEvents.length > 0) {
+                  await this.createInputStepsForEarlierEvents(binding.agentSessionId, earlierEvents);
+                }
+                await this.createInputStep(binding.agentSessionId, event);
+                inputStepsCreated = true;
+              }
+              await this.createRuntimeStep(binding.agentSessionId, event, {
+                type: "error",
+                message: `LLM turn ${outcomeEvent.outcome}${retryNote}${outcomeEvent.detail ? `: ${outcomeEvent.detail}` : ""}`
+              }, stepIdFilePath, contextFilePath, laneContextFilePath2);
+            }
+            continue;
+          }
           if (!binding) {
             const detail = runtimeEvent.type === "error" ? `: ${runtimeEvent.message}` : "";
             throw new Error(`runtime emitted ${runtimeEvent.type} before runtime_session${detail}`);
@@ -57604,7 +57982,8 @@ var ParallAgentGateway = class {
             recordMessageSend(sessionKey, !runtimeEvent.error);
           }
           if (runtimeEvent.type === "error") {
-            this.turnErrorSessions.add(sessionKey);
+            sawErrorEvent = true;
+            this.recordTurnErrorSignal(sessionKey);
           }
           await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
         }
@@ -57658,10 +58037,12 @@ var ParallAgentGateway = class {
           clearTimeout(deadlineTimer);
         const metricsSnapshot = getDispatchMetrics(sessionKey);
         const durationMs = metricsSnapshot ? Date.now() - metricsSnapshot.started_at : 0;
-        endDispatchSpan(dispatchSpan, metricsSnapshot, dispatchError);
-        recordDispatchMetric(event, this.opts.runtimeType, durationMs);
+        const effectiveOutcome = turnOutcomeEvent?.outcome ?? (dispatchError || sawErrorEvent ? "runtime_crash" : "ok");
+        endDispatchSpan(dispatchSpan, metricsSnapshot, dispatchError, turnOutcomeEvent);
+        recordDispatchMetric(event, this.opts.runtimeType, durationMs, effectiveOutcome);
+        recordTurnUsage(turnOutcomeEvent?.usage, this.opts.runtimeType);
         if (metricsSnapshot && !dispatchError && event.type === "message" && event.targetId?.startsWith("cht_") && !event.noReply && metricsSnapshot.deliver_text_chunks > 0 && metricsSnapshot.message_send_successes === 0 && !metricsSnapshot.no_reply_called) {
-          recordMissingReply(this.opts.runtimeType);
+          recordMissingReply(this.opts.runtimeType, effectiveOutcome);
         }
         clearDispatchMetrics(sessionKey);
         if (turnHandle) {
@@ -57769,7 +58150,7 @@ var ParallAgentGateway = class {
                 item.resolve(false);
               break;
             }
-            if (outcome === "failed") {
+            if (outcome === "failed" || outcome === "deferred") {
               for (const item of items)
                 item.resolve(false);
               continue;
@@ -57813,7 +58194,7 @@ var ParallAgentGateway = class {
         remaining.resolve(false);
       }
     } finally {
-      this.turnErrorSessions.delete(fork.fork.sessionKey);
+      this.turnOutcomes.delete(fork.fork.sessionKey);
       if (fork.deadlineTimer) {
         clearTimeout(fork.deadlineTimer);
         fork.deadlineTimer = null;
@@ -57928,7 +58309,7 @@ var ParallAgentGateway = class {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
-          if (outcome === "failed") {
+          if (outcome === "failed" || outcome === "deferred") {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
@@ -58075,8 +58456,8 @@ var ParallAgentGateway = class {
         this.dispatchState.mainBuffer.push(event);
         const typedAheadInBuffer = this.dispatchState.mainBuffer.some((e) => e.type !== "message");
         if (this.usesLaneLedger(event)) {
-          if (!typedAheadInBuffer && this.mainCurrentGroupKey === this.dispatchGroupKey(event) && this.opts.dispatchAdapter.enqueueDuringDispatch != null && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch(this.opts.runtimeKey, buildEventBody(event))) {
-            this.opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
+          if (!typedAheadInBuffer && this.mainCurrentGroupKey === this.dispatchGroupKey(event) && this.opts.dispatchAdapter.enqueueDuringDispatch != null) {
+            await steerLaneMessage(this.laneFlowHost(), event);
           }
         } else if (
           // Message events only. A typed event (task_comment/schedule/…)
@@ -60406,6 +60787,24 @@ ${event.body}` : event.body
     };
   });
 }
+var OC_AUTH_TEXT = /unauthorized|401|403|invalid api key|authentication/i;
+var OC_CONTEXT_TEXT = /context (window|length)|prompt is too long|request too large|413/i;
+var OC_API_TEXT = /overloaded|429|rate limit|5\d\d|bad gateway|service unavailable|timeout/i;
+function classifyOpenClawFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  let outcome = "runtime_crash";
+  if (OC_AUTH_TEXT.test(message))
+    outcome = "auth";
+  else if (OC_CONTEXT_TEXT.test(message))
+    outcome = "context_overflow";
+  else if (OC_API_TEXT.test(message))
+    outcome = "api_error";
+  return {
+    type: "turn_outcome",
+    outcome,
+    ...message ? { detail: message.slice(0, 500) } : {}
+  };
+}
 function createRuntimeEventStream() {
   const queue = [];
   const waiters = [];
@@ -60560,7 +60959,10 @@ function createOpenClawDispatchAdapter(opts) {
             }
           }
         });
-        run.then(() => stream.end()).catch((err) => stream.fail(err));
+        run.then(() => stream.end()).catch((err) => {
+          stream.push(classifyOpenClawFailure(err));
+          stream.fail(err);
+        });
         let sessionId;
         try {
           sessionId = await Promise.race([