@parall/parall 1.42.1 → 1.44.0

package/dist/index.bundle.mjs

@@ -17717,9 +17717,9 @@ var require_getMachineId_linux = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
-      for (const path8 of paths) {
+      for (const path9 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path8, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path9, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -21122,7 +21122,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path8) {
+function appendResourcePathToUrl(url, path9) {
   try {
     new URL(url);
   } catch (_a) {
@@ -21132,11 +21132,11 @@ function appendResourcePathToUrl(url, path8) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path8;
+  url += path9;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path8 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path9 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -26479,664 +26479,18 @@ function laneKeyForTarget(targetUri, threadRootId) {
   return Buffer.from(`${targetUri}
 ${threadRootId ?? ""}`, "utf8").toString("base64url");
 }
+function dispatchLaneContextDir(stateDir) {
+  return path.join(stateDir, "dispatch-lane-context");
+}
 function laneContextFilePath(contextDir, targetUri, threadRootId) {
   return path.join(contextDir, `${laneKeyForTarget(targetUri, threadRootId)}.json`);
 }
 
-// ../agent-core/dist/session-state.js
-function normalizeSessionKey(sessionKey) {
-  return sessionKey.toLowerCase();
-}
-var sessionChatIdMap = /* @__PURE__ */ new Map();
-var sessionMessageIdMap = /* @__PURE__ */ new Map();
-var dispatchMessageIdMap = /* @__PURE__ */ new Map();
-var dispatchGroupKeyMap = /* @__PURE__ */ new Map();
-var dispatchNoReplyMap = /* @__PURE__ */ new Map();
-function setSessionChatId(sessionKey, chatId) {
-  sessionChatIdMap.set(normalizeSessionKey(sessionKey), chatId);
-}
-function getSessionChatId(sessionKey) {
-  return sessionChatIdMap.get(normalizeSessionKey(sessionKey));
-}
-function setSessionMessageId(sessionKey, messageId) {
-  sessionMessageIdMap.set(normalizeSessionKey(sessionKey), messageId);
-}
-function clearSessionMessageId(sessionKey) {
-  sessionMessageIdMap.delete(normalizeSessionKey(sessionKey));
-}
-function setDispatchMessageId(sessionKey, messageId) {
-  dispatchMessageIdMap.set(normalizeSessionKey(sessionKey), messageId);
-}
-function getDispatchMessageId(sessionKey) {
-  return dispatchMessageIdMap.get(normalizeSessionKey(sessionKey));
-}
-function clearDispatchMessageId(sessionKey) {
-  dispatchMessageIdMap.delete(normalizeSessionKey(sessionKey));
-}
-function setDispatchGroupKey(sessionKey, groupKey) {
-  dispatchGroupKeyMap.set(normalizeSessionKey(sessionKey), groupKey);
-}
-function getDispatchGroupKey(sessionKey) {
-  return dispatchGroupKeyMap.get(normalizeSessionKey(sessionKey));
-}
-function clearDispatchGroupKey(sessionKey) {
-  dispatchGroupKeyMap.delete(normalizeSessionKey(sessionKey));
-}
-function setDispatchNoReply(sessionKey, noReply) {
-  dispatchNoReplyMap.set(normalizeSessionKey(sessionKey), noReply);
-}
-function clearDispatchNoReply(sessionKey) {
-  dispatchNoReplyMap.delete(normalizeSessionKey(sessionKey));
-}
-var dispatchMetricsMap = /* @__PURE__ */ new Map();
-function resetDispatchMetrics(sessionKey) {
-  dispatchMetricsMap.set(normalizeSessionKey(sessionKey), {
-    deliver_text_chunks: 0,
-    deliver_text_chars: 0,
-    message_send_attempts: 0,
-    message_send_successes: 0,
-    no_reply_called: false,
-    tool_call_count: 0,
-    started_at: Date.now()
-  });
-}
-function getDispatchMetrics(sessionKey) {
-  return dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
-}
-function clearDispatchMetrics(sessionKey) {
-  dispatchMetricsMap.delete(normalizeSessionKey(sessionKey));
-}
-function recordDeliverText(sessionKey, charCount) {
-  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
-  if (!m)
-    return;
-  m.deliver_text_chunks++;
-  m.deliver_text_chars += charCount;
-}
-function recordMessageSend(sessionKey, success) {
-  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
-  if (!m)
-    return;
-  m.message_send_attempts++;
-  if (success)
-    m.message_send_successes++;
-}
-function recordNoReply(sessionKey) {
-  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
-  if (!m)
-    return;
-  m.no_reply_called = true;
-}
-function recordToolCall(sessionKey) {
-  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
-  if (!m)
-    return;
-  m.tool_call_count++;
-}
+// ../agent-core/dist/lane-ledger.js
+import * as fs from "node:fs";
 
-// ../agent-core/dist/routing.js
-var MAX_CONCURRENT_FORKS = 20;
-var defaultRoutingStrategy = (event, state) => {
-  if (state.mainCurrentTargetId === event.targetId) {
-    return { action: "buffer-main" };
-  }
-  const existingForkKey = state.activeForks.get(event.targetId);
-  if (existingForkKey)
-    return { action: "buffer-fork", forkKey: existingForkKey };
-  if (state.activeForks.size >= MAX_CONCURRENT_FORKS) {
-    return { action: "buffer-main" };
-  }
-  return { action: "new-fork" };
-};
-function routeTrigger(event, state, strategy = defaultRoutingStrategy) {
-  const existingForkKey = state.activeForks.get(event.targetId);
-  if (existingForkKey)
-    return { action: "buffer-fork", forkKey: existingForkKey };
-  if (!state.mainDispatching)
-    return { action: "main" };
-  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") {
-    const clipLabel = event.channelProvider ? `the \`${event.channelProvider}\` clip's` : "your channel provider clip's";
-    const apiLabel = event.channelProvider ?? "external platform";
-    const target = event.channelExternalConversationId ? `{"chat_id": "${event.channelExternalConversationId}", "text": "..."}` : `{"chat_id": "<conversation id>", "text": "..."}`;
-    const threadAlt = event.channelExternalMessageId ? ` To reply in-thread to this specific message, use {"message_id": "${event.channelExternalMessageId}", "text": "..."} instead.` : "";
-    return `
-<system-reminder>To reply, invoke ${clipLabel} \`send_message\` command with ${target} \u2014 your plain text output is NOT delivered to the external conversation.${threadAlt} The same clip's \`call\` command reaches the wider ${apiLabel} API when needed.</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
-var PRLL_IDENTITY_BASE = `## You on Parall
-
-Parall is a shared workspace where humans and agents work side by side as equals.
-You are a participant here, not a service. You hold tasks, own decisions, and are
-accountable for the work you take on \u2014 the same way a human teammate is.
-
-The people and agents around you are collaborators, not users to serve. Be honest,
-be direct, and care about the outcome of the work \u2014 not just the request in front
-of you.`;
-function sanitizeProfileField(value) {
-  return value.replace(/[\r\n]+/g, " ").replace(/`/g, "'").trim();
-}
-function sanitizeProfileBlock(value) {
-  return value.replace(/\r\n?/g, "\n").trim();
-}
-function buildIdentity(agent) {
-  if (!agent)
-    return PRLL_IDENTITY_BASE;
-  const name = sanitizeProfileField(agent.displayName);
-  const lines = [PRLL_IDENTITY_BASE, "", "### Your Parall Identity", ""];
-  lines.push(`You are **${name}** (\`prll://${agent.userId}\`).`);
-  if (agent.description) {
-    const description = sanitizeProfileBlock(agent.description);
-    if (description) {
-      lines.push("", "### Your Agent Profile", "", description);
-    }
-  }
-  lines.push("", `When you see \`${agent.userId}\` or \`prll://${agent.userId}\` in messages, mentions, or events \u2014 that's you.`);
-  return lines.join("\n");
-}
-var PRLL_BEHAVIOR = `## How to work here
-
-### Move work forward
-Don't wait for instructions. If you see the next step, take it. If something is
-ambiguous, clarify once and proceed. If you're blocked, say what's blocking you
-\u2014 don't go silent. Initiative is expected.
-
-Use schedules as self-reminders \u2014 re-checking blocked work, chasing unanswered
-requests, verifying something landed. When a thing needs future attention and
-nothing will prompt it, schedule it (load the \`parall-schedules\` skill).
-
-### Work in the open
-Nothing you do exists until the system can see it. Your progress, decisions,
-blockers, and results need to live in tasks, comments, messages, or wiki pages
-\u2014 otherwise the organization is blind to your work, and so is the next agent
-who picks up where you left off. Leave traces as you go, not at the end.
-
-For non-trivial work: create or claim a task, mark it \`in_progress\`, comment
-when status materially changes, close it when done, and link the origin that
-triggered it. Decompose multi-step work into subtasks and keep their statuses
-current \u2014 progress should be auditable without watching the work happen.
-Details: load the \`parall-tasks\` skill.
-
-### Done means landed
-Producing output does not complete a task. Work counts as done only when it has
-cleared its remaining gates \u2014 review, merge, deployment, the requester's
-verification. Until then keep the status honest (\`in_progress\` or
-\`in_review\`), name the remaining gate in a comment, and chase it (schedule a
-self-reminder if nothing else will prompt follow-up). Never mark done what a
-human still has to accept.
-
-### Sessions, forks, and what survives
-Sessions end and context compacts. Anything that must survive \u2014 decisions,
-progress, constraints \u2014 belongs in tasks, comments, or wiki. Future sessions
-read the workspace, not this conversation.
-
-Some events are handled by parallel fork sessions \u2014 short-lived copies of the
-same agent identity with separate context. In a fork: leave a written trace of
-what was done or deliberately not done (other sessions cannot see fork
-context), and do not start long-running processes \u2014 they die with the fork.
-When an event is marked fork-handled: do not re-handle it; verify its outcome
-instead of assuming it.
-
-### Communicate like a teammate
-Match the conversation \u2014 concise in chat, thorough in docs, plain language over
-jargon. Say what matters; stop when you're done. Don't narrate every tool call
-or pad replies to seem thorough.
-
-Match the language of the person you're replying to. If someone writes in
-Chinese, reply in Chinese. If in English, reply in English. Never force a
-language switch unless explicitly asked.
-
-Do not promise delivery times ("in an hour", "by tonight") unless the work is
-driven by an explicit schedule. Scope visibly; report when actually done.
-
-### Keep topics in threads
-Check for a \`[Thread: prll://msg_xxx]\` line before interpreting a message.
-Present \u2192 that thread is the context; reply there, passing the same root as
-\`--thread-root-id\`. Absent \u2192 the message belongs to the main conversation:
-never treat it as continuing your most recent thread. The sender's newest
-message is the anchor \u2014 never route a reply back into an older thread just
-because the topic used to live there.
-
-Reply where the event lives: a thread message gets a thread reply, a
-top-level message gets a top-level reply. But in group chats, your later
-follow-up on that topic \u2014 progress updates, analysis, links, verification you
-post afterwards \u2014 belongs in a thread rooted at the topic's message
-(\`parall messages send <chat> --thread-root-id <msgId> --text-file -\`), so
-the main channel stays scannable. Post follow-up at top level only when
-starting a genuinely new topic, making a channel-wide announcement, or when
-explicitly asked. Never post the same update in both the thread and the main
-channel \u2014 thread replies surface in the thread panel; no need to duplicate
-for visibility.
-
-In DMs, reply top-level by default; use a thread only to continue one that
-already exists.
-
-### Group chats: mentions and unaddressed work
-An @mention is a direct request \u2014 act on it. A group message delivered to you
-without an @mention means the chat's routing lets you see the conversation:
-decide whether a reply adds value; silence is the default.
-
-A message without an @mention is not an open invitation. Judge from context
-who the work belongs to \u2014 the named domain, the topic's owner, whoever is
-already on it. If it belongs to someone else, leave it. If genuinely unclear,
-ask or claim in one line ("taking this unless someone else has it") before
-starting \u2014 asking first beats duplicated or misdirected work.
-
-### Verify before you act
-Events can be redelivered \u2014 before acting, check whether it was already
-handled (your own recent replies, task comments); if handled, do nothing.
-Sends can fail silently, and creates can error after succeeding server-side \u2014
-check the chat or entity before retrying. Never blind-retry a mutating call.
-
-### Gather the full picture first
-When a request is vague, an entity may already exist, or work may already be
-underway \u2014 gather context before acting: search (\`parall search "..."\`),
-check existing tasks/chats/wiki, read the surrounding conversation. Act on the
-full picture, not the fragment that arrived in the event.
-
-### Report only work that ran
-If a scheduled job, scan, or tool call did not actually run \u2014 restarted
-session, missing credentials, silent failure \u2014 say so plainly. Never fabricate
-or approximate results of work that did not execute.
-
-### Respect what's shared
-You have broad latitude inside your own work. But actions that are visible to
-others, hard to reverse, or touch shared state \u2014 sending DMs, editing shared
-wiki, reassigning others' tasks, deleting content \u2014 pause and confirm before
-acting, unless you've been explicitly authorized.
-
-### Shared workspace
-Other agents share this workspace. Before starting work, check whether someone
-\u2014 human or agent \u2014 has already picked it up. Coordination beats racing.
-
-### Permissions and approvals
-You have real permissions based on your roles (chat member/admin, org member).
-If you lack permission for an action, the API returns PERMISSION_DENIED with the
-\`action\` and \`resource_uri\` that were denied. The server decides whether that
-action is approvable: if it is, the CLI prints an \`approvals request\` command \u2014
-fill in the placeholders it shows (\`--chat\`, \`--title\`, \`--reason\`) and run
-it to ask someone with permission. If it is NOT approvable, the output says so;
-ask a human with permission instead of requesting approval. A
-\`INVALID_TARGET\` error instead means you addressed the wrong kind of thing
-(e.g. a \`usr_\` id where a chat is expected) \u2014 follow the message (e.g. use
-\`dm\` for a user). Don't retry or work around a denial; only request approval
-after an actual denial, never preemptively.
-
-### When in doubt
-Prefer asking over guessing. Prefer "I don't know" over fabricating. Your
-credibility is what you bring to the workspace \u2014 protect it.`;
-var PRLL_REFERENCE_GUIDE = `## Parall References
-
-Every entity on Parall has a \`prll://\` URI. Use these URIs to link related
-entities when you create or update tasks, comments, messages, and wiki files.
-
-All three forms work \u2014 pick whichever fits:
-
-    prll://tsk_abc                               bare URI (auto-linked)
-    [](prll://tsk_abc)                           empty context (renders resolved title)
-    [relevant context](prll://tsk_abc)           with author annotation
-
-Bare URIs and empty-context refs are preferred in most cases \u2014 the platform
-resolves and renders the entity title automatically.
-
-### URI format
-
-\`prll://\` follows standard URI structure: \`scheme://authority/path?query#fragment\`.
-
-**Entities** \u2014 the entity ID is the authority:
-
-    prll://usr_xxx          user          prll://prj_xxx          project
-    prll://tsk_xxx          task          prll://wik_xxx          wiki
-    prll://msg_xxx          message       prll://tcm_xxx          task comment
-    prll://cht_xxx          chat          prll://ase_xxx          agent session
-    prll://att_xxx          attachment    prll://sch_xxx          schedule
-                                          prll://srn_xxx          schedule run
-
-**Wiki** \u2014 path is file path, fragment is a typed anchor:
-
-    prll://wik_xxx/docs/guide.md                  file
-    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)
-    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)
-
-  Anchor types: \`h=\` heading, \`l=\` line/range, \`s=\` symbol.
-  Line anchors in persistent content require \`?rev=<full-40-char-sha>\`.
-
-**Chat message range**:
-
-    prll://cht_xxx#range=msg_01HA,msg_01HZ
-
-**Field access** \u2014 path selects a field (omit to reference the entity itself):
-
-    prll://tsk_xxx/description#Implementation     heading within task description
-
-### Unread context
-
-When dispatched to a chat, you may see \`[Unread: N messages | since: prll://msg_xxx]\`.
-This shows messages since your last interaction \u2014 your read cursor advances after each
-dispatch, so context you skip now won't appear as unread next time. Use
-\`parall messages list <chat> --limit 20\` to fetch recent context. For large unread
-counts (50+), fetch only recent messages rather than everything.
-
-Thread dispatches may show \`[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]\`.
-Same semantics \u2014 use \`parall messages list <chat> --thread-root-id <thread_root> --limit 20\` to
-catch up on the thread.
-
-### Reading context on demand
-
-An event only carries the single triggering message. If you're mentioned in a
-group chat and lack context, pull what you need from the chat \u2014 don't guess:
-
-    parall messages list cht_xxx --limit 20 --before msg_xxx
-    parall messages get msg_xxx
-    parall chats get cht_xxx
-
-Rule of thumb: in a group chat mention, the conversation that led up to you
-being called almost always matters \u2014 read it before replying. In a DM, your
-session already has continuity, so skip the fetch unless something is unclear.
-
-Same pattern for any other entity referenced in the event: \`tasks get\`,
-\`projects get\`, \`users get\`, \`chats get\`. Follow the reflink, don't ask.
-
-### Find context with search first
-
-Reach for unified semantic search before paging chat history:
-
-    parall search "pricing decision june" [--limit 10]
-
-It spans messages, tasks, and wiki. Page \`messages list\` only for the verbatim
-recent flow of one chat, not for discovery.
-
-### File attachments
-
-Messages may include attachments. They appear in events as:
-
-    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]
-
-To download an attachment, use the CLI:
-
-    parall files download att_xxx --output /tmp/screenshot.png
-
-To send a file:
-
-    parall messages send prll://cht_xxx --file /tmp/output.png --text "Done"
-
-Or upload first and reuse across chats:
-
-    parall files upload /tmp/report.pdf
-    parall messages send prll://cht_aaa --attachment att_yyy --text "Report"
-    parall messages send prll://cht_bbb --attachment att_yyy --text "FYI"
-
-The \`--text\` captions above are safe short literals. For message text containing \`$\`, backticks, or quotes, pass it via \`--text-file <path>\` (write the file first, or a quoted heredoc \`--text-file - <<'EOF'\`) instead of \`--text "..."\` \u2014 inside double quotes the shell turns \`$1,000\` into \`,000\` and executes \`$(...)\`.
-
-### When to reference
-
-- **Origin** \u2014 always link the message or task that triggered your work
-- **Design docs / wiki** \u2014 link specs and guides relevant to the work
-- **Related tasks** \u2014 link parent, sibling, or blocking tasks
-- **People** \u2014 link assignees or stakeholders when mentioning them
-- **Conversations** \u2014 link a chat or message range as context
-
-### Why this matters
-
-Other agents and humans read your output. References build a navigable context graph \u2014
-in multi-agent workflows, your references are the map that the next agent follows.`;
-function renderLocalAttachmentSection(section) {
-  if (section.images.length === 0 && section.notes.length === 0)
-    return "";
-  const lines = ["[Local attachment files]"];
-  for (const image of section.images) {
-    lines.push(`- prll://${image.attachmentId} (${sanitizePromptMeta(image.mimeType)}, ${formatBytes(image.fileSize)}, ${sanitizePromptMeta(image.fileName)})`, `  ${image.localPath}`);
-  }
-  lines.push(...section.notes);
-  return lines.join("\n");
-}
-function sanitizePromptMeta(value) {
-  return value.replace(/[\r\n]+/g, " ").replace(/[()]/g, " ").trim();
-}
-function formatBytes(bytes) {
-  if (bytes >= 1048576)
-    return `${(bytes / 1048576).toFixed(1)}MB`;
-  if (bytes >= 1024)
-    return `${Math.round(bytes / 1024)}KB`;
-  return `${bytes}B`;
-}
-
-// ../agent-core/dist/bridge-workspace.js
-function extractShellCommand(input) {
-  if (!input || typeof input !== "object")
-    return void 0;
-  const command = input.command;
-  return typeof command === "string" && command.trim() ? command.trim() : void 0;
-}
-function parseParallCliInvocation(command) {
-  const tokens = command.replace(/\s+/g, " ").trim().split(" ");
-  let i = 0;
-  if (tokens[i] === "parall") {
-    i++;
-  } else if (tokens[i] === "npx") {
-    i++;
-    while (i < tokens.length && tokens[i].startsWith("-"))
-      i++;
-    if (i >= tokens.length || !/^@parall\/cli(?:@.+)?$/.test(tokens[i]))
-      return null;
-    i++;
-  } else if (tokens[i] === "pnpm") {
-    i++;
-    if (i < tokens.length && (tokens[i] === "exec" || tokens[i] === "dlx"))
-      i++;
-    if (i >= tokens.length || tokens[i] !== "parall")
-      return null;
-    i++;
-  } else {
-    return null;
-  }
-  return tokens.slice(i).filter((t) => !t.startsWith("-"));
-}
-function isParallSendCommand(command) {
-  if (!command)
-    return false;
-  const sub = parseParallCliInvocation(command);
-  if (!sub || sub.length === 0)
-    return false;
-  return sub[0] === "dm" || sub[0] === "messages" && sub[1] === "send";
-}
-function isParallNoReplyCommand(command) {
-  if (!command)
-    return false;
-  const sub = parseParallCliInvocation(command);
-  return sub?.[0] === "no-reply";
-}
-
-// ../agent-core/dist/dispatch-adapter.js
-function buildErrorStepContent(message) {
-  return { text: message, suppressed: false, status: "error" };
-}
-
-// ../agent-core/dist/gateway-base.js
-import * as os from "node:os";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-
-// ../sdk/dist/types.js
-var MENTION_ALL_USER_ID = "all";
+// ../sdk/dist/types.js
+var MENTION_ALL_USER_ID = "all";
 
 // ../sdk/dist/constants.js
 var API_BASE = "/api/v1";
@@ -27579,6 +26933,7 @@ var ParallClient = class _ParallClient {
   setTokens;
   refreshPromise = null;
   swimlaneName;
+  getFeatureFlagOverrides;
   /** Auth endpoints excluded from automatic 401 refresh to prevent recursion. */
   static AUTH_PATHS = /* @__PURE__ */ new Set([
     "/auth/login",
@@ -27609,7 +26964,7 @@ var ParallClient = class _ParallClient {
     return apiError;
   }
   /** Build headers common to all requests (auth, swimlane). */
-  buildHeaders(extra) {
+  buildHeaders(path9, extra) {
     const headers = {
       "Content-Type": "application/json",
       ...extra
@@ -27620,6 +26975,11 @@ var ParallClient = class _ParallClient {
     if (this.swimlaneName) {
       headers["X-Prll-Swimlane"] = this.swimlaneName;
     }
+    if (path9.startsWith(API_BASE)) {
+      const overrides = this.getFeatureFlagOverrides?.();
+      if (overrides)
+        headers["X-Prll-FF-Override"] = overrides;
+    }
     return headers;
   }
   constructor(options = {}) {
@@ -27630,6 +26990,7 @@ var ParallClient = class _ParallClient {
     this.getRefreshToken = options.getRefreshToken;
     this.setTokens = options.setTokens;
     this.swimlaneName = options.swimlaneName;
+    this.getFeatureFlagOverrides = options.getFeatureFlagOverrides;
   }
   /**
    * Pick the origin for a request path: wiki-service base for `/wiki/v1`
@@ -27637,8 +26998,8 @@ var ParallClient = class _ParallClient {
    * is authoritative, so wiki vs api routing can't drift from how a caller
    * happens to invoke the client.
    */
-  baseUrlFor(path8) {
-    return path8.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+  baseUrlFor(path9) {
+    return path9.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
   }
   setToken(token) {
     this.token = token;
@@ -27665,10 +27026,10 @@ var ParallClient = class _ParallClient {
    * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
    * No-op when the token is still fresh, missing, or un-parseable.
    */
-  async ensureFreshToken(path8) {
+  async ensureFreshToken(path9) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path8.replace(/^\/api\/v1/, "");
+    const pathSuffix = path9.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -27700,11 +27061,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path8, body, query, retried = false, opts) {
+  async request(method, path9, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path8);
+      await this.ensureFreshToken(path9);
     }
-    let url = `${this.baseUrlFor(path8)}${path8}`;
+    let url = `${this.baseUrlFor(path9)}${path9}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27716,7 +27077,7 @@ var ParallClient = class _ParallClient {
       if (qs)
         url += `?${qs}`;
     }
-    const headers = this.buildHeaders();
+    const headers = this.buildHeaders(path9);
     const timeoutSignal = AbortSignal.timeout(opts?.timeoutMs ?? 15e3);
     const signal = opts?.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
     let res;
@@ -27734,12 +27095,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path8.replace(/^\/api\/v1/, "");
+      const pathSuffix = path9.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path8, body, query, true, opts);
+          return this.request(method, path9, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27769,15 +27130,15 @@ var ParallClient = class _ParallClient {
    * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
    * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
    */
-  async multipartRequest(method, path8, body, retried = false) {
+  async multipartRequest(method, path9, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path8);
+      await this.ensureFreshToken(path9);
     }
-    const { "Content-Type": _drop, ...headers } = this.buildHeaders();
+    const { "Content-Type": _drop, ...headers } = this.buildHeaders(path9);
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrlFor(path8)}${path8}`, {
+      res = await fetch(`${this.baseUrlFor(path9)}${path9}`, {
         method,
         headers,
         body,
@@ -27787,12 +27148,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path8.replace(/^\/api\/v1/, "");
+      const pathSuffix = path9.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path8, body, true);
+          return this.multipartRequest(method, path9, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -28496,8 +27857,8 @@ var ParallClient = class _ParallClient {
   async requestMachineUpdate(orgId, machineId, mandatory = false) {
     await this.request("POST", ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
   }
-  async browseMachineFilesystem(orgId, machineId, path8) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path8 }, void 0, false, { timeoutMs: 15e3 });
+  async browseMachineFilesystem(orgId, machineId, path9) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path9 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -28582,7 +27943,6 @@ var ParallClient = class _ParallClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
-  /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
   async completeDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
   }
@@ -28590,6 +27950,10 @@ var ParallClient = class _ParallClient {
    * End a turn for a lane-less runtime: resolve the turn's folded WorkItems
    * by source — broad-cover to the turn's reply Effect when one exists,
    * 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).
    */
   async completeDispatchSources(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);
@@ -28618,7 +27982,7 @@ var ParallClient = class _ParallClient {
     if (currentVersion !== void 0) {
       extra["If-None-Match"] = currentVersion;
     }
-    const headers = this.buildHeaders(extra);
+    const headers = this.buildHeaders(ENDPOINTS.PLATFORM_CONFIG, extra);
     let res;
     try {
       res = await fetch(url, {
@@ -29066,8 +28430,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiRestriction(orgId, wikiId, restrictionId) {
     await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path8) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path8 ? { path: path8 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path9) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path9 ? { path: path9 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -29076,14 +28440,14 @@ var ParallClient = class _ParallClient {
   async getWikiCommits(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
   }
-  async getWikiFileCommits(orgId, wikiId, path8, params) {
+  async getWikiFileCommits(orgId, wikiId, path9, params) {
     return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-      path: path8,
+      path: path9,
       ...params
     });
   }
-  async getWikiBlame(orgId, wikiId, path8, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path8, ref });
+  async getWikiBlame(orgId, wikiId, path9, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path9, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -29281,858 +28645,1624 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", ENDPOINTS.CLIP_ONLINE(orgId));
     return resp.data;
   }
-  /** Deployment-wide hosted browser runtime availability — drives whether the
-   *  create UI offers the platform-hosted placement. Fail-closed server-side. */
-  async getBrowserRuntimeStatus(orgId) {
-    return this.request("GET", ENDPOINTS.BROWSER_RUNTIME_STATUS(orgId));
+  /** Deployment-wide hosted browser runtime availability — drives whether the
+   *  create UI offers the platform-hosted placement. Fail-closed server-side. */
+  async getBrowserRuntimeStatus(orgId) {
+    return this.request("GET", ENDPOINTS.BROWSER_RUNTIME_STATUS(orgId));
+  }
+  /** Org-wide browser-profile discovery list. Returns the sanitized
+   *  {@link BrowserProfileListItem} shape (not the full domain model), each row
+   *  carrying a per-viewer `can_open` control hint. */
+  async listBrowserProfiles(orgId) {
+    const resp = await this.request("GET", ENDPOINTS.BROWSER_PROFILES(orgId));
+    return resp.data;
+  }
+  async createBrowserProfile(orgId, req) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILES(orgId), req);
+  }
+  async getBrowserProfile(orgId, profileId) {
+    return this.request("GET", ENDPOINTS.BROWSER_PROFILE(orgId, profileId));
+  }
+  async updateBrowserProfile(orgId, profileId, req) {
+    return this.request("PATCH", ENDPOINTS.BROWSER_PROFILE(orgId, profileId), req);
+  }
+  async deleteBrowserProfile(orgId, profileId) {
+    await this.request("DELETE", ENDPOINTS.BROWSER_PROFILE(orgId, profileId));
+  }
+  async openBrowserProfile(orgId, profileId, req = {}) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_OPEN(orgId, profileId), req);
+  }
+  async stopBrowserProfile(orgId, profileId) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_STOP(orgId, profileId), {});
+  }
+  async resetBrowserProfile(orgId, profileId) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_RESET(orgId, profileId));
+  }
+  async listBrowserProfileConsents(orgId, profileId) {
+    const resp = await this.request("GET", ENDPOINTS.BROWSER_PROFILE_CONSENTS(orgId, profileId));
+    return resp.data;
+  }
+  async grantBrowserProfileConsent(orgId, profileId, req) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_CONSENTS(orgId, profileId), req);
+  }
+  async revokeBrowserProfileConsent(orgId, profileId, clipId) {
+    await this.request("DELETE", ENDPOINTS.BROWSER_PROFILE_CONSENT(orgId, profileId, clipId));
+  }
+  async listRegistryClips(q) {
+    const url = ENDPOINTS.CLIP_REGISTRY() + (q ? `?q=${encodeURIComponent(q)}` : "");
+    const resp = await this.request("GET", url);
+    return resp.data;
+  }
+  // ---- Edge devices ----
+  async listEdgeDevices(orgId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
+  }
+  async getEdgeOnboarding(orgId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_ONBOARDING(orgId));
+  }
+  async listEdgeProfiles(orgId, edgeId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
+  }
+  // ---- Clip connections ----
+  async listClipConnections(orgId, clipId) {
+    return this.request("GET", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId));
+  }
+  async createClipConnection(orgId, clipId, input) {
+    return this.request("POST", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId), input);
+  }
+  async deleteClipConnection(orgId, connId) {
+    return this.request("DELETE", ENDPOINTS.CLIP_CONNECTION(orgId, connId));
+  }
+};
+function normalizeWikiChangeset(changeset) {
+  return {
+    ...changeset,
+    changed_paths: changeset.changed_paths ?? [],
+    file_changes: changeset.file_changes ?? []
+  };
+}
+var ApiError = class extends Error {
+  status;
+  code;
+  extras;
+  /** Attempted action (authorization denials) — e.g. "chat.add_member". */
+  action;
+  /** Target resource URI that was evaluated — e.g. "prll://cht_…". */
+  resourceUri;
+  /** Whether the action is approval-executable (PERMISSION_DENIED only). */
+  approvable;
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+};
+function buildApiError(res, rawErrorBody) {
+  const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
+  const errorObj = errorBody.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
+  const errMsg = (typeof errorObj?.message === "string" ? errorObj.message : void 0) ?? (typeof errorBody.message === "string" ? errorBody.message : void 0) ?? (typeof errorBody.error === "string" ? errorBody.error : void 0);
+  const errCode = (typeof errorObj?.code === "string" ? errorObj.code : void 0) ?? (typeof errorBody.code === "string" ? errorBody.code : void 0);
+  const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
+  const anchors = errorObj ?? errorBody;
+  if (typeof anchors.action === "string")
+    apiError.action = anchors.action;
+  if (typeof anchors.resource_uri === "string")
+    apiError.resourceUri = anchors.resource_uri;
+  if (typeof anchors.approvable === "boolean")
+    apiError.approvable = anchors.approvable;
+  const structural = /* @__PURE__ */ new Set(["error", "code", "message", "status"]);
+  const extras = {};
+  for (const [k, v] of Object.entries(errorBody))
+    if (!structural.has(k))
+      extras[k] = v;
+  if (errorObj) {
+    for (const [k, v] of Object.entries(errorObj))
+      if (!structural.has(k))
+        extras[k] = v;
+  }
+  if (Object.keys(extras).length > 0)
+    apiError.extras = extras;
+  return apiError;
+}
+
+// ../sdk/dist/ws.js
+function isRetryableNetworkError(err) {
+  return err instanceof Error && err.name === "ApiError" && "status" in err && err.status === 0;
+}
+function isBrowserRuntime() {
+  return typeof window !== "undefined";
+}
+var ParallWs = class {
+  ws = null;
+  options;
+  listeners = /* @__PURE__ */ new Map();
+  stateListeners = /* @__PURE__ */ new Set();
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  lastSeq = 0;
+  _state = "disconnected";
+  intentionalClose = false;
+  lastReceivedAt = 0;
+  heartbeatIntervalMs = 0;
+  probeTimer = null;
+  browserListenersActive = false;
+  constructor(options) {
+    this.options = {
+      reconnect: true,
+      reconnectInterval: 1e3,
+      maxReconnectInterval: 3e4,
+      ...options
+    };
+    this.lastSeq = options.lastSeq ?? 0;
+  }
+  get state() {
+    return this._state;
+  }
+  async connect() {
+    this.intentionalClose = false;
+    this.setupBrowserListeners();
+    this.setState("connecting");
+    let ticket;
+    try {
+      ticket = await this.options.getTicket();
+    } catch (err) {
+      if (isBrowserRuntime() && isRetryableNetworkError(err)) {
+        console.warn("Failed to get WS ticket:", err);
+      } else {
+        console.error("Failed to get WS ticket:", err);
+      }
+      if (this.options.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("disconnected");
+      }
+      return;
+    }
+    const wsUrl = ticket.ws_url || this.options.wsUrl;
+    if (!wsUrl) {
+      console.error("No WS URL available");
+      this.setState("disconnected");
+      return;
+    }
+    const url = new URL(wsUrl);
+    url.searchParams.set("ticket", ticket.ticket);
+    if (this.lastSeq > 0) {
+      url.searchParams.set("last_seq", String(this.lastSeq));
+    }
+    this.ws = new WebSocket(url.toString());
+    const ws = this.ws;
+    const connectTimeout = setTimeout(() => {
+      if (this._state === "connected" || this.intentionalClose)
+        return;
+      ws.onclose = null;
+      ws.onopen = null;
+      ws.onerror = null;
+      try {
+        ws.close();
+      } catch {
+      }
+      if (ws !== this.ws)
+        return;
+      if (this.options.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("disconnected");
+      }
+    }, 15e3);
+    this.ws.onopen = () => {
+      clearTimeout(connectTimeout);
+      this.reconnectAttempts = 0;
+      this.lastReceivedAt = Date.now();
+      this.setState("connected");
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const frame = JSON.parse(event.data);
+        this.handleFrame(frame);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      clearTimeout(connectTimeout);
+      this.stopHeartbeat();
+      this.clearProbe();
+      if (this.intentionalClose) {
+        this.setState("disconnected");
+        return;
+      }
+      if (this.options.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("disconnected");
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    this.stopHeartbeat();
+    this.clearReconnect();
+    this.clearProbe();
+    this.teardownBrowserListeners();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
   }
-  /** Org-wide browser-profile discovery list. Returns the sanitized
-   *  {@link BrowserProfileListItem} shape (not the full domain model), each row
-   *  carrying a per-viewer `can_open` control hint. */
-  async listBrowserProfiles(orgId) {
-    const resp = await this.request("GET", ENDPOINTS.BROWSER_PROFILES(orgId));
-    return resp.data;
+  // ---- Client -> Server messages ----
+  /** Tell the server which chats the user is currently viewing (no auth implications). */
+  watch(chatIds) {
+    this.send({ type: WS_EVENTS.WATCH, data: { chat_ids: chatIds } });
   }
-  async createBrowserProfile(orgId, req) {
-    return this.request("POST", ENDPOINTS.BROWSER_PROFILES(orgId), req);
+  sendTyping(chatId, action, threadRootId) {
+    this.send({
+      type: WS_EVENTS.TYPING,
+      data: { chat_id: chatId, thread_root_id: threadRootId ?? null, action }
+    });
   }
-  async getBrowserProfile(orgId, profileId) {
-    return this.request("GET", ENDPOINTS.BROWSER_PROFILE(orgId, profileId));
+  /** Send an agent heartbeat with telemetry data. */
+  sendAgentHeartbeat(sessionId, telemetry) {
+    this.send({
+      type: WS_EVENTS.AGENT_HEARTBEAT,
+      data: { session_id: sessionId, telemetry }
+    });
   }
-  async updateBrowserProfile(orgId, profileId, req) {
-    return this.request("PATCH", ENDPOINTS.BROWSER_PROFILE(orgId, profileId), req);
+  sendEvent(type, data) {
+    this.send({ type, data });
   }
-  async deleteBrowserProfile(orgId, profileId) {
-    await this.request("DELETE", ENDPOINTS.BROWSER_PROFILE(orgId, profileId));
+  // ---- Event listeners ----
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
   }
-  async openBrowserProfile(orgId, profileId, req = {}) {
-    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_OPEN(orgId, profileId), req);
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
   }
-  async stopBrowserProfile(orgId, profileId) {
-    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_STOP(orgId, profileId), {});
+  onStateChange(handler) {
+    this.stateListeners.add(handler);
+    return () => {
+      this.stateListeners.delete(handler);
+    };
   }
-  async resetBrowserProfile(orgId, profileId) {
-    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_RESET(orgId, profileId));
+  // ---- Internal ----
+  send(frame) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(frame));
+    }
   }
-  async listBrowserProfileConsents(orgId, profileId) {
-    const resp = await this.request("GET", ENDPOINTS.BROWSER_PROFILE_CONSENTS(orgId, profileId));
-    return resp.data;
+  handleFrame(frame) {
+    this.lastReceivedAt = Date.now();
+    this.clearProbe();
+    if (frame.seq !== void 0) {
+      this.lastSeq = frame.seq;
+    }
+    if (frame.type === WS_EVENTS.HELLO) {
+      const interval = frame.data.heartbeat_interval;
+      this.startHeartbeat(interval);
+    }
+    const handlers = this.listeners.get(frame.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(frame.data, frame.seq);
+      }
+    }
   }
-  async grantBrowserProfileConsent(orgId, profileId, req) {
-    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_CONSENTS(orgId, profileId), req);
+  startHeartbeat(intervalSec) {
+    this.stopHeartbeat();
+    if (!Number.isFinite(intervalSec) || intervalSec <= 0) {
+      console.error("Invalid heartbeat interval from server:", intervalSec);
+      return;
+    }
+    this.heartbeatIntervalMs = intervalSec * 1e3;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.lastReceivedAt > 0 && Date.now() - this.lastReceivedAt > this.heartbeatIntervalMs * 1.5) {
+        this.probeConnection();
+        return;
+      }
+      this.send({ type: WS_EVENTS.PING, data: { ts: Date.now() } });
+    }, intervalSec * 1e3);
   }
-  async revokeBrowserProfileConsent(orgId, profileId, clipId) {
-    await this.request("DELETE", ENDPOINTS.BROWSER_PROFILE_CONSENT(orgId, profileId, clipId));
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
   }
-  async listRegistryClips(q) {
-    const url = ENDPOINTS.CLIP_REGISTRY() + (q ? `?q=${encodeURIComponent(q)}` : "");
-    const resp = await this.request("GET", url);
-    return resp.data;
+  scheduleReconnect() {
+    this.setState("reconnecting");
+    this.clearReconnect();
+    const base = Math.min(this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectInterval);
+    const delay = base * (0.5 + Math.random() * 0.5);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, delay);
   }
-  // ---- Edge devices ----
-  async listEdgeDevices(orgId) {
-    return this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
+  clearReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
   }
-  async getEdgeOnboarding(orgId) {
-    return this.request("GET", ENDPOINTS.ORG_EDGE_ONBOARDING(orgId));
+  /** Force-close a dead/stale connection and trigger reconnect. */
+  forceReconnect() {
+    this.stopHeartbeat();
+    this.clearReconnect();
+    this.clearProbe();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onopen = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    if (this.options.reconnect && !this.intentionalClose) {
+      this.scheduleReconnect();
+    } else {
+      this.setState("disconnected");
+    }
   }
-  async listEdgeProfiles(orgId, edgeId) {
-    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
+  // ---- Browser event listeners for proactive reconnection ----
+  setupBrowserListeners() {
+    if (this.browserListenersActive)
+      return;
+    this.browserListenersActive = true;
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.handleVisibilityChange);
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", this.handleOnline);
+    }
   }
-  // ---- Clip connections ----
-  async listClipConnections(orgId, clipId) {
-    return this.request("GET", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId));
+  teardownBrowserListeners() {
+    if (!this.browserListenersActive)
+      return;
+    this.browserListenersActive = false;
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+    }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this.handleOnline);
+    }
   }
-  async createClipConnection(orgId, clipId, input) {
-    return this.request("POST", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId), input);
+  /**
+   * Send a ping and arm a short timeout. If no frame arrives within 5s the
+   * connection is assumed dead and force-reconnected. Any received frame
+   * (including the pong) cancels the timer via clearProbe() in handleFrame.
+   */
+  probeConnection() {
+    if (this.probeTimer)
+      return;
+    this.send({ type: WS_EVENTS.PING, data: { ts: Date.now() } });
+    this.probeTimer = setTimeout(() => {
+      this.forceReconnect();
+    }, 5e3);
   }
-  async deleteClipConnection(orgId, connId) {
-    return this.request("DELETE", ENDPOINTS.CLIP_CONNECTION(orgId, connId));
+  clearProbe() {
+    if (this.probeTimer) {
+      clearTimeout(this.probeTimer);
+      this.probeTimer = null;
+    }
   }
-};
-function normalizeWikiChangeset(changeset) {
-  return {
-    ...changeset,
-    changed_paths: changeset.changed_paths ?? [],
-    file_changes: changeset.file_changes ?? []
+  /** Tab returned to foreground — verify connection or accelerate reconnect. */
+  handleVisibilityChange = () => {
+    if (typeof document !== "undefined" && document.hidden)
+      return;
+    if (this._state === "connected") {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        this.forceReconnect();
+      } else {
+        this.probeConnection();
+      }
+    } else if (this._state === "reconnecting") {
+      this.clearReconnect();
+      this.reconnectAttempts = 0;
+      this.connect();
+    }
   };
-}
-var ApiError = class extends Error {
-  status;
-  code;
-  extras;
-  /** Attempted action (authorization denials) — e.g. "chat.add_member". */
-  action;
-  /** Target resource URI that was evaluated — e.g. "prll://cht_…". */
-  resourceUri;
-  /** Whether the action is approval-executable (PERMISSION_DENIED only). */
-  approvable;
-  constructor(status, message, code) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.name = "ApiError";
+  /** Network restored — accelerate reconnection. */
+  handleOnline = () => {
+    if (this.intentionalClose)
+      return;
+    if (this._state === "connected") {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        this.forceReconnect();
+      } else {
+        this.probeConnection();
+      }
+    } else if (this._state === "reconnecting") {
+      this.clearReconnect();
+      this.reconnectAttempts = 0;
+      this.connect();
+    }
+  };
+  setState(state) {
+    this._state = state;
+    for (const listener of this.stateListeners) {
+      listener(state);
+    }
   }
 };
-function buildApiError(res, rawErrorBody) {
-  const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
-  const errorObj = errorBody.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
-  const errMsg = (typeof errorObj?.message === "string" ? errorObj.message : void 0) ?? (typeof errorBody.message === "string" ? errorBody.message : void 0) ?? (typeof errorBody.error === "string" ? errorBody.error : void 0);
-  const errCode = (typeof errorObj?.code === "string" ? errorObj.code : void 0) ?? (typeof errorBody.code === "string" ? errorBody.code : void 0);
-  const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
-  const anchors = errorObj ?? errorBody;
-  if (typeof anchors.action === "string")
-    apiError.action = anchors.action;
-  if (typeof anchors.resource_uri === "string")
-    apiError.resourceUri = anchors.resource_uri;
-  if (typeof anchors.approvable === "boolean")
-    apiError.approvable = anchors.approvable;
-  const structural = /* @__PURE__ */ new Set(["error", "code", "message", "status"]);
-  const extras = {};
-  for (const [k, v] of Object.entries(errorBody))
-    if (!structural.has(k))
-      extras[k] = v;
-  if (errorObj) {
-    for (const [k, v] of Object.entries(errorObj))
-      if (!structural.has(k))
-        extras[k] = v;
-  }
-  if (Object.keys(extras).length > 0)
-    apiError.extras = extras;
-  return apiError;
-}
 
-// ../sdk/dist/ws.js
-function isRetryableNetworkError(err) {
-  return err instanceof Error && err.name === "ApiError" && "status" in err && err.status === 0;
+// ../agent-core/dist/lane-ledger.js
+var LedgerUnsupportedError = class extends Error {
+};
+function isStaleLane(err) {
+  return err instanceof ApiError && err.status === 409 && err.code === "STALE_LANE";
 }
-function isBrowserRuntime() {
-  return typeof window !== "undefined";
+function isEndpointMissing(err) {
+  return err instanceof ApiError && err.status === 404 && !err.code;
 }
-var ParallWs = class {
-  ws = null;
-  options;
-  listeners = /* @__PURE__ */ new Map();
-  stateListeners = /* @__PURE__ */ new Set();
-  heartbeatTimer = null;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  lastSeq = 0;
-  _state = "disconnected";
-  intentionalClose = false;
-  lastReceivedAt = 0;
-  heartbeatIntervalMs = 0;
-  probeTimer = null;
-  browserListenersActive = false;
-  constructor(options) {
-    this.options = {
-      reconnect: true,
-      reconnectInterval: 1e3,
-      maxReconnectInterval: 3e4,
-      ...options
-    };
-    this.lastSeq = options.lastSeq ?? 0;
+var LaneLedger = class {
+  opts;
+  lanes = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
   }
-  get state() {
-    return this._state;
+  get contextDir() {
+    return this.opts.contextDir;
   }
-  async connect() {
-    this.intentionalClose = false;
-    this.setupBrowserListeners();
-    this.setState("connecting");
-    let ticket;
-    try {
-      ticket = await this.options.getTicket();
-    } catch (err) {
-      if (isBrowserRuntime() && isRetryableNetworkError(err)) {
-        console.warn("Failed to get WS ticket:", err);
-      } else {
-        console.error("Failed to get WS ticket:", err);
+  /** Only chat message events ride the lane ledger; typed events stay on the legacy ack path. */
+  handles(event) {
+    return event.type === "message" && event.targetId.startsWith("cht_");
+  }
+  laneKeyFor(event) {
+    if (event.type !== "message" && event.dispatchEventId) {
+      return laneKeyForTarget(`dsp:${event.dispatchEventId}`);
+    }
+    return laneKeyForTarget(`prll://${event.targetId}`, event.threadRootId);
+  }
+  getForEvent(event) {
+    return this.lanes.get(this.laneKeyFor(event));
+  }
+  laneContextPath(lane) {
+    return laneContextFilePath(this.opts.contextDir, lane.targetUri, lane.threadRootId);
+  }
+  /**
+   * Claim (or reuse) the lane for a group of same-lane message events and
+   * fold every group member into it. Returns 'foreign' when a healthy
+   * incumbent (another pod) holds the resource — the caller must not
+   * dispatch; the events stay pending server-side and re-drive after the
+   * incumbent completes.
+   */
+  async ensureLane(events) {
+    const trigger = events[events.length - 1];
+    const laneKey = this.laneKeyFor(trigger);
+    let lane = this.lanes.get(laneKey);
+    if (!lane) {
+      const targetUri = `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
+        });
+      } catch (err) {
+        if (isEndpointMissing(err))
+          throw new LedgerUnsupportedError("claim endpoint unavailable");
+        throw err;
       }
-      if (this.options.reconnect) {
-        this.scheduleReconnect();
-      } else {
-        this.setState("disconnected");
+      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`);
+        } else {
+          this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
+        }
+        return null;
       }
-      return;
-    }
-    const wsUrl = ticket.ws_url || this.options.wsUrl;
-    if (!wsUrl) {
-      console.error("No WS URL available");
-      this.setState("disconnected");
-      return;
-    }
-    const url = new URL(wsUrl);
-    url.searchParams.set("ticket", ticket.ticket);
-    if (this.lastSeq > 0) {
-      url.searchParams.set("last_seq", String(this.lastSeq));
+      const leaseUntilMs = Date.parse(res.lease_until ?? "");
+      lane = {
+        laneKey,
+        lane: res.lane,
+        targetUri,
+        threadRootId: trigger.threadRootId,
+        folded: /* @__PURE__ */ new Map(),
+        ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
+      };
+      for (const ev of res.events ?? []) {
+        lane.folded.set(ev.source_id, ev.id);
+      }
+      this.lanes.set(laneKey, lane);
     }
-    this.ws = new WebSocket(url.toString());
-    const ws = this.ws;
-    const connectTimeout = setTimeout(() => {
-      if (this._state === "connected" || this.intentionalClose)
-        return;
-      ws.onclose = null;
-      ws.onopen = null;
-      ws.onerror = null;
+    for (const ev of events) {
+      if (lane.folded.has(ev.messageId))
+        continue;
       try {
-        ws.close();
-      } catch {
+        const res = await this.opts.client.steerDispatch(this.opts.orgId, {
+          lane: lane.lane,
+          target_uri: lane.targetUri,
+          thread_root_id: lane.threadRootId,
+          ...ev.dispatchEventId ? { dispatch_event_id: ev.dispatchEventId } : { source_type: "message", source_id: ev.messageId }
+        });
+        lane.folded.set(ev.messageId, res.dispatch_event_id);
+      } catch (err) {
+        if (isStaleLane(err)) {
+          this.lanes.delete(laneKey);
+          return null;
+        }
+        this.opts.log?.warn(`steer fold failed for ${ev.messageId} \u2014 failing closed, releasing lane: ${String(err)}`);
+        await this.release(laneKey);
+        return null;
       }
-      if (ws !== this.ws)
-        return;
-      if (this.options.reconnect) {
-        this.scheduleReconnect();
+    }
+    return lane;
+  }
+  /**
+   * Fold a live mid-turn message into its active lane BEFORE injecting it
+   * into the running turn. Injection without a successful fold is forbidden —
+   * an un-folded injected message would be re-driven after complete and the
+   * model would handle it twice.
+   */
+  async steerLive(event) {
+    const laneKey = this.laneKeyFor(event);
+    const lane = this.lanes.get(laneKey);
+    if (!lane)
+      return false;
+    if (lane.folded.has(event.messageId))
+      return true;
+    try {
+      const res = await this.opts.client.steerDispatch(this.opts.orgId, {
+        lane: lane.lane,
+        target_uri: lane.targetUri,
+        thread_root_id: lane.threadRootId,
+        ...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;
+    } catch (err) {
+      if (isStaleLane(err)) {
+        this.lanes.delete(laneKey);
       } else {
-        this.setState("disconnected");
+        this.opts.log?.warn(`live steer failed for ${event.messageId}: ${String(err)}`);
       }
-    }, 15e3);
-    this.ws.onopen = () => {
-      clearTimeout(connectTimeout);
-      this.reconnectAttempts = 0;
-      this.lastReceivedAt = Date.now();
-      this.setState("connected");
-    };
-    this.ws.onmessage = (event) => {
-      try {
-        const frame = JSON.parse(event.data);
-        this.handleFrame(frame);
-      } catch {
+      return false;
+    }
+  }
+  /**
+   * Complete the lane when no local work remains for it: the server sweeps
+   * still-leased members as no_action, releases the occupancy row, and
+   * re-drives any same-target pending work. A STALE_LANE answer means a
+   * takeover already owns the resource — local state is dropped either way.
+   */
+  /**
+   * Record that the turn on this lane surfaced a runtime error. The flow
+   * settles an errored lane immediately (dispatchLaneGroup returns 'failed'
+   * after a forced complete), so the bit normally lives for one turn only —
+   * it is the transport between the gateway's per-session error signal and
+   * this lane's complete request.
+   */
+  markTurnError(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      lane.turnError = true;
+  }
+  async completeIfIdle(laneKey, hasMoreLocal) {
+    const lane = this.lanes.get(laneKey);
+    if (!lane || hasMoreLocal)
+      return;
+    this.lanes.delete(laneKey);
+    this.removeLaneContext(lane);
+    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"
+      });
+      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}`);
       }
-    };
-    this.ws.onclose = () => {
-      clearTimeout(connectTimeout);
-      this.stopHeartbeat();
-      this.clearProbe();
-      if (this.intentionalClose) {
-        this.setState("disconnected");
+    } catch (err) {
+      if (isStaleLane(err)) {
+        this.opts.log?.info(`lane complete skipped for ${lane.targetUri} \u2014 taken over`);
         return;
       }
-      if (this.options.reconnect) {
-        this.scheduleReconnect();
-      } else {
-        this.setState("disconnected");
-      }
-    };
-    this.ws.onerror = () => {
-    };
-  }
-  disconnect() {
-    this.intentionalClose = true;
-    this.stopHeartbeat();
-    this.clearReconnect();
-    this.clearProbe();
-    this.teardownBrowserListeners();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
+      this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
     }
-    this.setState("disconnected");
   }
-  // ---- Client -> Server messages ----
-  /** Tell the server which chats the user is currently viewing (no auth implications). */
-  watch(chatIds) {
-    this.send({ type: WS_EVENTS.WATCH, data: { chat_ids: chatIds } });
+  /**
+   * Renew one lane by its key — the external runtime-activity hook for
+   * adapters whose tool traffic bypasses the RuntimeEvent stream (openclaw
+   * hooks). Scoped to the session's own lane: renewing every lane would let
+   * one busy fork keep an unrelated stalled fork's lane leased forever.
+   */
+  renewByKey(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      this.maybeRenew(lane);
   }
-  sendTyping(chatId, action, threadRootId) {
-    this.send({
-      type: WS_EVENTS.TYPING,
-      data: { chat_id: chatId, thread_root_id: threadRootId ?? null, action }
+  /**
+   * Long-turn keepalive: renew the lane's lease on runtime activity, throttled
+   * so a chatty turn doesn't spam the server. Without this, a legitimately
+   * long turn (> lane TTL) would be dethroned mid-flight and every subsequent
+   * write misfired with STALE_LANE — the design doc's "long turns renew via
+   * step writes". Fire-and-forget: a failed renewal is surfaced by the next
+   * write's incumbency check anyway.
+   */
+  maybeRenew(lane) {
+    const now = Date.now();
+    const ttl = lane.leaseTtlMs ?? 10 * 6e4;
+    const until = lane.leaseUntilMs ?? now;
+    if (until - now > ttl / 2)
+      return;
+    lane.leaseUntilMs = now + ttl;
+    void this.opts.client.heartbeatDispatchLane(this.opts.orgId, {
+      lane: lane.lane,
+      target_uri: lane.targetUri,
+      thread_root_id: lane.threadRootId
+    }).then((res) => {
+      const until2 = Date.parse(res?.lease_until ?? "");
+      if (!Number.isNaN(until2))
+        lane.leaseUntilMs = until2;
+    }).catch((err) => {
+      if (isStaleLane(err)) {
+        this.lanes.delete(lane.laneKey);
+        this.opts.log?.warn(`lane ${lane.targetUri} was taken over during the turn`);
+        return;
+      }
+      this.opts.log?.warn(`lane heartbeat failed for ${lane.targetUri}: ${String(err)}`);
     });
   }
-  /** Send an agent heartbeat with telemetry data. */
-  sendAgentHeartbeat(sessionId, telemetry) {
-    this.send({
-      type: WS_EVENTS.AGENT_HEARTBEAT,
-      data: { session_id: sessionId, telemetry }
-    });
+  /**
+   * Release a lane's unresolved members back to pending (dispatch error /
+   * shutdown) so the next pod re-claims immediately instead of waiting out
+   * the lease.
+   */
+  async release(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (!lane)
+      return;
+    this.lanes.delete(laneKey);
+    this.removeLaneContext(lane);
+    try {
+      await this.opts.client.releaseDispatchLane(this.opts.orgId, lane.lane);
+    } catch (err) {
+      this.opts.log?.warn(`lane release failed for ${lane.targetUri}: ${String(err)}`);
+    }
   }
-  sendEvent(type, data) {
-    this.send({ type, data });
+  async releaseAll() {
+    const keys = [...this.lanes.keys()];
+    for (const key of keys) {
+      await this.release(key);
+    }
   }
-  // ---- Event listeners ----
-  on(event, handler) {
-    let set = this.listeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.listeners.set(event, set);
+  /** True when any lane is currently active (used by shutdown logging). */
+  get activeCount() {
+    return this.lanes.size;
+  }
+  /**
+   * Claim the single-member lane of one typed WorkItem (resource = dsp:<id>),
+   * by WorkItem id or by source identity (the live task.assigned event has no
+   * WorkItem id). Returns null when a healthy incumbent (another pod) holds
+   * it or the WorkItem is already resolved — the caller must skip processing.
+   */
+  async claimTyped(ref) {
+    let res;
+    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
+      });
+    } catch (err) {
+      if (isEndpointMissing(err))
+        throw new LedgerUnsupportedError("claim endpoint unavailable");
+      throw err;
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
+    if (!res.claimed || !res.lane || !res.events?.length)
+      return null;
+    const workItem = res.events[0];
+    const targetUri = `dsp:${workItem.id}`;
+    const leaseUntilMs = Date.parse(res.lease_until ?? "");
+    const lane = {
+      laneKey: laneKeyForTarget(targetUri),
+      lane: res.lane,
+      targetUri,
+      folded: /* @__PURE__ */ new Map([[workItem.source_id, workItem.id]]),
+      typedDispatchEventId: workItem.id,
+      ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
     };
+    this.lanes.set(lane.laneKey, lane);
+    return lane;
   }
-  off(event, handler) {
-    this.listeners.get(event)?.delete(handler);
+  /**
+   * Remove the per-lane context file (and its CLI sidecar) when the lane
+   * ends. A leftover file would make a later cross-context send to the same
+   * target bind a dead lane token and misfire with STALE_LANE instead of
+   * taking the plain non-ledger path.
+   */
+  removeLaneContext(lane) {
+    const contextPath = this.laneContextPath(lane);
+    for (const p of [contextPath, contextPath.replace(/\.json$/, ".reply-state.json")]) {
+      try {
+        fs.rmSync(p, { force: true });
+      } catch {
+      }
+    }
   }
-  onStateChange(handler) {
-    this.stateListeners.add(handler);
-    return () => {
-      this.stateListeners.delete(handler);
-    };
+};
+
+// ../agent-core/dist/gateway-lane-flow.js
+async function dispatchLaneGroup(host, opts) {
+  const ledger = host.laneLedger;
+  const event = opts.events[opts.events.length - 1];
+  let lane;
+  try {
+    lane = await ledger.ensureLane(opts.events);
+  } catch (err) {
+    if (!(err instanceof LedgerUnsupportedError))
+      throw err;
+    host.disableLedger("claim endpoint missing");
+    await host.emitDispatchReceived(event);
+    const dispatched2 = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
+    if (!dispatched2)
+      return "shutdown";
+    for (const ev of opts.events) {
+      host.opts.client.ackDispatch(host.opts.config.org_id, {
+        source_type: ev.ackSourceType ?? "message",
+        source_id: ev.ackSourceId ?? ev.messageId
+      }).catch(() => {
+      });
+    }
+    return "dispatched";
   }
-  // ---- Internal ----
-  send(frame) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(frame));
+  if (!lane) {
+    for (const ev of opts.events) {
+      host.dispatchedMessages.delete(ev.messageId);
     }
+    return "foreign";
+  }
+  host.noteSessionLane(opts.sessionKey, lane.laneKey);
+  let dispatched = false;
+  try {
+    dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
+  } catch (err) {
+    host.noteSessionLane(opts.sessionKey, null);
+    await ledger.release(lane.laneKey).catch(() => {
+    });
+    throw err;
+  } finally {
+    if (dispatched)
+      host.noteSessionLane(opts.sessionKey, null);
+  }
+  if (!dispatched) {
+    return "shutdown";
   }
-  handleFrame(frame) {
-    this.lastReceivedAt = Date.now();
-    this.clearProbe();
-    if (frame.seq !== void 0) {
-      this.lastSeq = frame.seq;
-    }
-    if (frame.type === WS_EVENTS.HELLO) {
-      const interval = frame.data.heartbeat_interval;
-      this.startHeartbeat(interval);
+  if (host.consumeTurnError(opts.sessionKey)) {
+    ledger.markTurnError(lane.laneKey);
+    for (const msgId of lane.folded.keys()) {
+      host.dispatchedMessages.delete(msgId);
     }
-    const handlers = this.listeners.get(frame.type);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(frame.data, frame.seq);
-      }
+    try {
+      host.opts.dispatchAdapter.abortDispatch?.(opts.sessionKey);
+    } catch {
     }
+    await ledger.completeIfIdle(lane.laneKey, false);
+    return "failed";
   }
-  startHeartbeat(intervalSec) {
-    this.stopHeartbeat();
-    if (!Number.isFinite(intervalSec) || intervalSec <= 0) {
-      console.error("Invalid heartbeat interval from server:", intervalSec);
-      return;
+  const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
+  await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
+  return "dispatched";
+}
+var TYPED_BACKOFF_BASE_MS = 2e3;
+var TYPED_BACKOFF_CAP_MS = 5 * 6e4;
+var TYPED_BACKOFF_MAP_CAP = 512;
+async function consumeTypedDispatch(host, ref, run, ack) {
+  const backoffKey = ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`;
+  const armed = host.typedRedriveBackoff.get(backoffKey);
+  if (armed) {
+    const waitMs = armed.until - Date.now();
+    if (waitMs > 0) {
+      host.opts.log?.info(`typed dispatch ${backoffKey} backing off ${Math.ceil(waitMs / 1e3)}s after ${armed.failures} failed consume(s)`);
+      await new Promise((resolve3) => {
+        const timer = setTimeout(resolve3, waitMs);
+        timer.unref?.();
+      });
     }
-    this.heartbeatIntervalMs = intervalSec * 1e3;
-    this.heartbeatTimer = setInterval(() => {
-      if (this.lastReceivedAt > 0 && Date.now() - this.lastReceivedAt > this.heartbeatIntervalMs * 1.5) {
-        this.probeConnection();
-        return;
-      }
-      this.send({ type: WS_EVENTS.PING, data: { ts: Date.now() } });
-    }, intervalSec * 1e3);
+    if (host.shuttingDown)
+      return;
   }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
+  const settleAck = (ackResult) => ackResult !== false;
+  const settle = (acked2) => {
+    if (acked2) {
+      host.typedRedriveBackoff.delete(backoffKey);
+      return;
     }
-  }
-  scheduleReconnect() {
-    this.setState("reconnecting");
-    this.clearReconnect();
-    const base = Math.min(this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectInterval);
-    const delay = base * (0.5 + Math.random() * 0.5);
-    this.reconnectAttempts++;
-    this.reconnectTimer = setTimeout(() => {
-      this.connect();
-    }, delay);
-  }
-  clearReconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
+    const failures = (host.typedRedriveBackoff.get(backoffKey)?.failures ?? 0) + 1;
+    const backoffMs = Math.min(TYPED_BACKOFF_CAP_MS, TYPED_BACKOFF_BASE_MS * 2 ** (failures - 1));
+    if (host.typedRedriveBackoff.delete(backoffKey) === false && host.typedRedriveBackoff.size >= TYPED_BACKOFF_MAP_CAP) {
+      const oldest = host.typedRedriveBackoff.keys().next().value;
+      if (oldest !== void 0)
+        host.typedRedriveBackoff.delete(oldest);
     }
-  }
-  /** Force-close a dead/stale connection and trigger reconnect. */
-  forceReconnect() {
-    this.stopHeartbeat();
-    this.clearReconnect();
-    this.clearProbe();
-    if (this.ws) {
-      this.ws.onclose = null;
-      this.ws.onopen = null;
-      this.ws.onerror = null;
-      this.ws.onmessage = null;
-      try {
-        this.ws.close();
-      } catch {
+    host.typedRedriveBackoff.set(backoffKey, { failures, until: Date.now() + backoffMs });
+  };
+  const runLegacy = async () => {
+    let acked2 = false;
+    try {
+      if (await run(ref.dispatchEventId)) {
+        acked2 = settleAck(await ack(ref.dispatchEventId));
       }
-      this.ws = null;
-    }
-    if (this.options.reconnect && !this.intentionalClose) {
-      this.scheduleReconnect();
-    } else {
-      this.setState("disconnected");
+    } finally {
+      settle(acked2);
     }
+  };
+  if (!host.laneLedger || host.ledgerDisabled) {
+    await runLegacy();
+    return;
   }
-  // ---- Browser event listeners for proactive reconnection ----
-  setupBrowserListeners() {
-    if (this.browserListenersActive)
+  let lane;
+  try {
+    lane = await host.laneLedger.claimTyped(ref);
+  } catch (err) {
+    if (err instanceof LedgerUnsupportedError) {
+      host.disableLedger("claim endpoint missing");
+      await runLegacy();
       return;
-    this.browserListenersActive = true;
-    if (typeof document !== "undefined") {
-      document.addEventListener("visibilitychange", this.handleVisibilityChange);
     }
-    if (typeof window !== "undefined") {
-      window.addEventListener("online", this.handleOnline);
+    throw err;
+  }
+  if (!lane) {
+    host.opts.log?.info(`typed dispatch ${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`} not claimable (held elsewhere or already resolved) \u2014 skipping`);
+    return;
+  }
+  let acked = false;
+  try {
+    if (await run(lane.typedDispatchEventId)) {
+      acked = settleAck(await ack(lane.typedDispatchEventId));
     }
+  } finally {
+    settle(acked);
+    await host.laneLedger.completeIfIdle(lane.laneKey, false).catch(() => {
+    });
   }
-  teardownBrowserListeners() {
-    if (!this.browserListenersActive)
+}
+async function consumeMessageWorkItem(host, item) {
+  if (host.shuttingDown)
+    return;
+  if (!host.tryClaimMessage(item.source_id))
+    return;
+  const ackItem = () => {
+    host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => {
+    });
+  };
+  let msg = null;
+  try {
+    msg = await host.opts.client.getMessage(item.source_id);
+  } catch (err) {
+    const status = err?.status;
+    if (status !== 404) {
+      host.opts.log?.warn(`message fetch failed for ${item.source_id}, leaving pending: ${String(err)}`);
+      host.dispatchedMessages.delete(item.source_id);
       return;
-    this.browserListenersActive = false;
-    if (typeof document !== "undefined") {
-      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
     }
-    if (typeof window !== "undefined") {
-      window.removeEventListener("online", this.handleOnline);
+  }
+  if (!msg || msg.sender_id === host.opts.agentUserId) {
+    host.dispatchedMessages.delete(item.source_id);
+    ackItem();
+    return;
+  }
+  const decision = await host.buildMessageDispatchDecision(item.chat_id, msg);
+  if (decision.action === "retry") {
+    host.dispatchedMessages.delete(item.source_id);
+    return;
+  }
+  if (decision.action === "skip") {
+    host.dispatchedMessages.delete(item.source_id);
+    ackItem();
+    return;
+  }
+  decision.event.dispatchEventId = item.id;
+  const laneResolved = host.usesLaneLedger(decision.event);
+  try {
+    const dispatched = await host.handleInboundEvent(decision.event);
+    if (dispatched) {
+      if (!laneResolved)
+        ackItem();
+    } else {
+      host.dispatchedMessages.delete(item.source_id);
     }
+  } catch (err) {
+    host.dispatchedMessages.delete(item.source_id);
+    throw err;
+  }
+}
+
+// ../agent-core/dist/session-state.js
+function normalizeSessionKey(sessionKey) {
+  return sessionKey.toLowerCase();
+}
+var sessionChatIdMap = /* @__PURE__ */ new Map();
+var sessionMessageIdMap = /* @__PURE__ */ new Map();
+var dispatchMessageIdMap = /* @__PURE__ */ new Map();
+var dispatchGroupKeyMap = /* @__PURE__ */ new Map();
+var dispatchNoReplyMap = /* @__PURE__ */ new Map();
+function setSessionChatId(sessionKey, chatId) {
+  sessionChatIdMap.set(normalizeSessionKey(sessionKey), chatId);
+}
+function getSessionChatId(sessionKey) {
+  return sessionChatIdMap.get(normalizeSessionKey(sessionKey));
+}
+function setSessionMessageId(sessionKey, messageId) {
+  sessionMessageIdMap.set(normalizeSessionKey(sessionKey), messageId);
+}
+function clearSessionMessageId(sessionKey) {
+  sessionMessageIdMap.delete(normalizeSessionKey(sessionKey));
+}
+function setDispatchMessageId(sessionKey, messageId) {
+  dispatchMessageIdMap.set(normalizeSessionKey(sessionKey), messageId);
+}
+function getDispatchMessageId(sessionKey) {
+  return dispatchMessageIdMap.get(normalizeSessionKey(sessionKey));
+}
+function clearDispatchMessageId(sessionKey) {
+  dispatchMessageIdMap.delete(normalizeSessionKey(sessionKey));
+}
+function setDispatchGroupKey(sessionKey, groupKey) {
+  dispatchGroupKeyMap.set(normalizeSessionKey(sessionKey), groupKey);
+}
+function getDispatchGroupKey(sessionKey) {
+  return dispatchGroupKeyMap.get(normalizeSessionKey(sessionKey));
+}
+function clearDispatchGroupKey(sessionKey) {
+  dispatchGroupKeyMap.delete(normalizeSessionKey(sessionKey));
+}
+function setDispatchNoReply(sessionKey, noReply) {
+  dispatchNoReplyMap.set(normalizeSessionKey(sessionKey), noReply);
+}
+function clearDispatchNoReply(sessionKey) {
+  dispatchNoReplyMap.delete(normalizeSessionKey(sessionKey));
+}
+var dispatchMetricsMap = /* @__PURE__ */ new Map();
+function resetDispatchMetrics(sessionKey) {
+  dispatchMetricsMap.set(normalizeSessionKey(sessionKey), {
+    deliver_text_chunks: 0,
+    deliver_text_chars: 0,
+    message_send_attempts: 0,
+    message_send_successes: 0,
+    no_reply_called: false,
+    tool_call_count: 0,
+    started_at: Date.now()
+  });
+}
+function getDispatchMetrics(sessionKey) {
+  return dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
+}
+function clearDispatchMetrics(sessionKey) {
+  dispatchMetricsMap.delete(normalizeSessionKey(sessionKey));
+}
+function recordDeliverText(sessionKey, charCount) {
+  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
+  if (!m)
+    return;
+  m.deliver_text_chunks++;
+  m.deliver_text_chars += charCount;
+}
+function recordMessageSend(sessionKey, success) {
+  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
+  if (!m)
+    return;
+  m.message_send_attempts++;
+  if (success)
+    m.message_send_successes++;
+}
+function recordNoReply(sessionKey) {
+  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
+  if (!m)
+    return;
+  m.no_reply_called = true;
+}
+function recordToolCall(sessionKey) {
+  const m = dispatchMetricsMap.get(normalizeSessionKey(sessionKey));
+  if (!m)
+    return;
+  m.tool_call_count++;
+}
+
+// ../agent-core/dist/routing.js
+var MAX_CONCURRENT_FORKS = 20;
+var defaultRoutingStrategy = (event, state) => {
+  if (state.mainCurrentTargetId === event.targetId) {
+    return { action: "buffer-main" };
   }
-  /**
-   * Send a ping and arm a short timeout. If no frame arrives within 5s the
-   * connection is assumed dead and force-reconnected. Any received frame
-   * (including the pong) cancels the timer via clearProbe() in handleFrame.
-   */
-  probeConnection() {
-    if (this.probeTimer)
-      return;
-    this.send({ type: WS_EVENTS.PING, data: { ts: Date.now() } });
-    this.probeTimer = setTimeout(() => {
-      this.forceReconnect();
-    }, 5e3);
+  const existingForkKey = state.activeForks.get(event.targetId);
+  if (existingForkKey)
+    return { action: "buffer-fork", forkKey: existingForkKey };
+  if (state.activeForks.size >= MAX_CONCURRENT_FORKS) {
+    return { action: "buffer-main" };
   }
-  clearProbe() {
-    if (this.probeTimer) {
-      clearTimeout(this.probeTimer);
-      this.probeTimer = null;
+  return { action: "new-fork" };
+};
+function routeTrigger(event, state, strategy = defaultRoutingStrategy) {
+  const existingForkKey = state.activeForks.get(event.targetId);
+  if (existingForkKey)
+    return { action: "buffer-fork", forkKey: existingForkKey };
+  if (!state.mainDispatching)
+    return { action: "main" };
+  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}]`);
     }
-  }
-  /** Tab returned to foreground — verify connection or accelerate reconnect. */
-  handleVisibilityChange = () => {
-    if (typeof document !== "undefined" && document.hidden)
-      return;
-    if (this._state === "connected") {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        this.forceReconnect();
-      } else {
-        this.probeConnection();
-      }
-    } else if (this._state === "reconnecting") {
-      this.clearReconnect();
-      this.reconnectAttempts = 0;
-      this.connect();
+    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);
     }
-  };
-  /** Network restored — accelerate reconnection. */
-  handleOnline = () => {
-    if (this.intentionalClose)
-      return;
-    if (this._state === "connected") {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        this.forceReconnect();
-      } else {
-        this.probeConnection();
+    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)}]`);
       }
-    } else if (this._state === "reconnecting") {
-      this.clearReconnect();
-      this.reconnectAttempts = 0;
-      this.connect();
     }
-  };
-  setState(state) {
-    this._state = state;
-    for (const listener of this.stateListeners) {
-      listener(state);
+    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}]`);
     }
-  }
-};
-
-// ../agent-core/dist/lane-ledger.js
-import * as fs from "node:fs";
-var LedgerUnsupportedError = class extends Error {
-};
-function isStaleLane(err) {
-  return err instanceof ApiError && err.status === 409 && err.code === "STALE_LANE";
-}
-function isEndpointMissing(err) {
-  return err instanceof ApiError && err.status === 404 && !err.code;
-}
-var LaneLedger = class {
-  opts;
-  lanes = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.opts = opts;
-  }
-  get contextDir() {
-    return this.opts.contextDir;
-  }
-  /** Only chat message events ride the lane ledger; typed events stay on the legacy ack path. */
-  handles(event) {
-    return event.type === "message" && event.targetId.startsWith("cht_");
-  }
-  laneKeyFor(event) {
-    if (event.type !== "message" && event.dispatchEventId) {
-      return laneKeyForTarget(`dsp:${event.dispatchEventId}`);
+    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)}]`);
     }
-    return laneKeyForTarget(`prll://${event.targetId}`, event.threadRootId);
-  }
-  getForEvent(event) {
-    return this.lanes.get(this.laneKeyFor(event));
-  }
-  laneContextPath(lane) {
-    return laneContextFilePath(this.opts.contextDir, lane.targetUri, lane.threadRootId);
-  }
-  /**
-   * Claim (or reuse) the lane for a group of same-lane message events and
-   * fold every group member into it. Returns 'foreign' when a healthy
-   * incumbent (another pod) holds the resource — the caller must not
-   * dispatch; the events stay pending server-side and re-drive after the
-   * incumbent completes.
-   */
-  async ensureLane(events) {
-    const trigger = events[events.length - 1];
-    const laneKey = this.laneKeyFor(trigger);
-    let lane = this.lanes.get(laneKey);
-    if (!lane) {
-      const targetUri = `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
-        });
-      } catch (err) {
-        if (isEndpointMissing(err))
-          throw new LedgerUnsupportedError("claim endpoint unavailable");
-        throw err;
-      }
-      if (!res.claimed || !res.lane) {
-        this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
-        return null;
-      }
-      const leaseUntilMs = Date.parse(res.lease_until ?? "");
-      lane = {
-        laneKey,
-        lane: res.lane,
-        targetUri,
-        threadRootId: trigger.threadRootId,
-        folded: /* @__PURE__ */ new Map(),
-        ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
-      };
-      for (const ev of res.events ?? []) {
-        lane.folded.set(ev.source_id, ev.id);
-      }
-      this.lanes.set(laneKey, lane);
+    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}]`);
     }
-    for (const ev of events) {
-      if (lane.folded.has(ev.messageId))
-        continue;
-      try {
-        const res = await this.opts.client.steerDispatch(this.opts.orgId, {
-          lane: lane.lane,
-          target_uri: lane.targetUri,
-          thread_root_id: lane.threadRootId,
-          ...ev.dispatchEventId ? { dispatch_event_id: ev.dispatchEventId } : { source_type: "message", source_id: ev.messageId }
-        });
-        lane.folded.set(ev.messageId, res.dispatch_event_id);
-      } catch (err) {
-        if (isStaleLane(err)) {
-          this.lanes.delete(laneKey);
-          return null;
-        }
-        this.opts.log?.warn(`steer fold failed for ${ev.messageId} \u2014 failing closed, releasing lane: ${String(err)}`);
-        await this.release(laneKey);
-        return null;
-      }
+    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)}]`);
     }
-    return lane;
-  }
-  /**
-   * Fold a live mid-turn message into its active lane BEFORE injecting it
-   * into the running turn. Injection without a successful fold is forbidden —
-   * an un-folded injected message would be re-driven after complete and the
-   * model would handle it twice.
-   */
-  async steerLive(event) {
-    const laneKey = this.laneKeyFor(event);
-    const lane = this.lanes.get(laneKey);
-    if (!lane)
-      return false;
-    if (lane.folded.has(event.messageId))
-      return true;
-    try {
-      const res = await this.opts.client.steerDispatch(this.opts.orgId, {
-        lane: lane.lane,
-        target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId,
-        ...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;
-    } catch (err) {
-      if (isStaleLane(err)) {
-        this.lanes.delete(laneKey);
-      } else {
-        this.opts.log?.warn(`live steer failed for ${event.messageId}: ${String(err)}`);
-      }
-      return false;
+    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);
   }
-  /**
-   * Complete the lane when no local work remains for it: the server sweeps
-   * still-leased members as no_action, releases the occupancy row, and
-   * re-drives any same-target pending work. A STALE_LANE answer means a
-   * takeover already owns the resource — local state is dropped either way.
-   */
-  async completeIfIdle(laneKey, hasMoreLocal) {
-    const lane = this.lanes.get(laneKey);
-    if (!lane || hasMoreLocal)
-      return;
-    this.lanes.delete(laneKey);
-    this.removeLaneContext(lane);
-    try {
-      const res = await this.opts.client.completeDispatch(this.opts.orgId, {
-        lane: lane.lane,
-        target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId
-      });
-      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;
-      }
-      this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
+  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>`;
   }
-  /**
-   * Long-turn keepalive: renew the lane's lease on runtime activity, throttled
-   * so a chatty turn doesn't spam the server. Without this, a legitimately
-   * long turn (> lane TTL) would be dethroned mid-flight and every subsequent
-   * write misfired with STALE_LANE — the design doc's "long turns renew via
-   * step writes". Fire-and-forget: a failed renewal is surfaced by the next
-   * write's incumbency check anyway.
-   */
-  maybeRenew(lane) {
-    const now = Date.now();
-    const ttl = lane.leaseTtlMs ?? 10 * 6e4;
-    const until = lane.leaseUntilMs ?? now;
-    if (until - now > ttl / 2)
-      return;
-    lane.leaseUntilMs = now + ttl;
-    void this.opts.client.heartbeatDispatchLane(this.opts.orgId, {
-      lane: lane.lane,
-      target_uri: lane.targetUri,
-      thread_root_id: lane.threadRootId
-    }).then((res) => {
-      const until2 = Date.parse(res?.lease_until ?? "");
-      if (!Number.isNaN(until2))
-        lane.leaseUntilMs = until2;
-    }).catch((err) => {
-      if (isStaleLane(err)) {
-        this.lanes.delete(lane.laneKey);
-        this.opts.log?.warn(`lane ${lane.targetUri} was taken over during the turn`);
-        return;
-      }
-      this.opts.log?.warn(`lane heartbeat failed for ${lane.targetUri}: ${String(err)}`);
-    });
+  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>`;
   }
-  /**
-   * Release a lane's unresolved members back to pending (dispatch error /
-   * shutdown) so the next pod re-claims immediately instead of waiting out
-   * the lease.
-   */
-  async release(laneKey) {
-    const lane = this.lanes.get(laneKey);
-    if (!lane)
-      return;
-    this.lanes.delete(laneKey);
-    this.removeLaneContext(lane);
-    try {
-      await this.opts.client.releaseDispatchLane(this.opts.orgId, lane.lane);
-    } catch (err) {
-      this.opts.log?.warn(`lane release failed for ${lane.targetUri}: ${String(err)}`);
-    }
+  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>`;
   }
-  async releaseAll() {
-    const keys = [...this.lanes.keys()];
-    for (const key of keys) {
-      await this.release(key);
+  if (event.type === "channel_message") {
+    if (event.channelCliCapable) {
+      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>`;
   }
-  /** True when any lane is currently active (used by shutdown logging). */
-  get activeCount() {
-    return this.lanes.size;
+  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>`;
   }
-  /**
-   * Claim the single-member lane of one typed WorkItem (resource = dsp:<id>),
-   * by WorkItem id or by source identity (the live task.assigned event has no
-   * WorkItem id). Returns null when a healthy incumbent (another pod) holds
-   * it or the WorkItem is already resolved — the caller must skip processing.
-   */
-  async claimTyped(ref) {
-    let res;
-    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
-      });
-    } catch (err) {
-      if (isEndpointMissing(err))
-        throw new LedgerUnsupportedError("claim endpoint unavailable");
-      throw err;
+  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);
     }
-    if (!res.claimed || !res.lane || !res.events?.length)
-      return null;
-    const workItem = res.events[0];
-    const targetUri = `dsp:${workItem.id}`;
-    const leaseUntilMs = Date.parse(res.lease_until ?? "");
-    const lane = {
-      laneKey: laneKeyForTarget(targetUri),
-      lane: res.lane,
-      targetUri,
-      folded: /* @__PURE__ */ new Map([[workItem.source_id, workItem.id]]),
-      typedDispatchEventId: workItem.id,
-      ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
-    };
-    this.lanes.set(lane.laneKey, lane);
-    return lane;
-  }
-  /**
-   * Remove the per-lane context file (and its CLI sidecar) when the lane
-   * ends. A leftover file would make a later cross-context send to the same
-   * target bind a dead lane token and misfire with STALE_LANE instead of
-   * taking the plain non-ledger path.
-   */
-  removeLaneContext(lane) {
-    const contextPath = this.laneContextPath(lane);
-    for (const p of [contextPath, contextPath.replace(/\.json$/, ".reply-state.json")]) {
-      try {
-        fs.rmSync(p, { force: true });
-      } catch {
-      }
+    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
+var PRLL_IDENTITY_BASE = `## You on Parall
+
+Parall is a shared workspace where humans and agents work side by side as equals.
+You are a participant here, not a service. You hold tasks, own decisions, and are
+accountable for the work you take on \u2014 the same way a human teammate is.
+
+The people and agents around you are collaborators, not users to serve. Be honest,
+be direct, and care about the outcome of the work \u2014 not just the request in front
+of you.`;
+function sanitizeProfileField(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/`/g, "'").trim();
+}
+function sanitizeProfileBlock(value) {
+  return value.replace(/\r\n?/g, "\n").trim();
+}
+function buildIdentity(agent) {
+  if (!agent)
+    return PRLL_IDENTITY_BASE;
+  const name = sanitizeProfileField(agent.displayName);
+  const lines = [PRLL_IDENTITY_BASE, "", "### Your Parall Identity", ""];
+  lines.push(`You are **${name}** (\`prll://${agent.userId}\`).`);
+  if (agent.description) {
+    const description = sanitizeProfileBlock(agent.description);
+    if (description) {
+      lines.push("", "### Your Agent Profile", "", description);
     }
   }
-};
+  lines.push("", `When you see \`${agent.userId}\` or \`prll://${agent.userId}\` in messages, mentions, or events \u2014 that's you.`);
+  return lines.join("\n");
+}
+var PRLL_BEHAVIOR = `## How to work here
 
-// ../agent-core/dist/gateway-lane-flow.js
-async function dispatchLaneGroup(host, opts) {
-  const ledger = host.laneLedger;
-  const event = opts.events[opts.events.length - 1];
-  let lane;
-  try {
-    lane = await ledger.ensureLane(opts.events);
-  } catch (err) {
-    if (!(err instanceof LedgerUnsupportedError))
-      throw err;
-    host.disableLedger("claim endpoint missing");
-    await host.emitDispatchReceived(event);
-    const dispatched2 = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
-    if (!dispatched2)
-      return "shutdown";
-    for (const ev of opts.events) {
-      host.opts.client.ackDispatch(host.opts.config.org_id, {
-        source_type: ev.ackSourceType ?? "message",
-        source_id: ev.ackSourceId ?? ev.messageId
-      }).catch(() => {
-      });
-    }
-    return "dispatched";
-  }
-  if (!lane) {
-    for (const ev of opts.events) {
-      host.dispatchedMessages.delete(ev.messageId);
-    }
-    return "foreign";
-  }
-  let dispatched = false;
-  try {
-    dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
-  } catch (err) {
-    await ledger.release(lane.laneKey).catch(() => {
-    });
-    throw err;
-  }
-  if (!dispatched) {
-    return "shutdown";
+### Move work forward
+Don't wait for instructions. If you see the next step, take it. If something is
+ambiguous, clarify once and proceed. If you're blocked, say what's blocking you
+\u2014 don't go silent. Initiative is expected.
+
+Use schedules as self-reminders \u2014 re-checking blocked work, chasing unanswered
+requests, verifying something landed. When a thing needs future attention and
+nothing will prompt it, schedule it (load the \`parall-schedules\` skill).
+
+### Work in the open
+Nothing you do exists until the system can see it. Your progress, decisions,
+blockers, and results need to live in tasks, comments, messages, or wiki pages
+\u2014 otherwise the organization is blind to your work, and so is the next agent
+who picks up where you left off. Leave traces as you go, not at the end.
+
+For non-trivial work: create or claim a task, mark it \`in_progress\`, comment
+when status materially changes, close it when done, and link the origin that
+triggered it. Decompose multi-step work into subtasks and keep their statuses
+current \u2014 progress should be auditable without watching the work happen.
+Details: load the \`parall-tasks\` skill.
+
+### Done means landed
+Producing output does not complete a task. Work counts as done only when it has
+cleared its remaining gates \u2014 review, merge, deployment, the requester's
+verification. Until then keep the status honest (\`in_progress\` or
+\`in_review\`), name the remaining gate in a comment, and chase it (schedule a
+self-reminder if nothing else will prompt follow-up). Never mark done what a
+human still has to accept.
+
+### Sessions, forks, and what survives
+Sessions end and context compacts. Anything that must survive \u2014 decisions,
+progress, constraints \u2014 belongs in tasks, comments, or wiki. Future sessions
+read the workspace, not this conversation.
+
+Some events are handled by parallel fork sessions \u2014 short-lived copies of the
+same agent identity with separate context. In a fork: leave a written trace of
+what was done or deliberately not done (other sessions cannot see fork
+context), and do not start long-running processes \u2014 they die with the fork.
+When an event is marked fork-handled: do not re-handle it; verify its outcome
+instead of assuming it.
+
+### Communicate like a teammate
+Match the conversation \u2014 concise in chat, thorough in docs, plain language over
+jargon. Say what matters; stop when you're done. Don't narrate every tool call
+or pad replies to seem thorough.
+
+Match the language of the person you're replying to. If someone writes in
+Chinese, reply in Chinese. If in English, reply in English. Never force a
+language switch unless explicitly asked.
+
+Do not promise delivery times ("in an hour", "by tonight") unless the work is
+driven by an explicit schedule. Scope visibly; report when actually done.
+
+### Keep topics in threads
+Check for a \`[Thread: prll://msg_xxx]\` line before interpreting a message.
+Present \u2192 that thread is the context; reply there, passing the same root as
+\`--thread-root-id\`. Absent \u2192 the message belongs to the main conversation:
+never treat it as continuing your most recent thread. The sender's newest
+message is the anchor \u2014 never route a reply back into an older thread just
+because the topic used to live there.
+
+Reply where the event lives: a thread message gets a thread reply, a
+top-level message gets a top-level reply. But in group chats, your later
+follow-up on that topic \u2014 progress updates, analysis, links, verification you
+post afterwards \u2014 belongs in a thread rooted at the topic's message
+(\`parall messages send <chat> --thread-root-id <msgId> --text-file -\`), so
+the main channel stays scannable. Post follow-up at top level only when
+starting a genuinely new topic, making a channel-wide announcement, or when
+explicitly asked. Never post the same update in both the thread and the main
+channel \u2014 thread replies surface in the thread panel; no need to duplicate
+for visibility.
+
+In DMs, reply top-level by default; use a thread only to continue one that
+already exists.
+
+### Group chats: mentions and unaddressed work
+An @mention is a direct request \u2014 act on it. A group message delivered to you
+without an @mention means the chat's routing lets you see the conversation:
+decide whether a reply adds value; silence is the default.
+
+A message without an @mention is not an open invitation. Judge from context
+who the work belongs to \u2014 the named domain, the topic's owner, whoever is
+already on it. If it belongs to someone else, leave it. If genuinely unclear,
+ask or claim in one line ("taking this unless someone else has it") before
+starting \u2014 asking first beats duplicated or misdirected work.
+
+### Verify before you act
+Events can be redelivered \u2014 before acting, check whether it was already
+handled (your own recent replies, task comments); if handled, do nothing.
+Sends can fail silently, and creates can error after succeeding server-side \u2014
+check the chat or entity before retrying. Never blind-retry a mutating call.
+
+### Gather the full picture first
+When a request is vague, an entity may already exist, or work may already be
+underway \u2014 gather context before acting: search (\`parall search "..."\`),
+check existing tasks/chats/wiki, read the surrounding conversation. Act on the
+full picture, not the fragment that arrived in the event.
+
+### Report only work that ran
+If a scheduled job, scan, or tool call did not actually run \u2014 restarted
+session, missing credentials, silent failure \u2014 say so plainly. Never fabricate
+or approximate results of work that did not execute.
+
+### Respect what's shared
+You have broad latitude inside your own work. But actions that are visible to
+others, hard to reverse, or touch shared state \u2014 sending DMs, editing shared
+wiki, reassigning others' tasks, deleting content \u2014 pause and confirm before
+acting, unless you've been explicitly authorized.
+
+### Shared workspace
+Other agents share this workspace. Before starting work, check whether someone
+\u2014 human or agent \u2014 has already picked it up. Coordination beats racing.
+
+### Permissions and approvals
+You have real permissions based on your roles (chat member/admin, org member).
+If you lack permission for an action, the API returns PERMISSION_DENIED with the
+\`action\` and \`resource_uri\` that were denied. The server decides whether that
+action is approvable: if it is, the CLI prints an \`approvals request\` command \u2014
+fill in the placeholders it shows (\`--chat\`, \`--title\`, \`--reason\`) and run
+it to ask someone with permission. If it is NOT approvable, the output says so;
+ask a human with permission instead of requesting approval. A
+\`INVALID_TARGET\` error instead means you addressed the wrong kind of thing
+(e.g. a \`usr_\` id where a chat is expected) \u2014 follow the message (e.g. use
+\`dm\` for a user). Don't retry or work around a denial; only request approval
+after an actual denial, never preemptively.
+
+### When in doubt
+Prefer asking over guessing. Prefer "I don't know" over fabricating. Your
+credibility is what you bring to the workspace \u2014 protect it.`;
+var PRLL_REFERENCE_GUIDE = `## Parall References
+
+Every entity on Parall has a \`prll://\` URI. Use these URIs to link related
+entities when you create or update tasks, comments, messages, and wiki files.
+
+All three forms work \u2014 pick whichever fits:
+
+    prll://tsk_abc                               bare URI (auto-linked)
+    [](prll://tsk_abc)                           empty context (renders resolved title)
+    [relevant context](prll://tsk_abc)           with author annotation
+
+Bare URIs and empty-context refs are preferred in most cases \u2014 the platform
+resolves and renders the entity title automatically.
+
+### URI format
+
+\`prll://\` follows standard URI structure: \`scheme://authority/path?query#fragment\`.
+
+**Entities** \u2014 the entity ID is the authority:
+
+    prll://usr_xxx          user          prll://prj_xxx          project
+    prll://tsk_xxx          task          prll://wik_xxx          wiki
+    prll://msg_xxx          message       prll://cmt_xxx          comment
+    prll://cht_xxx          chat          prll://tcm_xxx          task comment (legacy)
+    prll://att_xxx          attachment    prll://ase_xxx          agent session
+    prll://sch_xxx          schedule      prll://srn_xxx          schedule run
+
+**Wiki** \u2014 path is file path, fragment is a typed anchor:
+
+    prll://wik_xxx/docs/guide.md                  file
+    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)
+    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)
+
+  Anchor types: \`h=\` heading, \`l=\` line/range, \`s=\` symbol.
+  Line anchors in persistent content require \`?rev=<full-40-char-sha>\`.
+
+**Chat message range**:
+
+    prll://cht_xxx#range=msg_01HA,msg_01HZ
+
+**Field access** \u2014 path selects a field (omit to reference the entity itself):
+
+    prll://tsk_xxx/description#Implementation     heading within task description
+
+### Unread context
+
+When dispatched to a chat, you may see \`[Unread: N messages | since: prll://msg_xxx]\`.
+This shows messages since your last interaction \u2014 your read cursor advances after each
+dispatch, so context you skip now won't appear as unread next time. Use
+\`parall messages list <chat> --limit 20\` to fetch recent context. For large unread
+counts (50+), fetch only recent messages rather than everything.
+
+Thread dispatches may show \`[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]\`.
+Same semantics \u2014 use \`parall messages list <chat> --thread-root-id <thread_root> --limit 20\` to
+catch up on the thread.
+
+### Reading context on demand
+
+An event only carries the single triggering message. If you're mentioned in a
+group chat and lack context, pull what you need from the chat \u2014 don't guess:
+
+    parall messages list cht_xxx --limit 20 --before msg_xxx
+    parall messages get msg_xxx
+    parall chats get cht_xxx
+
+Rule of thumb: in a group chat mention, the conversation that led up to you
+being called almost always matters \u2014 read it before replying. In a DM, your
+session already has continuity, so skip the fetch unless something is unclear.
+
+Same pattern for any other entity referenced in the event: \`tasks get\`,
+\`projects get\`, \`users get\`, \`chats get\`. Follow the reflink, don't ask.
+When one entity isn't enough \u2014 you need what's *around* it \u2014 walk the
+reference graph instead of guessing (see "Walk the reference graph" below).
+
+### Find context with search first
+
+Reach for unified semantic search before paging chat history:
+
+    parall search "pricing decision june" --limit 10
+
+It spans messages, tasks, wiki, and comments. Page \`messages list\` only for the
+verbatim recent flow of one chat, not for discovery.
+
+### Walk the reference graph
+
+References form a traversable graph, and you can query it \u2014 don't stop at
+fetching entities one by one:
+
+    # entity metadata (title, status, preview)
+    parall refs resolve prll://tsk_xxx prll://wik_xxx
+    # who references this entity
+    parall refs backlinks prll://tsk_xxx
+    # connected sub-graph around it
+    parall refs graph prll://tsk_xxx --depth 2
+
+Use \`refs backlinks\` when you need "where is this discussed / used"; use
+\`refs graph\` when you need the full picture around an entity (related tasks,
+docs, conversations \u2014 edges carry the author's annotation for why they linked).
+Then \`refs resolve\` the interesting node URIs in one batch to get titles and
+status. \`refs graph\` takes entity-level URIs only (\`prll://wik_xxx\`, not
+\`prll://wik_xxx/docs/a.md\`). All results are filtered to what you can see.
+Details: parall-platform skill.
+
+### File attachments
+
+Messages may include attachments. They appear in events as:
+
+    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]
+
+To download an attachment, use the CLI:
+
+    parall files download att_xxx --output /tmp/screenshot.png
+
+To send a file:
+
+    parall messages send prll://cht_xxx --file /tmp/output.png --text "Done"
+
+Or upload first and reuse across chats:
+
+    parall files upload /tmp/report.pdf
+    parall messages send prll://cht_aaa --attachment att_yyy --text "Report"
+    parall messages send prll://cht_bbb --attachment att_yyy --text "FYI"
+
+The \`--text\` captions above are safe short literals. For message text containing \`$\`, backticks, or quotes, pass it via \`--text-file <path>\` (write the file first, or a quoted heredoc \`--text-file - <<'EOF'\`) instead of \`--text "..."\` \u2014 inside double quotes the shell turns \`$1,000\` into \`,000\` and executes \`$(...)\`.
+
+### When to reference
+
+- **Origin** \u2014 always link the message or task that triggered your work
+- **Design docs / wiki** \u2014 link specs and guides relevant to the work
+- **Related tasks** \u2014 link parent, sibling, or blocking tasks
+- **People** \u2014 link assignees or stakeholders when mentioning them
+- **Conversations** \u2014 link a chat or message range as context
+
+### Why this matters
+
+Other agents and humans read your output. References build a navigable context graph \u2014
+in multi-agent workflows, your references are the map that the next agent follows.`;
+function renderLocalAttachmentSection(section) {
+  if (section.images.length === 0 && section.notes.length === 0)
+    return "";
+  const lines = ["[Local attachment files]"];
+  for (const image of section.images) {
+    lines.push(`- prll://${image.attachmentId} (${sanitizePromptMeta(image.mimeType)}, ${formatBytes(image.fileSize)}, ${sanitizePromptMeta(image.fileName)})`, `  ${image.localPath}`);
   }
-  const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
-  await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
-  return "dispatched";
+  lines.push(...section.notes);
+  return lines.join("\n");
 }
-async function consumeTypedDispatch(host, ref, run, ack) {
-  if (!host.laneLedger || host.ledgerDisabled) {
-    if (await run(ref.dispatchEventId))
-      await ack(ref.dispatchEventId);
-    return;
-  }
-  let lane;
-  try {
-    lane = await host.laneLedger.claimTyped(ref);
-  } catch (err) {
-    if (err instanceof LedgerUnsupportedError) {
-      host.disableLedger("claim endpoint missing");
-      if (await run(ref.dispatchEventId))
-        await ack(ref.dispatchEventId);
-      return;
-    }
-    throw err;
-  }
-  if (!lane) {
-    host.opts.log?.info(`typed dispatch ${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`} not claimable (held elsewhere or already resolved) \u2014 skipping`);
-    return;
-  }
-  try {
-    if (await run(lane.typedDispatchEventId))
-      await ack(lane.typedDispatchEventId);
-  } finally {
-    await host.laneLedger.completeIfIdle(lane.laneKey, false).catch(() => {
-    });
-  }
+function sanitizePromptMeta(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/[()]/g, " ").trim();
 }
-async function consumeMessageWorkItem(host, item) {
-  if (host.shuttingDown)
-    return;
-  if (!host.tryClaimMessage(item.source_id))
-    return;
-  const ackItem = () => {
-    host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => {
-    });
-  };
-  let msg = null;
-  try {
-    msg = await host.opts.client.getMessage(item.source_id);
-  } catch (err) {
-    const status = err?.status;
-    if (status !== 404) {
-      host.opts.log?.warn(`message fetch failed for ${item.source_id}, leaving pending: ${String(err)}`);
-      host.dispatchedMessages.delete(item.source_id);
-      return;
-    }
-  }
-  if (!msg || msg.sender_id === host.opts.agentUserId) {
-    host.dispatchedMessages.delete(item.source_id);
-    ackItem();
-    return;
-  }
-  const decision = await host.buildMessageDispatchDecision(item.chat_id, msg);
-  if (decision.action === "retry") {
-    host.dispatchedMessages.delete(item.source_id);
-    return;
-  }
-  if (decision.action === "skip") {
-    host.dispatchedMessages.delete(item.source_id);
-    ackItem();
-    return;
-  }
-  decision.event.dispatchEventId = item.id;
-  const laneResolved = host.usesLaneLedger(decision.event);
-  try {
-    const dispatched = await host.handleInboundEvent(decision.event);
-    if (dispatched) {
-      if (!laneResolved)
-        ackItem();
-    } else {
-      host.dispatchedMessages.delete(item.source_id);
-    }
-  } catch (err) {
-    host.dispatchedMessages.delete(item.source_id);
-    throw err;
+function formatBytes(bytes) {
+  if (bytes >= 1048576)
+    return `${(bytes / 1048576).toFixed(1)}MB`;
+  if (bytes >= 1024)
+    return `${Math.round(bytes / 1024)}KB`;
+  return `${bytes}B`;
+}
+
+// ../agent-core/dist/bridge-workspace.js
+function extractShellCommand(input) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const command = input.command;
+  return typeof command === "string" && command.trim() ? command.trim() : void 0;
+}
+function parseParallCliInvocation(command) {
+  const tokens = command.replace(/\s+/g, " ").trim().split(" ");
+  let i = 0;
+  if (tokens[i] === "parall") {
+    i++;
+  } else if (tokens[i] === "npx") {
+    i++;
+    while (i < tokens.length && tokens[i].startsWith("-"))
+      i++;
+    if (i >= tokens.length || !/^@parall\/cli(?:@.+)?$/.test(tokens[i]))
+      return null;
+    i++;
+  } else if (tokens[i] === "pnpm") {
+    i++;
+    if (i < tokens.length && (tokens[i] === "exec" || tokens[i] === "dlx"))
+      i++;
+    if (i >= tokens.length || tokens[i] !== "parall")
+      return null;
+    i++;
+  } else {
+    return null;
   }
+  return tokens.slice(i).filter((t) => !t.startsWith("-"));
+}
+function isParallSendCommand(command) {
+  if (!command)
+    return false;
+  const sub = parseParallCliInvocation(command);
+  if (!sub || sub.length === 0)
+    return false;
+  return sub[0] === "dm" || sub[0] === "messages" && sub[1] === "send";
+}
+function isParallNoReplyCommand(command) {
+  if (!command)
+    return false;
+  const sub = parseParallCliInvocation(command);
+  return sub?.[0] === "no-reply";
 }
 
+// ../agent-core/dist/dispatch-adapter.js
+function buildErrorStepContent(message) {
+  return { text: message, suppressed: false, status: "error" };
+}
+
+// ../agent-core/dist/gateway-base.js
+import * as os from "node:os";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
 // ../agent-core/dist/telemetry.js
 init_esm();
 var import_api_logs = __toESM(require_src(), 1);
@@ -30413,6 +30543,9 @@ var ParallAgentGateway = class {
   // (stable mapping; avoids one connection fetch per inbound message).
   channelConnectionProviders = /* @__PURE__ */ new Map();
   dispatchedMessages = /* @__PURE__ */ new Set();
+  // Per-WorkItem failure backoff for typed dispatch consumption — see
+  // LaneFlowHost.typedRedriveBackoff in gateway-lane-flow.ts.
+  typedRedriveBackoff = /* @__PURE__ */ new Map();
   forkStates = /* @__PURE__ */ new Map();
   dispatchState = {
     mainDispatching: false,
@@ -30537,7 +30670,11 @@ var ParallAgentGateway = class {
           return this.opts.client.ackDispatch(this.opts.config.org_id, {
             source_type: "task_activity",
             source_id: data.id
-          }).then(() => void 0, () => void 0);
+          }).then(() => true, (err) => {
+            this.dispatchedTasks.delete(`${data.id}:${data.updated_at}`);
+            this.opts.log?.warn(`dispatch ack failed for task ${data.id}, releasing for re-drive: ${String(err)}`);
+            return false;
+          });
         });
       } catch (err) {
         this.opts.log?.error(`task dispatch failed for ${data.id}: ${String(err)}`);
@@ -30644,6 +30781,44 @@ var ParallAgentGateway = class {
     this.dispatchedMessages.add(id);
     return true;
   }
+  /**
+   * Lane currently being dispatched per session — lets external activity
+   * signals renew exactly the caller's lane (renewing all lanes would keep
+   * an unrelated stalled fork's lane leased forever).
+   */
+  sessionActiveLanes = /* @__PURE__ */ new Map();
+  noteSessionLane(sessionKey, laneKey) {
+    if (laneKey == null)
+      this.sessionActiveLanes.delete(sessionKey);
+    else
+      this.sessionActiveLanes.set(sessionKey, laneKey);
+  }
+  /**
+   * External runtime-activity signal for adapters whose tool activity does
+   * not flow through the RuntimeEvent stream (openclaw hooks call this from
+   * the tool-call lifecycle): renews the session's OWN active ledger lane so
+   * a long tool call cannot outlive the lease and get dethroned mid-turn.
+   * No-op without an active ledger lane for the session.
+   */
+  touchRuntimeActivity(sessionKey) {
+    if (this.ledgerDisabled)
+      return;
+    const laneKey = this.sessionActiveLanes.get(sessionKey);
+    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.
+   * 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.
+   */
+  consumeTurnError(sessionKey) {
+    return this.turnErrorSessions.delete(sessionKey);
+  }
   async emitDispatchReceived(event) {
     const sourceType = event.ackSourceType ?? (event.type === "task" ? "task_activity" : "message");
     const sourceId = event.ackSourceId ?? event.messageId;
@@ -30687,11 +30862,15 @@ var ParallAgentGateway = class {
   }
   // Typed completion must wait until the administrative ack has either
   // committed or failed. Errors stay best-effort: a failed ack leaves the row
-  // received, so Complete releases and re-drives it safely.
+  // received, so Complete releases and re-drives it safely. The boolean
+  // outcome feeds the typed-consume backoff — an ack that failed must count
+  // as a failed consume, or an ack outage would clear the backoff entry and
+  // let the release re-drive spin at wire speed.
   ackDispatchEvent(dispatchEventId, onFailure) {
-    return this.opts.client.ackDispatchByID(this.opts.config.org_id, dispatchEventId).then(() => void 0, (err) => {
+    return this.opts.client.ackDispatchByID(this.opts.config.org_id, dispatchEventId).then(() => true, (err) => {
       onFailure?.();
       this.opts.log?.warn(`dispatch ack failed for ${dispatchEventId}, releasing for re-drive: ${String(err)}`);
+      return false;
     });
   }
   clearTypedDispatchDedupe(item) {
@@ -30989,6 +31168,7 @@ var ParallAgentGateway = class {
       this.pendingRestartNotification = null;
     }
     resetDispatchMetrics(sessionKey);
+    this.turnErrorSessions.delete(sessionKey);
     return runWithSessionKey(sessionKey, async () => {
       let dispatchSpan = null;
       setSessionChatId(sessionKey, event.targetId);
@@ -31096,6 +31276,9 @@ var ParallAgentGateway = class {
           } else if (runtimeEvent.type === "tool_result" && pendingSendCallIds.delete(runtimeEvent.callId)) {
             recordMessageSend(sessionKey, !runtimeEvent.error);
           }
+          if (runtimeEvent.type === "error") {
+            this.turnErrorSessions.add(sessionKey);
+          }
           await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
         }
         if (!binding) {
@@ -31243,13 +31426,23 @@ var ParallAgentGateway = class {
               body: buildForkScopePrefix(last) + buildEventBody(last),
               earlier,
               captureText: batchText,
-              hasMoreLocal: () => fork.queue.length > 0
+              // Per-LANE residue check (parity with the main-buffer path):
+              // the fork queue can hold several lanes (channel + thread of
+              // the same chat). A whole-queue check would defer THIS lane's
+              // complete behind another lane's items and never revisit it —
+              // its members would sit received until lease expiry.
+              hasMoreLocal: () => fork.queue.some((it) => this.dispatchGroupKey(it.event) === this.dispatchGroupKey(last))
             });
             if (outcome === "foreign") {
               for (const item of items)
                 item.resolve(false);
               break;
             }
+            if (outcome === "failed") {
+              for (const item of items)
+                item.resolve(false);
+              continue;
+            }
             dispatched = outcome === "dispatched";
           } else {
             dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
@@ -31283,6 +31476,7 @@ var ParallAgentGateway = class {
         remaining.resolve(false);
       }
     } finally {
+      this.turnErrorSessions.delete(fork.fork.sessionKey);
       if (fork.deadlineTimer) {
         clearTimeout(fork.deadlineTimer);
         fork.deadlineTimer = null;
@@ -31395,6 +31589,10 @@ var ParallAgentGateway = class {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
+          if (outcome === "failed") {
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            continue;
+          }
           continue;
         }
         try {
@@ -31498,7 +31696,7 @@ var ParallAgentGateway = class {
         }
         this.dispatchState.mainBuffer.push(event);
         if (this.usesLaneLedger(event)) {
-          if (this.mainCurrentGroupKey === this.dispatchGroupKey(event) && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
+          if (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)`);
           }
         } else if (this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
@@ -31525,12 +31723,14 @@ var ParallAgentGateway = class {
           this.dispatchState.mainBuffer.push(event);
           return false;
         }
-        try {
-          await this.emitDispatchReceived(event);
-        } catch (err) {
-          this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
-          this.dispatchState.mainBuffer.push(event);
-          return false;
+        if (!this.usesLaneLedger(event)) {
+          try {
+            await this.emitDispatchReceived(event);
+          } catch (err) {
+            this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
+            this.dispatchState.mainBuffer.push(event);
+            return false;
+          }
         }
         const fork = await this.opts.dispatchAdapter.forkSession({
           sessionKey: this.opts.runtimeKey,
@@ -32014,6 +32214,8 @@ var ParallAgentGateway = class {
         provider = void 0;
       }
     }
+    const keys = this.opts.getCapabilityKeys?.() ?? [];
+    const cliCapable = provider ? keys.includes(`${provider}-cli`) : keys.some((k) => k.endsWith("-cli"));
     const event = {
       type: "channel_message",
       targetId: conv.id,
@@ -32028,6 +32230,7 @@ var ParallAgentGateway = class {
       channelConversationType: conv.conversation_type || void 0,
       channelExternalConversationId: conv.external_conversation_id,
       channelExternalMessageId: msg.external_message_id,
+      channelCliCapable: cliCapable,
       ackSourceType: "channel_message",
       ackSourceId: msg.id
     };
@@ -32361,12 +32564,116 @@ ${fullSummary}` : fullSummary;
   }
 };
 
+// ../agent-core/dist/platform-config.js
+function extractCapabilities(config) {
+  const agents = config.agents ?? {};
+  const raw = agents.capabilities;
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    const e = entry;
+    if (typeof e.key !== "string" || !e.key)
+      continue;
+    if (typeof e.fragment !== "string" || !e.fragment)
+      continue;
+    out.push({
+      key: e.key,
+      source: typeof e.source === "string" ? e.source : "",
+      fragment: e.fragment
+    });
+  }
+  return out;
+}
+
+// ../agent-core/dist/channel-capability.js
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var CAPABILITY_FEISHU_CLI = "feishu-cli";
+var CHANNEL_POINTER_MAGIC = "parall channel capability pointer";
+function capabilityBinDir(stateDir) {
+  return path3.join(stateDir, "bin");
+}
+function channelExecEntryPath() {
+  const selfDir = path3.dirname(fileURLToPath(import.meta.url));
+  const sibling = path3.join(selfDir, "parall-channel-exec.js");
+  if (fs3.existsSync(sibling))
+    return sibling;
+  return fileURLToPath(new URL("./bin/channel-exec.js", import.meta.url));
+}
+function materializeChannelCapabilities(stateDir, capabilities, log) {
+  try {
+    reconcileFeishuCli(stateDir, capabilities, log);
+  } catch (err) {
+    log?.warn(`channel capability materialization failed: ${String(err)}`);
+  }
+}
+function reconcileFeishuCli(stateDir, capabilities, log) {
+  const binDir = capabilityBinDir(stateDir);
+  const posixPath = path3.join(binDir, "lark-cli");
+  const granted = capabilities.some((c) => c.key === CAPABILITY_FEISHU_CLI);
+  const hadPointer = fs3.existsSync(posixPath);
+  if (!granted && !hadPointer)
+    return;
+  fs3.mkdirSync(binDir, { recursive: true });
+  const entry = channelExecEntryPath();
+  const nodeExec = process.execPath;
+  writePointerIfChanged(posixPath, renderPosixPointer(nodeExec, entry, binDir, "feishu"), log);
+  writePointerIfChanged(path3.join(binDir, "lark-cli.cmd"), renderCmdPointer(nodeExec, entry, binDir, "feishu"), log);
+}
+function writePointerIfChanged(filePath, content, log) {
+  let existing = null;
+  try {
+    existing = fs3.readFileSync(filePath, "utf8");
+  } catch {
+    existing = null;
+  }
+  if (existing !== content) {
+    fs3.writeFileSync(filePath, content, { mode: 493 });
+    log?.info(`channel capability: pointer materialized (${path3.basename(filePath)})`);
+  }
+  fs3.chmodSync(filePath, 493);
+}
+function renderPosixPointer(nodeExecPath, entryJsPath, binDir, channel) {
+  return [
+    "#!/bin/sh",
+    `# Generated by @parall/agent-core \u2014 ${CHANNEL_POINTER_MAGIC} (do not edit).`,
+    "# Credential + exec logic lives in the agent-core package; revocation is",
+    "# enforced by the platform mint endpoint, so this pointer stays constant.",
+    // Strip Node preload-hijack vars BEFORE launching node: NODE_OPTIONS
+    // (e.g. --require=/evil.js) and NODE_PATH would execute caller-supplied code
+    // at interpreter startup — BEFORE channel-exec's own env scrub, i.e. before
+    // the mint. The pointer is a platform-authored trust-boundary artifact whose
+    // whole job is a CONTROLLED launch of the broker (absolute node, magic
+    // guard, skip-dir); this closes the same env-hijack class for node startup
+    // that the absolute node path closes for PATH, keeping the launch deterministic.
+    "unset NODE_OPTIONS NODE_PATH",
+    // "$@" preserves argv exactly (this is the agent's main path via git-bash).
+    `exec "${nodeExecPath}" "${entryJsPath}" --channel ${channel} --skip-dir "${binDir}" -- "$@"`,
+    ""
+  ].join("\n");
+}
+function renderCmdPointer(nodeExecPath, entryJsPath, binDir, channel) {
+  return [
+    "@echo off",
+    `rem Generated by @parall/agent-core - ${CHANNEL_POINTER_MAGIC} (do not edit).`,
+    // Clear Node preload-hijack vars before launching node (see the sh pointer).
+    'set "NODE_OPTIONS="',
+    'set "NODE_PATH="',
+    `"${nodeExecPath}" "${entryJsPath}" --channel ${channel} --skip-dir "${binDir}" -- %*`,
+    ""
+  ].join("\r\n");
+}
+
 // ../agent-core/dist/internal/attachment-input.js
 import { execSync } from "node:child_process";
 import { constants } from "node:fs";
 import * as fsSync from "node:fs";
-import * as fs3 from "node:fs/promises";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path4 from "node:path";
 var DEFAULT_MAX_TOTAL_IMAGE_BYTES = 20 * 1024 * 1024;
 var DEFAULT_ATTACHMENT_CACHE_MAX_BYTES = 512 * 1024 * 1024;
 var DEFAULT_ATTACHMENT_DOWNLOAD_TIMEOUT_MS = 3e4;
@@ -32396,11 +32703,11 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     };
   }
   const rootDir = await ensureAttachmentRootDir(opts.workspaceDir);
-  const messageDir = path3.join(rootDir, sanitizePathSegment(event.messageId));
+  const messageDir = path4.join(rootDir, sanitizePathSegment(event.messageId));
   await ensurePathIsNotSymlink(messageDir);
-  await fs3.mkdir(messageDir, { recursive: true });
+  await fs4.mkdir(messageDir, { recursive: true });
   await ensurePathIsNotSymlink(messageDir);
-  const activeMessageDir = path3.resolve(messageDir);
+  const activeMessageDir = path4.resolve(messageDir);
   activeAttachmentDirs.add(activeMessageDir);
   const maintenanceCooldownMs = opts.maintenanceCooldownMs ?? DEFAULT_MAINTENANCE_COOLDOWN_MS;
   const maintenancePromise = scheduleAttachmentMaintenance(rootDir, {
@@ -32417,7 +32724,7 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     const notes = [];
     let downloadedBytes = 0;
     for (const att of imageAttachments) {
-      const localPath = path3.join(messageDir, localFileName(att.id, att.fileName, att.mimeType));
+      const localPath = path4.join(messageDir, localFileName(att.id, att.fileName, att.mimeType));
       const downloadTimeoutMs = opts.downloadTimeoutMs ?? DEFAULT_ATTACHMENT_DOWNLOAD_TIMEOUT_MS;
       const fetchFresh = async () => {
         const fileInfo = await withTimeout(context2.client.getFileUrl(att.id), downloadTimeoutMs, `file URL lookup timed out after ${downloadTimeoutMs}ms`);
@@ -32474,7 +32781,7 @@ async function appendPreparedLocalAttachmentRefs(body, event, context2, opts) {
   return { body: appendLocalAttachmentRefs(body, attachments), attachments };
 }
 function pinLocalAttachmentPaths(images) {
-  const dirs = new Set(images.map((image) => path3.resolve(path3.dirname(image.localPath))));
+  const dirs = new Set(images.map((image) => path4.resolve(path4.dirname(image.localPath))));
   for (const dir of dirs) {
     activeAttachmentDirs.add(dir);
   }
@@ -32489,7 +32796,7 @@ function pinLocalAttachmentPaths(images) {
   };
 }
 function attachmentRootDir(workspaceDir) {
-  return path3.join(path3.resolve(workspaceDir), ".parall", "attachments");
+  return path4.join(path4.resolve(workspaceDir), ".parall", "attachments");
 }
 function ensureLocalAttachmentGitExclude(workingDirectory) {
   try {
@@ -32498,8 +32805,8 @@ function ensureLocalAttachmentGitExclude(workingDirectory) {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const excludePath = path3.isAbsolute(rel) ? rel : path3.join(workingDirectory, rel);
-    fsSync.mkdirSync(path3.dirname(excludePath), { recursive: true });
+    const excludePath = path4.isAbsolute(rel) ? rel : path4.join(workingDirectory, rel);
+    fsSync.mkdirSync(path4.dirname(excludePath), { recursive: true });
     const existing = fsSync.existsSync(excludePath) ? fsSync.readFileSync(excludePath, "utf8") : "";
     if (existing.split(/\r?\n/).some((line) => line.trim() === ".parall/"))
       return;
@@ -32535,18 +32842,18 @@ function scheduleAttachmentMaintenance(rootDir, opts) {
   return run;
 }
 async function ensureAttachmentRootDir(workspaceDir) {
-  const workspaceRoot = path3.resolve(workspaceDir);
-  const parallDir = path3.join(workspaceRoot, ".parall");
+  const workspaceRoot = path4.resolve(workspaceDir);
+  const parallDir = path4.join(workspaceRoot, ".parall");
   const rootDir = attachmentRootDir(workspaceRoot);
-  await fs3.mkdir(workspaceRoot, { recursive: true });
+  await fs4.mkdir(workspaceRoot, { recursive: true });
   await ensurePathIsNotSymlink(parallDir);
-  await fs3.mkdir(parallDir, { recursive: true, mode: 448 });
+  await fs4.mkdir(parallDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(parallDir);
   await ensurePathIsNotSymlink(rootDir);
-  await fs3.mkdir(rootDir, { recursive: true, mode: 448 });
+  await fs4.mkdir(rootDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(rootDir);
-  const realWorkspace = await fs3.realpath(workspaceRoot);
-  const realRoot = await fs3.realpath(rootDir);
+  const realWorkspace = await fs4.realpath(workspaceRoot);
+  const realRoot = await fs4.realpath(rootDir);
   if (!isPathInside(realRoot, realWorkspace)) {
     throw new Error(`attachment root escapes workspace: ${rootDir}`);
   }
@@ -32554,7 +32861,7 @@ async function ensureAttachmentRootDir(workspaceDir) {
 }
 async function ensurePathIsNotSymlink(filePath) {
   try {
-    const stat = await fs3.lstat(filePath);
+    const stat = await fs4.lstat(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`refusing to use symlinked attachment path ${filePath}`);
     }
@@ -32565,8 +32872,8 @@ async function ensurePathIsNotSymlink(filePath) {
   }
 }
 function isPathInside(childPath, parentPath) {
-  const rel = path3.relative(parentPath, childPath);
-  return rel === "" || !!rel && !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(parentPath, childPath);
+  return rel === "" || !!rel && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 async function existingUsableFile(filePath, expectedSize, rootDir) {
   try {
@@ -32577,30 +32884,30 @@ async function existingUsableFile(filePath, expectedSize, rootDir) {
   }
 }
 async function localFileStatInsideRoot(filePath, rootDir) {
-  const stat = await fs3.lstat(filePath);
+  const stat = await fs4.lstat(filePath);
   if (stat.isSymbolicLink()) {
     throw new Error(`refusing to use symlinked attachment file ${filePath}`);
   }
   if (!stat.isFile()) {
     throw new Error(`attachment path is not a file ${filePath}`);
   }
-  const realRoot = await fs3.realpath(rootDir);
-  const realFile = await fs3.realpath(filePath);
+  const realRoot = await fs4.realpath(rootDir);
+  const realFile = await fs4.realpath(filePath);
   if (!isPathInside(realFile, realRoot)) {
     throw new Error(`attachment file escapes workspace: ${filePath}`);
   }
   return stat;
 }
 async function localDirectoryStatInsideRoot(dirPath, rootDir) {
-  const stat = await fs3.lstat(dirPath);
+  const stat = await fs4.lstat(dirPath);
   if (stat.isSymbolicLink()) {
     throw new Error(`refusing to use symlinked attachment directory ${dirPath}`);
   }
   if (!stat.isDirectory()) {
     throw new Error(`attachment path is not a directory ${dirPath}`);
   }
-  const realRoot = await fs3.realpath(rootDir);
-  const realDir = await fs3.realpath(dirPath);
+  const realRoot = await fs4.realpath(rootDir);
+  const realDir = await fs4.realpath(dirPath);
   if (!isPathInside(realDir, realRoot)) {
     throw new Error(`attachment directory escapes workspace: ${dirPath}`);
   }
@@ -32608,7 +32915,7 @@ async function localDirectoryStatInsideRoot(dirPath, rootDir) {
 }
 async function openLocalFileInsideRoot(filePath, rootDir) {
   const checkedStat = await localFileStatInsideRoot(filePath, rootDir);
-  const file = await fs3.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const file = await fs4.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
   let keepOpen = false;
   try {
     const openedStat = await file.stat();
@@ -32624,8 +32931,8 @@ async function openLocalFileInsideRoot(filePath, rootDir) {
   }
 }
 async function openLocalTempFileInsideRoot(filePath, rootDir) {
-  await localDirectoryStatInsideRoot(path3.dirname(filePath), rootDir);
-  const file = await fs3.open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  await localDirectoryStatInsideRoot(path4.dirname(filePath), rootDir);
+  const file = await fs4.open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
   let keepOpen = false;
   try {
     const checkedStat = await localFileStatInsideRoot(filePath, rootDir);
@@ -32650,7 +32957,7 @@ async function assertLocalFileIdentity(filePath, rootDir, expected) {
 async function removeLocalFileIfInside(filePath, rootDir) {
   try {
     await localFileStatInsideRoot(filePath, rootDir);
-    await fs3.rm(filePath, { force: true });
+    await fs4.rm(filePath, { force: true });
   } catch {
   }
 }
@@ -32663,7 +32970,7 @@ function sameFile(a, b) {
 async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
   let entries;
   try {
-    entries = await fs3.readdir(rootDir, { withFileTypes: true });
+    entries = await fs4.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -32671,15 +32978,15 @@ async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
   await Promise.all(entries.map(async (entry) => {
     if (!entry.isDirectory())
       return;
-    const fullPath = path3.join(rootDir, entry.name);
+    const fullPath = path4.join(rootDir, entry.name);
     try {
-      if (preserveDirs?.has(path3.resolve(fullPath)))
+      if (preserveDirs?.has(path4.resolve(fullPath)))
         return;
-      const stat = await fs3.lstat(fullPath);
+      const stat = await fs4.lstat(fullPath);
       if (!stat.isDirectory())
         return;
       if (stat.mtimeMs < cutoff) {
-        await fs3.rm(fullPath, { recursive: true, force: true });
+        await fs4.rm(fullPath, { recursive: true, force: true });
       }
     } catch (err) {
       log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
@@ -32691,7 +32998,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
     return;
   let entries;
   try {
-    entries = await fs3.readdir(rootDir, { withFileTypes: true });
+    entries = await fs4.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -32700,9 +33007,9 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const fullPath = path3.join(rootDir, entry.name);
+    const fullPath = path4.join(rootDir, entry.name);
     try {
-      const stat = await fs3.lstat(fullPath);
+      const stat = await fs4.lstat(fullPath);
       if (!stat.isDirectory())
         continue;
       const size = await directorySize(fullPath);
@@ -32718,10 +33025,10 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
   for (const dir of dirs) {
     if (total <= maxBytes)
       break;
-    if (preserveDirs?.has(path3.resolve(dir.path)))
+    if (preserveDirs?.has(path4.resolve(dir.path)))
       continue;
     try {
-      await fs3.rm(dir.path, { recursive: true, force: true });
+      await fs4.rm(dir.path, { recursive: true, force: true });
       total -= dir.size;
     } catch (err) {
       log?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
@@ -32730,12 +33037,12 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
 }
 async function directorySize(dirPath) {
   let total = 0;
-  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path3.join(dirPath, entry.name);
+    const fullPath = path4.join(dirPath, entry.name);
     let stat;
     try {
-      stat = await fs3.lstat(fullPath);
+      stat = await fs4.lstat(fullPath);
     } catch {
       continue;
     }
@@ -32750,10 +33057,10 @@ async function directorySize(dirPath) {
   return total;
 }
 function activeDirsForRoot(rootDir) {
-  const root = path3.resolve(rootDir);
+  const root = path4.resolve(rootDir);
   const dirs = /* @__PURE__ */ new Set();
   for (const dir of activeAttachmentDirs) {
-    if (dir === root || dir.startsWith(`${root}${path3.sep}`)) {
+    if (dir === root || dir.startsWith(`${root}${path4.sep}`)) {
       dirs.add(dir);
     }
   }
@@ -32850,9 +33157,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
     }
     writtenStat = await file.stat();
     await closeFile();
-    await localDirectoryStatInsideRoot(path3.dirname(filePath), rootDir);
+    await localDirectoryStatInsideRoot(path4.dirname(filePath), rootDir);
     await assertLocalFileIdentity(tmpPath, rootDir, writtenStat);
-    await fs3.rename(tmpPath, filePath);
+    await fs4.rename(tmpPath, filePath);
     completed = true;
     return written;
   } finally {
@@ -32868,9 +33175,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
   }
 }
 function localFileName(attachmentId, fileName, mimeType) {
-  const safeName = sanitizePathSegment(path3.basename(fileName || attachmentId));
-  const ext = path3.extname(safeName) || extensionForMime(mimeType);
-  const stem = path3.basename(safeName, path3.extname(safeName)) || attachmentId;
+  const safeName = sanitizePathSegment(path4.basename(fileName || attachmentId));
+  const ext = path4.extname(safeName) || extensionForMime(mimeType);
+  const stem = path4.basename(safeName, path4.extname(safeName)) || attachmentId;
   return `${sanitizePathSegment(attachmentId)}-${stem}${ext}`;
 }
 function extensionForMime(mimeType) {
@@ -32936,7 +33243,7 @@ function parseContentLength(value) {
 // dist/gateway.js
 import * as crypto2 from "node:crypto";
 import * as os2 from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // dist/runtime.js
 var runtime = null;
@@ -32994,15 +33301,27 @@ function buildOrchestratorSessionKey(accountId) {
 }
 
 // dist/config-manager.js
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+var currentCapabilities = [];
+function getChannelCapabilityFragments() {
+  return currentCapabilities.map((c) => c.fragment);
+}
+function getChannelCapabilityKeys() {
+  return currentCapabilities.map((c) => c.key);
+}
+function applyChannelCapabilitySnapshot(stateDir, config, log) {
+  const caps = extractCapabilities(config);
+  materializeChannelCapabilities(stateDir, caps, log);
+  currentCapabilities = caps;
+}
 var CACHE_FILENAME = "parall-platform-config.json";
 function cachePath(stateDir) {
-  return path4.join(stateDir, CACHE_FILENAME);
+  return path5.join(stateDir, CACHE_FILENAME);
 }
 function loadCachedConfig(stateDir) {
   try {
-    const raw = fs4.readFileSync(cachePath(stateDir), "utf-8");
+    const raw = fs5.readFileSync(cachePath(stateDir), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -33016,14 +33335,14 @@ function saveCachedConfig(stateDir, config) {
   };
   const filePath = cachePath(stateDir);
   const tmpPath = `${filePath}.tmp`;
-  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs4.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
-  fs4.renameSync(tmpPath, filePath);
+  fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+  fs5.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
+  fs5.renameSync(tmpPath, filePath);
 }
 function applyToOpenClawConfig(configPath, platformConfig, credentials) {
   let existing = {};
   try {
-    const raw = fs4.readFileSync(configPath, "utf-8");
+    const raw = fs5.readFileSync(configPath, "utf-8");
     existing = JSON.parse(raw);
   } catch {
   }
@@ -33095,9 +33414,9 @@ function applyToOpenClawConfig(configPath, platformConfig, credentials) {
   agents.defaults = cleanedExisting;
   existing.agents = agents;
   const tmpPath = `${configPath}.tmp`;
-  fs4.mkdirSync(path4.dirname(configPath), { recursive: true });
-  fs4.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
-  fs4.renameSync(tmpPath, configPath);
+  fs5.mkdirSync(path5.dirname(configPath), { recursive: true });
+  fs5.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
+  fs5.renameSync(tmpPath, configPath);
 }
 async function fetchAndApplyPlatformConfig(opts) {
   const { client, stateDir, configPath, credentials, log } = opts;
@@ -33109,6 +33428,7 @@ async function fetchAndApplyPlatformConfig(opts) {
     if (cached) {
       log?.warn(`platform config fetch failed, using cached version ${cached.version}: ${String(err)}`);
       applyToOpenClawConfig(configPath, cached.config, credentials);
+      applyChannelCapabilitySnapshot(stateDir, cached.config, log);
       return;
     }
     log?.error(`platform config fetch failed and no cache available: ${String(err)}`);
@@ -33118,6 +33438,7 @@ async function fetchAndApplyPlatformConfig(opts) {
     log?.info("platform config unchanged (304)");
     if (cached) {
       applyToOpenClawConfig(configPath, cached.config, credentials);
+      applyChannelCapabilitySnapshot(stateDir, cached.config, log);
     }
     return;
   }
@@ -33126,17 +33447,19 @@ async function fetchAndApplyPlatformConfig(opts) {
     log?.error(`platform config schema_version ${fresh.schema_version} is newer than supported (${SUPPORTED_SCHEMA_VERSION}), keeping current config`);
     if (cached) {
       applyToOpenClawConfig(configPath, cached.config, credentials);
+      applyChannelCapabilitySnapshot(stateDir, cached.config, log);
     }
     return;
   }
   log?.info(`platform config updated to version ${fresh.version}`);
   saveCachedConfig(stateDir, fresh);
+  applyChannelCapabilitySnapshot(stateDir, fresh.config, log);
   applyToOpenClawConfig(configPath, fresh.config, credentials);
 }
 
 // dist/wiki-helper.js
 import { spawn, spawnSync } from "node:child_process";
-import path5 from "node:path";
+import path6 from "node:path";
 var DEFAULT_SYNC_TIMEOUT_MS = 9e4;
 var DEFAULT_WATCH_INTERVAL_SEC = 30;
 function isCommandMissing(error) {
@@ -33151,7 +33474,7 @@ function resolveParallCli() {
   return _cli;
 }
 function resolveMountRoot(stateDir) {
-  return process.env.PRLL_WIKI_MOUNT_ROOT?.trim() || path5.join(stateDir, "workspace");
+  return process.env.PRLL_WIKI_MOUNT_ROOT?.trim() || path6.join(stateDir, "workspace");
 }
 function resolveWatchIntervalSec() {
   const raw = process.env.PRLL_WIKI_REFRESH_INTERVAL_SEC?.trim();
@@ -33266,8 +33589,8 @@ async function startWikiHelper(params) {
 
 // dist/oc-session.js
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join4, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5, resolve as resolve2 } from "node:path";
 var CURRENT_SESSION_VERSION = 3;
 function generateId(existing) {
   for (let i = 0; i < 100; i++) {
@@ -33278,9 +33601,9 @@ function generateId(existing) {
   return randomUUID();
 }
 function loadEntries(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync3(filePath))
     return [];
-  const lines = readFileSync4(filePath, "utf-8").trim().split("\n");
+  const lines = readFileSync5(filePath, "utf-8").trim().split("\n");
   const entries = [];
   for (const line of lines) {
     if (!line.trim())
@@ -33359,8 +33682,8 @@ var SessionManager = class _SessionManager {
   constructor(cwd, sessionDir, sessionFile) {
     this.cwd = cwd;
     this.sessionDir = sessionDir;
-    if (sessionDir && !existsSync2(sessionDir)) {
-      mkdirSync4(sessionDir, { recursive: true });
+    if (sessionDir && !existsSync3(sessionDir)) {
+      mkdirSync5(sessionDir, { recursive: true });
     }
     if (sessionFile) {
       this.load(sessionFile);
@@ -33371,7 +33694,7 @@ var SessionManager = class _SessionManager {
   // -- Init / load -----------------------------------------------------------
   load(file) {
     this.sessionFile = resolve2(file);
-    if (!existsSync2(this.sessionFile)) {
+    if (!existsSync3(this.sessionFile)) {
       const p = this.sessionFile;
       this.initEmpty();
       this.sessionFile = p;
@@ -33413,7 +33736,7 @@ var SessionManager = class _SessionManager {
     this.leafId = null;
     this.flushed = false;
     const ts = timestamp.replace(/[:.]/g, "-");
-    this.sessionFile = join4(this.sessionDir, `${ts}_${this.sessionId}.jsonl`);
+    this.sessionFile = join5(this.sessionDir, `${ts}_${this.sessionId}.jsonl`);
   }
   buildIndex() {
     this.byId.clear();
@@ -33440,7 +33763,7 @@ var SessionManager = class _SessionManager {
   rewrite() {
     if (!this.sessionFile)
       return;
-    writeFileSync3(this.sessionFile, this.fileEntries.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    writeFileSync4(this.sessionFile, this.fileEntries.map((e) => JSON.stringify(e)).join("\n") + "\n");
   }
   // -- Public accessors ------------------------------------------------------
   getLeafId() {
@@ -33460,14 +33783,14 @@ var SessionManager = class _SessionManager {
   }
   // -- Branching -------------------------------------------------------------
   getBranch(fromId) {
-    const path8 = [];
+    const path9 = [];
     const startId = fromId ?? this.leafId;
     let current = startId ? this.byId.get(startId) : void 0;
     while (current) {
-      path8.unshift(current);
+      path9.unshift(current);
       current = current.parentId ? this.byId.get(current.parentId) : void 0;
     }
-    return path8;
+    return path9;
   }
   createBranchedSession(leafId) {
     const branch = this.getBranch(leafId);
@@ -33477,7 +33800,7 @@ var SessionManager = class _SessionManager {
     const newId = randomUUID();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const ts = timestamp.replace(/[:.]/g, "-");
-    const newFile = join4(this.sessionDir, `${ts}_${newId}.jsonl`);
+    const newFile = join5(this.sessionDir, `${ts}_${newId}.jsonl`);
     const header = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -33523,50 +33846,50 @@ var SessionManager = class _SessionManager {
     return newFile;
   }
   // -- Factory ---------------------------------------------------------------
-  static open(path8) {
-    const entries = loadEntries(path8);
+  static open(path9) {
+    const entries = loadEntries(path9);
     const header = entries.find((e) => e.type === "session");
     const cwd = header?.cwd ?? process.cwd();
-    const dir = resolve2(path8, "..");
-    return new _SessionManager(cwd, dir, path8);
+    const dir = resolve2(path9, "..");
+    return new _SessionManager(cwd, dir, path9);
   }
 };
 
 // dist/fork.js
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
 import * as crypto from "node:crypto";
 function readStoreEntry(sessionsDir, sessionKey) {
-  const storeFile = path6.join(sessionsDir, "sessions.json");
+  const storeFile = path7.join(sessionsDir, "sessions.json");
   try {
-    const store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
+    const store = JSON.parse(fs6.readFileSync(storeFile, "utf-8"));
     return store[sessionKey] ?? store[sessionKey.toLowerCase()] ?? null;
   } catch {
     return null;
   }
 }
 function writeStoreEntry(sessionsDir, sessionKey, entry) {
-  const storeFile = path6.join(sessionsDir, "sessions.json");
+  const storeFile = path7.join(sessionsDir, "sessions.json");
   try {
     let store = {};
     try {
-      store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
+      store = JSON.parse(fs6.readFileSync(storeFile, "utf-8"));
     } catch {
     }
     store[sessionKey.toLowerCase()] = entry;
-    fs5.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs6.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
     return true;
   } catch {
     return false;
   }
 }
 function deleteStoreEntry(sessionsDir, sessionKey) {
-  const storeFile = path6.join(sessionsDir, "sessions.json");
+  const storeFile = path7.join(sessionsDir, "sessions.json");
   try {
-    const store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
+    const store = JSON.parse(fs6.readFileSync(storeFile, "utf-8"));
     delete store[sessionKey];
     delete store[sessionKey.toLowerCase()];
-    fs5.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs6.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
   } catch {
   }
 }
@@ -33578,17 +33901,17 @@ function resolveTranscriptFile(sessionsDir, sessionKey) {
   if (!entry?.sessionId)
     return null;
   if (entry.sessionFile) {
-    const resolved = path6.isAbsolute(entry.sessionFile) ? entry.sessionFile : path6.join(sessionsDir, entry.sessionFile);
-    if (fs5.existsSync(resolved))
+    const resolved = path7.isAbsolute(entry.sessionFile) ? entry.sessionFile : path7.join(sessionsDir, entry.sessionFile);
+    if (fs6.existsSync(resolved))
       return resolved;
   }
-  const conventional = path6.join(sessionsDir, `${entry.sessionId}.jsonl`);
-  if (fs5.existsSync(conventional))
+  const conventional = path7.join(sessionsDir, `${entry.sessionId}.jsonl`);
+  if (fs6.existsSync(conventional))
     return conventional;
   try {
-    const files = fs5.readdirSync(sessionsDir);
+    const files = fs6.readdirSync(sessionsDir);
     const match = files.find((file) => file.includes(entry.sessionId) && file.endsWith(".jsonl"));
-    return match ? path6.join(sessionsDir, match) : null;
+    return match ? path7.join(sessionsDir, match) : null;
   } catch {
     return null;
   }
@@ -33599,7 +33922,7 @@ function resolveSessionId(sessionsDir, sessionKey) {
 }
 function forkOrchestratorSession(opts) {
   const { orchestratorSessionKey, accountId, transcriptFile, sessionsDir } = opts;
-  if (!fs5.existsSync(transcriptFile))
+  if (!fs6.existsSync(transcriptFile))
     return null;
   try {
     const manager = SessionManager.open(transcriptFile);
@@ -33619,7 +33942,7 @@ function forkOrchestratorSession(opts) {
       sessionId = crypto.randomUUID();
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-      sessionFile = path6.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
+      sessionFile = path7.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
       const header = {
         type: "session",
         version: CURRENT_SESSION_VERSION,
@@ -33628,7 +33951,7 @@ function forkOrchestratorSession(opts) {
         cwd: manager.getCwd(),
         parentSession: transcriptFile
       };
-      fs5.writeFileSync(sessionFile, `${JSON.stringify(header)}
+      fs6.writeFileSync(sessionFile, `${JSON.stringify(header)}
 `, {
         encoding: "utf-8",
         mode: 384,
@@ -33638,7 +33961,7 @@ function forkOrchestratorSession(opts) {
     const forkSessionKey = `${orchestratorSessionKey}:fork:${sessionId}`;
     const wrote = writeStoreEntry(sessionsDir, forkSessionKey, {
       sessionId,
-      sessionFile: path6.relative(sessionsDir, sessionFile),
+      sessionFile: path7.relative(sessionsDir, sessionFile),
       updatedAt: Date.now(),
       spawnedBy: orchestratorSessionKey,
       parentSessionKey: orchestratorSessionKey,
@@ -33653,8 +33976,8 @@ function forkOrchestratorSession(opts) {
 }
 function cleanupForkSession(opts) {
   try {
-    if (fs5.existsSync(opts.sessionFile)) {
-      fs5.unlinkSync(opts.sessionFile);
+    if (fs6.existsSync(opts.sessionFile)) {
+      fs6.unlinkSync(opts.sessionFile);
     }
   } catch {
   }
@@ -33662,6 +33985,10 @@ function cleanupForkSession(opts) {
 }
 
 // dist/gateway.js
+function sessionContextFilePath(stateDir, sessionKey) {
+  const fileName = Buffer.from(sessionKey).toString("base64url");
+  return path8.join(stateDir, "dispatch-context", `${fileName}.json`);
+}
 function resolveWsUrl(account) {
   if (account.config.ws_url)
     return account.config.ws_url;
@@ -33964,8 +34291,13 @@ var parallGateway = {
     const telemetry = await initAgentTelemetry("parall-openclaw-agent", "openclaw");
     const otelLog = createOtelLogger("agent", "openclaw-agent");
     try {
-      const stateDir = process.env.OPENCLAW_STATE_DIR || path7.join(process.env.HOME || "/data", ".openclaw");
-      const openclawConfigPath = path7.join(stateDir, "openclaw.json");
+      const stateDir = process.env.OPENCLAW_STATE_DIR || path8.join(process.env.HOME || "/data", ".openclaw");
+      const openclawConfigPath = path8.join(stateDir, "openclaw.json");
+      const shimDir = capabilityBinDir(stateDir);
+      const currentPath = process.env.PATH ?? "";
+      if (!currentPath.split(path8.delimiter).includes(shimDir)) {
+        process.env.PATH = currentPath ? `${shimDir}${path8.delimiter}${currentPath}` : shimDir;
+      }
       const configManagerOpts = {
         client,
         stateDir,
@@ -34001,7 +34333,7 @@ var parallGateway = {
         wsUrl
       });
       const orchestratorKey = buildOrchestratorSessionKey(ctx.accountId);
-      const sessionsDir = path7.join(stateDir, "agents", "main", "sessions");
+      const sessionsDir = path8.join(stateDir, "agents", "main", "sessions");
       const workspaceDir = process.cwd();
       ensureLocalAttachmentGitExclude(workspaceDir);
       const dispatchAdapter = createOpenClawDispatchAdapter({
@@ -34026,7 +34358,22 @@ var parallGateway = {
         runtimeKey: orchestratorKey,
         runtimeRef: { hostname: os2.hostname(), pid: process.pid },
         dispatchAdapter,
+        // 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).
+        dispatchContextDir: dispatchLaneContextDir(stateDir),
+        // Per-session context file (PRLL_CONTEXT_FILE contract) — the CLI's
+        // TYPED dispatch binding (parall tasks update → task_update effect)
+        // reads lane/event/task fields from this file, not the lane dir.
+        contextFilePathForSession: (sessionKey) => sessionContextFilePath(stateDir, sessionKey),
         log: otelLog,
+        // Live capability view for hint routing: the channel reply hint
+        // points at the vendor CLI only while the grant is active.
+        getCapabilityKeys: getChannelCapabilityKeys,
         shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
         forkDeadlineMs: parseForkDeadlineMs(process.env.PRLL_FORK_DEADLINE_MS),
         dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
@@ -34046,7 +34393,13 @@ var parallGateway = {
             runtimeRef: { hostname: os2.hostname(), pid: process.pid },
             wikiMountRoot,
             ws,
-            orchestratorSessionKey: orchestratorKey
+            orchestratorSessionKey: orchestratorKey,
+            dispatchContextDir: dispatchLaneContextDir(stateDir),
+            contextFilePathForSession: (sessionKey) => sessionContextFilePath(stateDir, sessionKey),
+            // Lease-renewal bridge: openclaw tool calls flow through hooks,
+            // not the RuntimeEvent stream, so hook activity must renew the
+            // ledger lanes or a long exec outlives the lease (STALE_LANE).
+            touchRuntimeActivity: (sessionKey) => gateway.touchRuntimeActivity(sessionKey)
           });
         },
         onSessionBinding: async ({ sessionKey, agentSessionId }) => {
@@ -34220,15 +34573,52 @@ function registerParallHooks(api) {
         buildIdentity(getAgentIdentity()),
         PRLL_CHANNEL_CONTEXT,
         PRLL_BEHAVIOR,
-        PRLL_REFERENCE_GUIDE
+        PRLL_REFERENCE_GUIDE,
+        // Channel-capability declarations (platform-config
+        // agents.capabilities[]). Evaluated on EVERY prompt build, so a
+        // capability grant/revocation reaches the next turn without any
+        // restart — the openclaw analogue of the CLI bridges' prompt-file
+        // rewrite + respawn.
+        ...getChannelCapabilityFragments()
       ].join("\n\n")
     };
   });
   const pendingSendCalls = /* @__PURE__ */ new Map();
+  const laneRenewals = /* @__PURE__ */ new Map();
+  const LANE_RENEW_INTERVAL_MS = 18e4;
+  const beginToolRenewal = (sessionKey) => {
+    const accountId = extractAccountIdFromSessionKey(sessionKey);
+    const state = accountId ? getParallAccountState(accountId) : void 0;
+    if (!state?.touchRuntimeActivity)
+      return;
+    state.touchRuntimeActivity(sessionKey);
+    const entry = laneRenewals.get(sessionKey) ?? { count: 0 };
+    entry.count++;
+    if (!entry.timer) {
+      entry.timer = setInterval(() => state.touchRuntimeActivity?.(sessionKey), LANE_RENEW_INTERVAL_MS);
+      entry.timer.unref?.();
+    }
+    laneRenewals.set(sessionKey, entry);
+  };
+  const endToolRenewal = (sessionKey) => {
+    const entry = laneRenewals.get(sessionKey);
+    if (entry) {
+      entry.count--;
+      if (entry.count <= 0) {
+        if (entry.timer)
+          clearInterval(entry.timer);
+        laneRenewals.delete(sessionKey);
+      }
+    }
+    const accountId = extractAccountIdFromSessionKey(sessionKey);
+    const state = accountId ? getParallAccountState(accountId) : void 0;
+    state?.touchRuntimeActivity?.(sessionKey);
+  };
   api.on("before_tool_call", async (event, ctx) => {
     const sessionKey = ctx.sessionKey;
     if (sessionKey) {
       recordToolCall(sessionKey);
+      beginToolRenewal(sessionKey);
       if (event.toolName === "exec" && event.toolCallId) {
         const command = event.params?.command;
         if (isParallSendCommand(command)) {
@@ -34297,6 +34687,12 @@ function registerParallHooks(api) {
       injectedEnv.PRLL_TRIGGER_MESSAGE_ID = triggerMsgId;
     if (state.wikiMountRoot)
       injectedEnv.PRLL_WIKI_MOUNT_ROOT = state.wikiMountRoot;
+    if (state.dispatchContextDir)
+      injectedEnv.PRLL_CONTEXT_DIR = state.dispatchContextDir;
+    if (state.contextFilePathForSession) {
+      injectedEnv.PRLL_CONTEXT_FILE = state.contextFilePathForSession(sessionKey);
+    }
+    state.touchRuntimeActivity?.(sessionKey);
     injectedEnv.OPENCLAW_SESSION_KEY = sessionKey;
     if (event.toolCallId)
       injectedEnv.OPENCLAW_TOOL_CALL_ID = event.toolCallId;
@@ -34308,6 +34704,8 @@ function registerParallHooks(api) {
     };
   });
   api.on("after_tool_call", async (event, ctx) => {
+    if (ctx.sessionKey)
+      endToolRenewal(ctx.sessionKey);
     if (ctx.sessionKey && event.toolCallId && pendingSendCalls.delete(event.toolCallId)) {
       recordMessageSend(ctx.sessionKey, !event.error);
     }