@parall/daemon 1.36.1 → 1.38.0

package/bundle/parall-claude-agent.js

@@ -17718,9 +17718,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 path9 of paths) {
+      for (const path10 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path9, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path10, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -21123,7 +21123,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path9) {
+function appendResourcePathToUrl(url, path10) {
   try {
     new URL(url);
   } catch (_a) {
@@ -21133,11 +21133,11 @@ function appendResourcePathToUrl(url, path9) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path9;
+  url += path10;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path9 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path10 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -26474,6 +26474,19 @@ function parseProviderConfig(env) {
   }
 }
 
+// ts/agent-core/dist/lane-key.js
+import * as path from "node:path";
+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`);
+}
+
 // ts/agent-core/dist/session-state.js
 function normalizeSessionKey(sessionKey) {
   return sessionKey.toLowerCase();
@@ -26647,6 +26660,17 @@ function buildEventBody(event) {
     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}]`);
@@ -26688,7 +26712,7 @@ function buildSendMessageHint(event) {
   }
   if (event.targetId.startsWith("cht_")) {
     return `
-<system-reminder>To reply, run: \`parall messages send prll://${event.targetId} --text "..."\` \u2014 your plain text output is not delivered to the chat.</system-reminder>`;
+<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 `
@@ -26697,6 +26721,14 @@ function buildSendMessageHint(event) {
   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 `
@@ -26904,6 +26936,8 @@ Or upload first and reuse across chats:
     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
@@ -26954,11 +26988,21 @@ To say something in a chat, you **must** invoke the Parall CLI via your shell/ex
 
 All outbound interactions go through the \`parall\` CLI. Credentials are pre-injected as environment variables \u2014 no setup needed. If \`parall\` is not on PATH, use \`npx --yes @parall/cli@latest\` instead.
 
-- \`parall messages send prll://cht_xxx --text "..."\` \u2014 reply into the triggering chat
-- \`parall dm prll://usr_xxx --text "..." [--no-reply]\` \u2014 direct message another user
+- \`parall messages send prll://cht_xxx --text-file -\` \u2014 reply into the triggering chat (pipe the body via a quoted heredoc; see Shell-safety below)
+- \`parall dm prll://usr_xxx --text-file - [--no-reply]\` \u2014 direct message another user
 - \`parall tasks update prll://tsk_xxx --status in_progress\` \u2014 task state
 - \`parall no-reply [--reason "..."]\` \u2014 explicitly declare this turn silent (audit signal; not required for silence, just clarifies intent)
 
+**Shell-safety \u2014 never wrap real message content in double quotes.** Your command runs in a shell, which expands \`$\`, backticks, and \`$(...)\` inside \`"..."\` before the CLI sees them: \`--text "That costs $1,000"\` sends \`That costs ,000\`, and \`--text "$(cmd)"\` executes \`cmd\`. Pass message bodies via \`--text-file <path>\` (write the file first \u2014 no shell touches it) or a quoted heredoc that disables expansion:
+
+\`\`\`bash
+parall messages send prll://cht_xxx --text-file - <<'EOF'
+That costs $1,000, and $(whoami) stays literal. I'm on it.
+EOF
+\`\`\`
+
+Keep \`--text "..."\` for short literals with no \`$\`, backtick, or apostrophe.
+
 The bridge injects Parall context via environment variables. The static credentials \`PRLL_API_URL\`, \`PRLL_API_KEY\`, and \`PRLL_ORG_ID\` are always set. \`PRLL_CONTEXT_FILE\` points to a per-session JSON file that the gateway updates each dispatch with \`session_id\`, \`chat_id\`, \`trigger_message_id\`, \`no_reply\`, and \`step_id\` (updated per tool call). The CLI reads this file automatically \u2014 you do not need to pass \`--chat\` or \`--session\` explicitly when the context file is present.
 
 ## Attachments
@@ -27003,7 +27047,7 @@ Messages may arrive with a \`[Thread: prll://msg_xxx]\` line in the event block,
 
 ### CLI usage
 - The \`msg_xxx\` from the \`[Thread: prll://msg_xxx]\` line is the thread root ID \u2014 pass it as \`--thread-root-id\`
-- Reply in a thread: \`parall messages send <chatId> --text "..." --thread-root-id <msgId>\`
+- Reply in a thread: \`parall messages send <chatId> --text-file /tmp/reply.md --thread-root-id <msgId>\`
 - Read thread replies: \`parall messages list <chatId> --thread-root-id <msgId>\`
 
 ### Thread etiquette
@@ -27071,8 +27115,8 @@ function childLogger(logger, sub) {
 
 // ts/agent-core/dist/gateway-base.js
 import * as os from "node:os";
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 
 // ts/sdk/dist/types.js
 var MENTION_ALL_USER_ID = "all";
@@ -27104,6 +27148,7 @@ var ENDPOINTS = {
   // Org-scoped
   ORG: (orgId) => `${API_BASE}/orgs/${orgId}`,
   ORG_MEMBERS: (orgId) => `${API_BASE}/orgs/${orgId}/members`,
+  ORG_MEMBERS_FORMER: (orgId) => `${API_BASE}/orgs/${orgId}/members/former`,
   TEAMS: (orgId) => `${API_BASE}/orgs/${orgId}/teams`,
   ORG_MEMBERS_ONLINE: (orgId) => `${API_BASE}/orgs/${orgId}/members/online`,
   ORG_MEMBER: (orgId, userId) => `${API_BASE}/orgs/${orgId}/members/${userId}`,
@@ -27253,6 +27298,19 @@ var ENDPOINTS = {
   EXTERNAL_TRIGGER: (orgId, triggerId) => `${API_BASE}/orgs/${orgId}/external-triggers/${triggerId}`,
   EXTERNAL_TRIGGER_RUNS: (orgId) => `${API_BASE}/orgs/${orgId}/external-trigger-runs`,
   EXTERNAL_TRIGGER_RUN: (orgId, runId) => `${API_BASE}/orgs/${orgId}/external-trigger-runs/${runId}`,
+  // External IM channel (org-scoped, platform-mediated Feishu/Slack)
+  CHANNEL_CONNECTIONS: (orgId) => `${API_BASE}/orgs/${orgId}/channel-connections`,
+  CHANNEL_CONNECTION: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}`,
+  CHANNEL_CONNECTION_CREDENTIALS: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/credentials`,
+  CHANNEL_CONNECTION_INGRESS_TOKEN_REGENERATE: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/ingress-token/regenerate`,
+  CHANNEL_CONNECTION_CONVERSATIONS: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/channel-connections/${connectionId}/conversations`,
+  CHANNEL_CONVERSATION: (orgId, conversationId) => `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}`,
+  CHANNEL_CONVERSATION_MESSAGES: (orgId, conversationId) => `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}/messages`,
+  CHANNEL_CONVERSATION_SESSION: (orgId, conversationId) => `${API_BASE}/orgs/${orgId}/channel-conversations/${conversationId}/session`,
+  CHANNEL_MESSAGE: (orgId, messageId) => `${API_BASE}/orgs/${orgId}/channel-messages/${messageId}`,
+  CHANNEL_PROVISIONING: (orgId) => `${API_BASE}/orgs/${orgId}/channel-provisioning`,
+  CHANNEL_PROVISIONING_SESSION: (orgId, sessionId) => `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}`,
+  CHANNEL_PROVISIONING_CANCEL: (orgId, sessionId) => `${API_BASE}/orgs/${orgId}/channel-provisioning/${sessionId}/cancel`,
   // Invitations (org-scoped, admin)
   ORG_INVITATIONS: (orgId) => `${API_BASE}/orgs/${orgId}/invitations`,
   ORG_INVITATION: (orgId, invId) => `${API_BASE}/orgs/${orgId}/invitations/${invId}`,
@@ -27270,9 +27328,16 @@ var ENDPOINTS = {
   INVITE_LINK_JOIN: `${API_BASE}/invite-link/join`,
   // Wikis (org-scoped, served by wiki-service)
   WIKIS: (orgId) => `${WIKI_BASE}/orgs/${orgId}/wikis`,
+  // Recycle bin — soft-deleted wikis (owner only). Must precede WIKI in the
+  // backend router so `deleted` isn't captured as a {wikiId}; the SDK builder
+  // is just a string.
+  WIKIS_DELETED: (orgId) => `${WIKI_BASE}/orgs/${orgId}/wikis/deleted`,
+  // Detail URL — also reused for DELETE (soft-delete) and `${WIKI}/restore`.
   WIKI: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}`,
+  WIKI_RESTORE: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restore`,
   WIKI_TREE: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/tree`,
   WIKI_BLOB: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/blob`,
+  WIKI_COPY: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/copy`,
   WIKI_NODE_SECTIONS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/node-sections`,
   WIKI_SEARCH: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/search`,
   WIKI_PAGE_INDEX: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/page-index`,
@@ -27326,6 +27391,11 @@ var ENDPOINTS = {
   DISPATCH_ACK_BY_ID: (orgId, id) => `${API_BASE}/orgs/${orgId}/dispatch/${id}/ack`,
   DISPATCH_EXPIRE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/expire`,
   DISPATCH_BY_MESSAGES: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/by-messages`,
+  DISPATCH_CLAIM: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/claim`,
+  DISPATCH_STEER: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/steer`,
+  DISPATCH_COMPLETE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/complete`,
+  DISPATCH_RELEASE: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/release`,
+  DISPATCH_HEARTBEAT: (orgId) => `${API_BASE}/orgs/${orgId}/dispatch/heartbeat`,
   // Unread
   UNREAD: `${API_BASE}/me/unread`,
   ORG_UNREAD: (orgId) => `${API_BASE}/orgs/${orgId}/unread`,
@@ -27355,6 +27425,14 @@ var ENDPOINTS = {
   BILLING_AUTO_RELOAD: (orgId) => `${API_BASE}/orgs/${orgId}/billing/auto-reload`,
   BILLING_SETUP_INTENT: (orgId) => `${API_BASE}/orgs/${orgId}/billing/setup-intent`,
   COMPUTE_PRICING: () => `${API_BASE}/billing/compute-pricing`,
+  // Runtime capability table (public, no auth) — SSOT for the create/settings
+  // interlock: per-runtime compute modes, native model family, cross-family
+  // availability, and recommended model.
+  RUNTIMES: () => `${API_BASE}/runtimes`,
+  // Model catalog (public, no auth) — served from the server's DB-backed
+  // snapshot. Optional include_model keeps an agent's pinned hidden legacy
+  // model representable in settings pickers.
+  MODELS: (includeModel) => includeModel ? `${API_BASE}/models?include_model=${encodeURIComponent(includeModel)}` : `${API_BASE}/models`,
   // ADMIN_GRANTS intentionally NOT exported here — it sits under the
   // unauthenticated `/internal/admin/*` surface and must not bleed into the
   // public SDK. Admin dashboard hits the URL directly from its own client.
@@ -27367,6 +27445,7 @@ var ENDPOINTS = {
   AGENT_CLIP: (orgId, agentId, clipId) => `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips/${clipId}`,
   CLIP_INVOKE: (orgId) => `${CLIP_BASE}/orgs/${orgId}/invoke`,
   CLIP_ONLINE: (orgId) => `${CLIP_BASE}/orgs/${orgId}/online`,
+  BROWSER_RUNTIME_STATUS: (orgId) => `${CLIP_BASE}/orgs/${orgId}/browser-runtime/status`,
   BROWSER_PROFILES: (orgId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles`,
   BROWSER_PROFILE: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}`,
   BROWSER_PROFILE_OPEN: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/open`,
@@ -27420,10 +27499,13 @@ var WS_EVENTS = {
   INVITATION_REVOKED: "invitation.revoked",
   ORG_JOIN_REQUEST_NEW: "org.join_request.new",
   ORG_INVITE_LINK_JOINED: "org.invite_link.joined",
+  ORG_MEMBER_REMOVED: "org.member.removed",
   AGENT_CONFIG_UPDATE: "agent_config.update",
   PRESENCE_UPDATE: "presence.update",
   WIKI_CHANGESET_CREATED: "wiki.changeset.created",
   WIKI_CHANGESET_UPDATED: "wiki.changeset.updated",
+  WIKI_DELETED: "wiki.deleted",
+  WIKI_RESTORED: "wiki.restored",
   COMMENT_CREATED: "comment.created",
   COMMENT_UPDATED: "comment.updated",
   COMMENT_DELETED: "comment.deleted",
@@ -27434,6 +27516,7 @@ var WS_EVENTS = {
   READ_POSITION_UPDATED: "read_position.updated",
   DISPATCH_NEW: "dispatch.new",
   DISPATCH_RECEIVED: "dispatch.received",
+  DISPATCH_RESOLVED: "dispatch.resolved",
   SCHEDULE_CREATED: "schedule.created",
   SCHEDULE_UPDATED: "schedule.updated",
   SCHEDULE_DELETED: "schedule.deleted",
@@ -27451,6 +27534,7 @@ var WS_EVENTS = {
   MACHINE_FILESYSTEM_BROWSE: "machine.filesystem.browse",
   MACHINE_UPDATE: "machine.update",
   MACHINE_CONFIG_UPDATED: "machine.config.updated",
+  MACHINE_AGENT_CONFIG_UPDATED: "machine.agent_config.updated",
   MACHINE_CLIP_SYNC: "machine.clip.sync",
   MACHINE_BROWSER_PROFILE_LIFECYCLE: "machine.browser_profile.lifecycle",
   MACHINE_BROWSER_PROFILE_VIEWER: "machine.browser_profile.viewer",
@@ -27528,8 +27612,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(path9) {
-    return path9.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+  baseUrlFor(path10) {
+    return path10.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
   }
   setToken(token) {
     this.token = token;
@@ -27556,10 +27640,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(path9) {
+  async ensureFreshToken(path10) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path9.replace(/^\/api\/v1/, "");
+    const pathSuffix = path10.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -27591,11 +27675,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path9, body, query, retried = false, opts) {
+  async request(method, path10, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path9);
+      await this.ensureFreshToken(path10);
     }
-    let url = `${this.baseUrlFor(path9)}${path9}`;
+    let url = `${this.baseUrlFor(path10)}${path10}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27625,12 +27709,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path9.replace(/^\/api\/v1/, "");
+      const pathSuffix = path10.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, path9, body, query, true, opts);
+          return this.request(method, path10, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27641,6 +27725,7 @@ var ParallClient = class _ParallClient {
       const rawErrorBody = await res.json().catch(() => ({}));
       throw buildApiError(res, rawErrorBody);
     }
+    opts?.onStatus?.(res.status);
     if (res.status === 204)
       return void 0;
     if (res.status === 202) {
@@ -27659,15 +27744,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, path9, body, retried = false) {
+  async multipartRequest(method, path10, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path9);
+      await this.ensureFreshToken(path10);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrlFor(path9)}${path9}`, {
+      res = await fetch(`${this.baseUrlFor(path10)}${path10}`, {
         method,
         headers,
         body,
@@ -27677,12 +27762,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path9.replace(/^\/api\/v1/, "");
+      const pathSuffix = path10.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, path9, body, true);
+          return this.multipartRequest(method, path10, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27790,6 +27875,13 @@ var ParallClient = class _ParallClient {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS(orgId));
     return res.data;
   }
+  /** User IDs of soft-removed (former) org members — for marking their avatar /
+   *  name as "left" where dormant relations still surface them (DMs, task
+   *  assignees, message history). */
+  async getFormerMemberIds(orgId) {
+    const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS_FORMER(orgId));
+    return res.user_ids ?? [];
+  }
   async getTeams(orgId) {
     const res = await this.request("GET", ENDPOINTS.TEAMS(orgId));
     return res.data;
@@ -27967,6 +28059,21 @@ var ParallClient = class _ParallClient {
   async sendMessage(orgId, chatId, req) {
     return this.request("POST", ENDPOINTS.CHAT_MESSAGES(orgId, chatId), req);
   }
+  /**
+   * sendMessage variant that also reports whether the server answered with an
+   * idempotent replay (HTTP 200 — the message already existed for this
+   * idempotency/effect key) instead of a fresh create (201). Used by the CLI
+   * to surface "already sent by a previous run (deduplicated)".
+   */
+  async sendMessageDetailed(orgId, chatId, req) {
+    let status = 0;
+    const message = await this.request("POST", ENDPOINTS.CHAT_MESSAGES(orgId, chatId), req, void 0, false, {
+      onStatus: (s) => {
+        status = s;
+      }
+    });
+    return { message, deduplicated: status === 200 };
+  }
   async getMessages(orgId, chatId, params) {
     return this.request("GET", ENDPOINTS.CHAT_MESSAGES(orgId, chatId), void 0, params);
   }
@@ -28278,20 +28385,25 @@ var ParallClient = class _ParallClient {
     return res.data;
   }
   /** `POST /machines/me/browser-profiles/{profileId}/status` — report runtime status. */
-  async reportBrowserProfileStatus(profileId, status, errorMsg) {
+  async reportBrowserProfileStatus(profileId, status, errorMsg, generation) {
     await this.request("POST", ENDPOINTS.MACHINES_ME_BROWSER_PROFILE_STATUS(profileId), {
       status,
-      ...errorMsg ? { error_msg: errorMsg } : {}
+      ...errorMsg ? { error_msg: errorMsg } : {},
+      ...generation !== void 0 ? { generation } : {}
     });
   }
   /**
    * `POST /machines/me/health` — bump the Machine's `updated_at` to now and
-   * report daemon state. The daemon should call this on a fixed cadence (e.g.
-   * every 30s) so an external observer can detect a wedged supervisor. Both
+   * report daemon state. The daemon calls this on startup and again whenever
+   * periodic runtime re-detection produces a CHANGED result (there is no
+   * fixed-cadence keepalive loop today — steady state posts nothing). All
    * fields are optional and only persisted when changed:
    *  - `daemonVersion` — the running bundle/launcher version.
    *  - `selfUpdateCapable` — whether the daemon can act on a machine.update
    *    signal (true under a service manager, false for bare `npx` foreground).
+   *  - `detectedRuntimes` — runtime CLIs found on the host. Omitted = no
+   *    report this beat (server keeps the stored value); [] = detection ran
+   *    and found nothing (server clears to empty).
    */
   async postMachineHeartbeat(opts) {
     const body = {};
@@ -28299,6 +28411,8 @@ var ParallClient = class _ParallClient {
       body.daemon_version = opts.daemonVersion;
     if (opts?.selfUpdateCapable !== void 0)
       body.self_update_capable = opts.selfUpdateCapable;
+    if (opts?.detectedRuntimes !== void 0)
+      body.detected_runtimes = opts.detectedRuntimes;
     return this.request("POST", ENDPOINTS.MACHINES_ME_HEALTH, Object.keys(body).length > 0 ? body : void 0);
   }
   async reportAgentWorkspaceState(agentId, state) {
@@ -28347,8 +28461,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, path9) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path9 }, void 0, false, { timeoutMs: 15e3 });
+  async browseMachineFilesystem(orgId, machineId, path10) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path10 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -28421,6 +28535,30 @@ var ParallClient = class _ParallClient {
     const params = maxAgeHours !== void 0 ? { max_age_hours: String(maxAgeHours) } : void 0;
     return this.request("POST", ENDPOINTS.DISPATCH_EXPIRE(orgId), void 0, params);
   }
+  /**
+   * Claim a dispatch lane (explicit consume endpoint). Occupies the
+   * (agent, target, thread) lane and folds claimable WorkItems into it;
+   * `claimed: false` means a healthy incumbent holds the lane.
+   */
+  async claimDispatch(orgId, req) {
+    return this.request("POST", ENDPOINTS.DISPATCH_CLAIM(orgId), req);
+  }
+  /** Fold a pending same-target WorkItem into a live lane (409 STALE_LANE when dethroned). */
+  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);
+  }
+  /** Release a lane on graceful shutdown — members return to pending immediately. */
+  async releaseDispatchLane(orgId, lane) {
+    return this.request("POST", ENDPOINTS.DISPATCH_RELEASE(orgId), { lane });
+  }
+  /** Renew a live lane's lease (long-turn keepalive). 409 STALE_LANE when dethroned. */
+  async heartbeatDispatchLane(orgId, req) {
+    return this.request("POST", ENDPOINTS.DISPATCH_HEARTBEAT(orgId), req);
+  }
   async getDispatchByMessages(orgId, chatId, messageIds) {
     const params = { chat_id: chatId, message_ids: messageIds.join(",") };
     return this.request("GET", ENDPOINTS.DISPATCH_BY_MESSAGES(orgId), void 0, params);
@@ -28617,6 +28755,59 @@ var ParallClient = class _ParallClient {
   async deleteExternalConnection(orgId, connectionId) {
     return this.request("DELETE", ENDPOINTS.EXTERNAL_CONNECTION(orgId, connectionId));
   }
+  // ---- External IM channel (org-scoped) ----
+  async createChannelConnection(orgId, input) {
+    return this.request("POST", ENDPOINTS.CHANNEL_CONNECTIONS(orgId), input);
+  }
+  async listChannelConnections(orgId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_CONNECTIONS(orgId));
+  }
+  async getChannelConnection(orgId, connectionId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId));
+  }
+  async updateChannelConnection(orgId, connectionId, patch) {
+    return this.request("PATCH", ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId), patch);
+  }
+  async archiveChannelConnection(orgId, connectionId) {
+    return this.request("DELETE", ENDPOINTS.CHANNEL_CONNECTION(orgId, connectionId));
+  }
+  async deliverChannelCredentials(orgId, connectionId, credentials) {
+    return this.request("POST", ENDPOINTS.CHANNEL_CONNECTION_CREDENTIALS(orgId, connectionId), credentials);
+  }
+  async regenerateChannelIngressToken(orgId, connectionId) {
+    return this.request("POST", ENDPOINTS.CHANNEL_CONNECTION_INGRESS_TOKEN_REGENERATE(orgId, connectionId));
+  }
+  /** Start a Feishu one-click provisioning session (device flow QR). */
+  async initiateChannelProvisioning(orgId, input) {
+    return this.request("POST", ENDPOINTS.CHANNEL_PROVISIONING(orgId), input);
+  }
+  /**
+   * Lazy status poll — server-side this may forward one provider poll, so
+   * call it at the session's `poll_interval_seconds` cadence, not faster.
+   */
+  async getChannelProvisioningSession(orgId, sessionId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_PROVISIONING_SESSION(orgId, sessionId));
+  }
+  async cancelChannelProvisioning(orgId, sessionId) {
+    return this.request("POST", ENDPOINTS.CHANNEL_PROVISIONING_CANCEL(orgId, sessionId));
+  }
+  async listChannelConversations(orgId, connectionId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_CONNECTION_CONVERSATIONS(orgId, connectionId));
+  }
+  async getChannelConversation(orgId, conversationId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_CONVERSATION(orgId, conversationId));
+  }
+  async listChannelConversationMessages(orgId, conversationId, limit) {
+    return this.request("GET", ENDPOINTS.CHANNEL_CONVERSATION_MESSAGES(orgId, conversationId), void 0, { limit });
+  }
+  async setChannelConversationSession(orgId, conversationId, agentSessionId) {
+    return this.request("PATCH", ENDPOINTS.CHANNEL_CONVERSATION_SESSION(orgId, conversationId), {
+      agent_session_id: agentSessionId
+    });
+  }
+  async getChannelMessage(orgId, messageId) {
+    return this.request("GET", ENDPOINTS.CHANNEL_MESSAGE(orgId, messageId));
+  }
   async getExternalTriggerSchema(orgId, connectionId) {
     return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGER_SCHEMA(orgId, connectionId));
   }
@@ -28658,6 +28849,23 @@ var ParallClient = class _ParallClient {
   async getWiki(orgId, wikiId) {
     return this.request("GET", ENDPOINTS.WIKI(orgId, wikiId));
   }
+  /** Soft-delete an entire wiki (org owner only; the default wiki is
+   *  protected → 403 WIKI_PROTECTED). Returns the deleted wiki. Recoverable
+   *  via restoreWiki within the retention window. */
+  async deleteWiki(orgId, wikiId) {
+    return this.request("DELETE", ENDPOINTS.WIKI(orgId, wikiId));
+  }
+  /** Restore a soft-deleted wiki (org owner only). 409 WIKI_PURGE_STARTED once
+   *  purge has been claimed (no longer restorable), or 404 once the row is gone.
+   *  Returns the restored wiki. */
+  async restoreWiki(orgId, wikiId) {
+    return this.request("POST", ENDPOINTS.WIKI_RESTORE(orgId, wikiId));
+  }
+  /** Recycle bin — list soft-deleted wikis for the org (owner only). */
+  async getDeletedWikis(orgId) {
+    const res = await this.request("GET", ENDPOINTS.WIKIS_DELETED(orgId));
+    return res.data;
+  }
   async getWikiTree(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_TREE(orgId, wikiId), void 0, params);
   }
@@ -28691,6 +28899,15 @@ var ParallClient = class _ParallClient {
       blob.signed_url = this.absoluteMediaUrl(blob.signed_url);
     return blob;
   }
+  /**
+   * Copy one wiki file to another path as an independent snapshot (no sync).
+   * Used to "share a private file out": copy a file from the caller's personal
+   * namespace (`users/{userId}/…`) into the public wiki, leaving the original
+   * untouched. 409 `FILE_EXISTS` if `dest_path` already exists.
+   */
+  async copyWikiFile(orgId, wikiId, req) {
+    return this.request("POST", ENDPOINTS.WIKI_COPY(orgId, wikiId), req);
+  }
   async getWikiNodeSections(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_NODE_SECTIONS(orgId, wikiId), void 0, params);
   }
@@ -28806,8 +29023,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiRestriction(orgId, wikiId, restrictionId) {
     await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path9) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path9 ? { path: path9 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path10) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path10 ? { path: path10 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -28816,14 +29033,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, path9, params) {
+  async getWikiFileCommits(orgId, wikiId, path10, params) {
     return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-      path: path9,
+      path: path10,
       ...params
     });
   }
-  async getWikiBlame(orgId, wikiId, path9, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path9, ref });
+  async getWikiBlame(orgId, wikiId, path10, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path10, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -28964,6 +29181,19 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", ENDPOINTS.COMPUTE_PRICING());
     return resp.data;
   }
+  /** Runtime capability table (public) — SSOT for the create/settings interlock. */
+  async getRuntimes() {
+    const resp = await this.request("GET", ENDPOINTS.RUNTIMES());
+    return resp.data;
+  }
+  /**
+   * Platform model catalog (public) — DB-backed, replaces the compile-time
+   * PLATFORM_MODELS constant. Pass includeModel to keep an agent's pinned
+   * hidden legacy model representable (settings picker).
+   */
+  async getModels(includeModel) {
+    return this.request("GET", ENDPOINTS.MODELS(includeModel));
+  }
   // ---- Clips ----
   async listClips(orgId) {
     const resp = await this.request("GET", ENDPOINTS.CLIPS(orgId));
@@ -29008,6 +29238,11 @@ 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));
+  }
   /** 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. */
@@ -29437,6 +29672,404 @@ var ParallWs = class {
   }
 };
 
+// ts/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}`);
+    }
+    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);
+    }
+    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;
+      }
+    }
+    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;
+    }
+  }
+  /**
+   * 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)}`);
+    }
+  }
+  /**
+   * 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)}`);
+    });
+  }
+  /**
+   * 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)}`);
+    }
+  }
+  async releaseAll() {
+    const keys = [...this.lanes.keys()];
+    for (const key of keys) {
+      await this.release(key);
+    }
+  }
+  /** 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;
+    }
+    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 {
+      }
+    }
+  }
+};
+
+// ts/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";
+  }
+  const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
+  await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
+  return "dispatched";
+}
+async function consumeTypedDispatch(host, ref, run, ack) {
+  if (!host.laneLedger || host.ledgerDisabled) {
+    if (await run(ref.dispatchEventId))
+      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))
+        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))
+      ack(lane.typedDispatchEventId);
+  } finally {
+    await host.laneLedger.completeIfIdle(lane.laneKey, false).catch(() => {
+    });
+  }
+}
+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;
+  }
+}
+
 // ts/agent-core/dist/telemetry.js
 init_esm();
 var import_api_logs = __toESM(require_src(), 1);
@@ -29667,6 +30300,9 @@ function resolveStepTarget(event) {
   if (event.type === "external_trigger" || event.targetId.startsWith("xtr_")) {
     return { target_type: "external_trigger", target_id: event.targetId };
   }
+  if (event.type === "channel_message" || event.targetId.startsWith("chv_")) {
+    return { target_type: "channel_conversation", target_id: event.targetId };
+  }
   if (event.type === "wiki_comment") {
     return { target_type: "wiki", target_id: event.targetId || void 0 };
   }
@@ -29710,6 +30346,9 @@ var ParallAgentGateway = class {
   opts;
   chatInfoMap = /* @__PURE__ */ new Map();
   dispatchedTasks = /* @__PURE__ */ new Set();
+  // connection id → provider alias, for channel_message prompt labeling
+  // (stable mapping; avoids one connection fetch per inbound message).
+  channelConnectionProviders = /* @__PURE__ */ new Map();
   dispatchedMessages = /* @__PURE__ */ new Set();
   forkStates = /* @__PURE__ */ new Map();
   dispatchState = {
@@ -29732,6 +30371,14 @@ var ParallAgentGateway = class {
   inFlightDispatches = 0;
   drainResolvers = [];
   pendingRestartNotification = null;
+  laneLedger;
+  // Sticky fallback: flipped when the server predates the ledger (claim
+  // endpoint 404) so every subsequent dispatch uses the legacy flow.
+  ledgerDisabled = false;
+  // Group key of the group currently being dispatched on main — lane-aware
+  // (targetId + thread), unlike mainCurrentTargetId which stays chat-level
+  // for fork routing decisions.
+  mainCurrentGroupKey;
   DISPATCHED_MESSAGES_CAP = 5e3;
   // SHUTDOWN_DEADLINE_MS is read by waitForDrain via the configured value
   // below — kept as instance state so per-runtime configs can override it
@@ -29741,6 +30388,14 @@ var ParallAgentGateway = class {
   DISPATCH_DEADLINE_MS;
   constructor(opts) {
     this.opts = opts;
+    if (opts.dispatchContextDir) {
+      this.laneLedger = new LaneLedger({
+        client: opts.client,
+        orgId: opts.config.org_id,
+        contextDir: opts.dispatchContextDir,
+        log: opts.log
+      });
+    }
     this.SHUTDOWN_DEADLINE_MS = opts.shutdownDeadlineMs ?? 6e4;
     this.FORK_DEADLINE_MS = opts.forkDeadlineMs ?? 2 * 60 * 6e4;
     this.DISPATCH_DEADLINE_MS = opts.dispatchDeadlineMs ?? 20 * 6e4;
@@ -29810,14 +30465,18 @@ var ParallAgentGateway = class {
       if (data.status !== "todo" && data.status !== "in_progress")
         return;
       try {
-        const dispatched = await this.handleTaskAssignment(data, data.id);
-        if (dispatched) {
+        await this.consumeTypedDispatch(data.dispatch_event_id ? { dispatchEventId: data.dispatch_event_id } : { sourceType: "task_activity", sourceId: data.id }, (dispatchEventId) => this.handleTaskAssignment(data, data.id, dispatchEventId), (dispatchEventId) => {
+          if (dispatchEventId) {
+            this.opts.client.ackDispatchByID(this.opts.config.org_id, dispatchEventId).catch(() => {
+            });
+            return;
+          }
           this.opts.client.ackDispatch(this.opts.config.org_id, {
             source_type: "task_activity",
             source_id: data.id
           }).catch(() => {
           });
-        }
+        });
       } catch (err) {
         this.opts.log?.error(`task dispatch failed for ${data.id}: ${String(err)}`);
       }
@@ -29827,11 +30486,10 @@ var ParallAgentGateway = class {
         if (!data.source_id || !data.task_id)
           return;
         try {
-          const dispatched = await this.handleTaskComment(data.source_id, data.task_id, data.actor_id, data.delivery_reason);
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.handleTaskComment(data.source_id, data.task_id ?? "", data.actor_id, data.delivery_reason), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`task comment dispatch failed for ${data.source_id}: ${String(err)}`);
         }
@@ -29839,11 +30497,10 @@ var ParallAgentGateway = class {
         if (!data.source_id)
           return;
         try {
-          const dispatched = await this.handleWikiComment(data.source_id, data.actor_id, data.delivery_reason);
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.handleWikiComment(data.source_id, data.actor_id, data.delivery_reason), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`wiki comment dispatch failed for ${data.source_id}: ${String(err)}`);
         }
@@ -29851,11 +30508,13 @@ var ParallAgentGateway = class {
         if (!data.task_id)
           return;
         try {
-          const dispatched = await this.handleTaskDispatch(data.task_id, data.source_id ?? data.task_id, { allowCreator: true });
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.handleTaskDispatch(data.task_id ?? "", data.source_id ?? data.task_id ?? "", {
+            allowCreator: true,
+            dispatchEventId
+          }), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`task update dispatch failed for ${data.task_id}: ${String(err)}`);
         }
@@ -29863,11 +30522,10 @@ var ParallAgentGateway = class {
         if (!data.source_id)
           return;
         try {
-          const dispatched = await this.fetchAndHandleScheduleFire(data.source_id, data.actor_id);
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.fetchAndHandleScheduleFire(data.source_id, data.actor_id), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`schedule fire dispatch failed for ${data.source_id}: ${String(err)}`);
         }
@@ -29875,26 +30533,41 @@ var ParallAgentGateway = class {
         if (!data.source_id)
           return;
         try {
-          const dispatched = await this.fetchAndHandleExternalTriggerRun(data.source_id);
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.fetchAndHandleExternalTriggerRun(data.source_id), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`external trigger dispatch failed for ${data.source_id}: ${String(err)}`);
         }
+      } else if (data.event_type === "channel_message") {
+        if (!data.source_id)
+          return;
+        try {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.fetchAndHandleChannelMessage(data.source_id), () => {
+            this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
+            });
+          });
+        } catch (err) {
+          this.opts.log?.error(`channel message dispatch failed for ${data.source_id}: ${String(err)}`);
+        }
       } else if (data.event_type === "approval_decided") {
         if (!data.source_id)
           return;
         try {
-          const dispatched = await this.fetchAndHandleApprovalDecided(data.source_id, data.actor_id, data.chat_id ?? null);
-          if (dispatched) {
+          await this.consumeTypedDispatch({ dispatchEventId: data.id }, () => this.fetchAndHandleApprovalDecided(data.source_id, data.actor_id, data.chat_id ?? null), () => {
             this.opts.client.ackDispatchByID(this.opts.config.org_id, data.id).catch(() => {
             });
-          }
+          });
         } catch (err) {
           this.opts.log?.error(`approval decided dispatch failed for ${data.source_id}: ${String(err)}`);
         }
+      } else if (data.event_type === "message" && this.laneLedger && data.source_id && data.chat_id) {
+        try {
+          await this.handleMessageRedrive(data);
+        } catch (err) {
+          this.opts.log?.error(`message re-drive failed for ${data.source_id}: ${String(err)}`);
+        }
       } else if (data.event_type !== "message" && data.event_type !== "task_assign") {
         this.opts.log?.info(`dispatch.new with unhandled event_type=${String(data.event_type)} (id=${data.id}) \u2014 no-op`);
       }
@@ -29930,6 +30603,39 @@ var ParallAgentGateway = class {
       source_id: sourceId
     });
   }
+  /** True when this event's lifecycle is owned by the dispatch lane ledger. */
+  usesLaneLedger(event) {
+    return this.laneLedger != null && !this.ledgerDisabled && this.laneLedger.handles(event);
+  }
+  disableLedger(reason) {
+    if (this.ledgerDisabled)
+      return;
+    this.ledgerDisabled = true;
+    this.opts.log?.warn(`dispatch ledger unavailable (${reason}) \u2014 falling back to legacy received/ack flow`);
+  }
+  /**
+   * Buffer grouping key. Lane-ledger message events group by full lane
+   * identity (chat + thread) so a channel lane and a thread lane in the same
+   * chat dispatch as separate turns with separate claims; everything else
+   * keeps the historical chat-level grouping.
+   */
+  dispatchGroupKey(event) {
+    if (this.usesLaneLedger(event)) {
+      return this.laneLedger.laneKeyFor(event);
+    }
+    return event.targetId;
+  }
+  // Lane-flow protocols live in gateway-lane-flow.ts; these thin delegates
+  // keep call sites and tests on the class surface.
+  laneFlowHost() {
+    return this;
+  }
+  dispatchLaneGroup(opts) {
+    return dispatchLaneGroup(this.laneFlowHost(), opts);
+  }
+  consumeTypedDispatch(ref, run, ack) {
+    return consumeTypedDispatch(this.laneFlowHost(), ref, run, ack);
+  }
   buildDispatchContext(event, sessionKey) {
     const binding = this.sessionBindings.get(sessionKey);
     return {
@@ -29946,6 +30652,7 @@ var ParallAgentGateway = class {
       noReply: event.noReply ?? false,
       contextFilePath: this.opts.contextFilePathForSession?.(sessionKey),
       stepIdFilePath: this.opts.stepIdFilePathForSession?.(sessionKey),
+      contextDirPath: this.opts.dispatchContextDir,
       client: this.opts.client,
       log: this.opts.log
     };
@@ -29961,12 +30668,17 @@ var ParallAgentGateway = class {
         target_type: target.target_type,
         target_id: target.target_id,
         content: {
-          trigger_type: event.type === "task" ? "task_assign" : event.type === "task_comment" ? "task_comment" : event.type === "wiki_comment" ? "wiki_comment" : event.type === "schedule" ? "schedule_fire" : event.type === "external_trigger" ? "external_trigger" : event.type === "approval" ? "approval_decided" : "mention",
+          trigger_type: event.type === "task" ? "task_assign" : event.type === "task_comment" ? "task_comment" : event.type === "wiki_comment" ? "wiki_comment" : event.type === "schedule" ? "schedule_fire" : event.type === "external_trigger" ? "external_trigger" : event.type === "channel_message" ? "channel_message" : event.type === "approval" ? "approval_decided" : "mention",
           trigger_ref: event.type === "task" ? { task_id: event.targetId } : event.type === "task_comment" ? { comment_id: event.messageId, task_id: event.targetId } : event.type === "wiki_comment" ? { comment_id: event.messageId, target_uri: event.replyTargetUri } : event.type === "schedule" ? { schedule_id: event.targetId, run_id: event.messageId } : event.type === "external_trigger" ? {
             trigger_id: event.targetId,
             run_id: event.messageId,
             connection_id: event.externalConnectionId,
             ingress_event_id: event.externalIngressEventId
+          } : event.type === "channel_message" ? {
+            conversation_id: event.targetId,
+            channel_message_id: event.messageId,
+            provider: event.channelProvider,
+            external_conversation_id: event.channelExternalConversationId
           } : event.type === "approval" ? { approval_id: event.messageId } : { message_id: event.messageId },
           sender_id: event.senderId,
           sender_name: event.senderName,
@@ -29980,7 +30692,7 @@ var ParallAgentGateway = class {
       this.opts.log?.warn(`failed to create input step: ${String(err)}`);
     }
   }
-  async createRuntimeStep(sessionId, event, runtimeEvent, stepIdFilePath, contextFilePath) {
+  async createRuntimeStep(sessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2) {
     const target = resolveStepTarget(event);
     try {
       switch (runtimeEvent.type) {
@@ -30026,6 +30738,9 @@ var ParallAgentGateway = class {
           } else if (stepIdFilePath) {
             this.writeStepIdFile(stepIdFilePath, step.id);
           }
+          if (laneContextFilePath2) {
+            this.updateContextFileStepId(laneContextFilePath2, step.id);
+          }
           break;
         }
         case "tool_result":
@@ -30048,6 +30763,9 @@ var ParallAgentGateway = class {
           } else if (stepIdFilePath) {
             this.clearStepIdFile(stepIdFilePath);
           }
+          if (laneContextFilePath2) {
+            this.updateContextFileStepId(laneContextFilePath2, null);
+          }
           break;
         case "error":
           await this.opts.client.createAgentStep(this.opts.config.org_id, this.opts.agentUserId, sessionId, {
@@ -30067,28 +30785,28 @@ var ParallAgentGateway = class {
   }
   writeContextFile(filePath, ctx) {
     try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      fs.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
+      fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+      fs2.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
     } catch (err) {
       this.opts.log?.warn(`failed to write context file ${filePath}: ${String(err)}`);
     }
   }
   updateContextFileStepId(filePath, stepId) {
     try {
-      const raw = fs.readFileSync(filePath, "utf8");
+      const raw = fs2.readFileSync(filePath, "utf8");
       const ctx = JSON.parse(raw);
       ctx.step_id = stepId;
-      fs.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
+      fs2.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
     } catch (err) {
       this.opts.log?.warn(`failed to update context file step_id ${filePath}: ${String(err)}`);
     }
   }
   updateContextFileSessionId(filePath, sessionId) {
     try {
-      const raw = fs.readFileSync(filePath, "utf8");
+      const raw = fs2.readFileSync(filePath, "utf8");
       const ctx = JSON.parse(raw);
       ctx.session_id = sessionId;
-      fs.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
+      fs2.writeFileSync(filePath, JSON.stringify(ctx), "utf8");
     } catch (err) {
       this.opts.log?.warn(`failed to update context file session_id ${filePath}: ${String(err)}`);
     }
@@ -30096,8 +30814,8 @@ var ParallAgentGateway = class {
   /** @deprecated Use writeContextFile / updateContextFileStepId. */
   writeStepIdFile(filePath, stepId) {
     try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      fs.writeFileSync(filePath, stepId, "utf8");
+      fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+      fs2.writeFileSync(filePath, stepId, "utf8");
     } catch (err) {
       this.opts.log?.warn(`failed to write step id file ${filePath}: ${String(err)}`);
     }
@@ -30105,7 +30823,7 @@ var ParallAgentGateway = class {
   /** @deprecated Use writeContextFile / updateContextFileStepId. */
   clearStepIdFile(filePath) {
     try {
-      fs.writeFileSync(filePath, "", "utf8");
+      fs2.writeFileSync(filePath, "", "utf8");
     } catch {
     }
   }
@@ -30114,7 +30832,7 @@ var ParallAgentGateway = class {
       await this.createInputStep(sessionId, event);
     }
   }
-  async bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath) {
+  async bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2) {
     const runtimeLaneKey = runtimeEvent.runtimeLaneKey || sessionKey;
     const existing = this.sessionBindings.get(sessionKey);
     if (existing && existing.runtimeLaneKey === runtimeLaneKey && existing.runtimeSessionId === runtimeEvent.runtimeSessionId) {
@@ -30158,6 +30876,9 @@ var ParallAgentGateway = class {
     if (contextFilePath) {
       this.updateContextFileSessionId(contextFilePath, session.id);
     }
+    if (laneContextFilePath2) {
+      this.updateContextFileSessionId(laneContextFilePath2, session.id);
+    }
     await this.opts.onSessionBinding?.(binding);
     return binding;
   }
@@ -30184,14 +30905,27 @@ var ParallAgentGateway = class {
       const dispatchContext = this.buildDispatchContext(event, sessionKey);
       const contextFilePath = dispatchContext.contextFilePath;
       const stepIdFilePath = dispatchContext.stepIdFilePath;
+      const activeLane = this.ledgerDisabled ? void 0 : this.laneLedger?.getForEvent(event);
+      const laneContextFilePath2 = activeLane ? this.laneLedger?.laneContextPath(activeLane) : void 0;
+      const contextBody = {
+        session_id: dispatchContext.sessionId ?? null,
+        chat_id: dispatchContext.chatId ?? null,
+        trigger_message_id: dispatchContext.triggerMessageId ?? null,
+        no_reply: dispatchContext.noReply,
+        step_id: null,
+        dispatch_event_id: activeLane?.typedDispatchEventId ?? activeLane?.folded.get(event.messageId) ?? null,
+        lane: activeLane?.lane ?? null,
+        target_uri: activeLane?.targetUri ?? null,
+        thread_root_id: activeLane?.threadRootId ?? null,
+        // Typed binding hint for the CLI: which task this dispatch is about
+        // (parall task update attaches the typed effect only on a match).
+        task_id: event.type === "task" ? event.targetId : null
+      };
       if (contextFilePath) {
-        this.writeContextFile(contextFilePath, {
-          session_id: dispatchContext.sessionId ?? null,
-          chat_id: dispatchContext.chatId ?? null,
-          trigger_message_id: dispatchContext.triggerMessageId ?? null,
-          no_reply: dispatchContext.noReply,
-          step_id: null
-        });
+        this.writeContextFile(contextFilePath, contextBody);
+      }
+      if (laneContextFilePath2) {
+        this.writeContextFile(laneContextFilePath2, contextBody);
       }
       this.inFlightDispatches++;
       const deadlineTimer = this.DISPATCH_DEADLINE_MS > 0 ? setTimeout(() => {
@@ -30217,7 +30951,15 @@ var ParallAgentGateway = class {
           context: dispatchContext
         })) {
           if (runtimeEvent.type === "runtime_session") {
-            binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath);
+            const priorAgentSessionId = binding?.agentSessionId;
+            binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2);
+            if (event.targetType === "channel_conversation" && binding.agentSessionId !== priorAgentSessionId) {
+              try {
+                await this.opts.client.setChannelConversationSession(this.opts.config.org_id, event.targetId, binding.agentSessionId);
+              } catch (err) {
+                this.opts.log?.warn(`failed to record session mapping for channel conversation ${event.targetId}: ${String(err)}`);
+              }
+            }
             if (!inputStepsCreated) {
               if (earlierEvents.length > 0) {
                 await this.createInputStepsForEarlierEvents(binding.agentSessionId, earlierEvents);
@@ -30242,6 +30984,9 @@ var ParallAgentGateway = class {
             await this.createInputStep(binding.agentSessionId, event);
             inputStepsCreated = true;
           }
+          if (activeLane && !this.ledgerDisabled) {
+            this.laneLedger?.maybeRenew(activeLane);
+          }
           if (captureText && runtimeEvent.type === "text" && runtimeEvent.text) {
             captureText.push(runtimeEvent.text);
           }
@@ -30258,7 +31003,7 @@ var ParallAgentGateway = class {
           } else if (runtimeEvent.type === "tool_result" && pendingSendCallIds.delete(runtimeEvent.callId)) {
             recordMessageSend(sessionKey, !runtimeEvent.error);
           }
-          await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath);
+          await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
         }
         if (!binding) {
           binding = this.sessionBindings.get(sessionKey);
@@ -30280,7 +31025,7 @@ var ParallAgentGateway = class {
             await this.createRuntimeStep(binding.agentSessionId, event, {
               type: "error",
               message: `Dispatch failed: ${String(err)}`
-            }, stepIdFilePath, contextFilePath);
+            }, stepIdFilePath, contextFilePath, laneContextFilePath2);
           } catch (stepErr) {
             if (this.isSessionNotLiveError(stepErr))
               staleDetected = true;
@@ -30323,6 +31068,9 @@ var ParallAgentGateway = class {
         } else if (stepIdFilePath) {
           this.clearStepIdFile(stepIdFilePath);
         }
+        if (laneContextFilePath2) {
+          this.updateContextFileStepId(laneContextFilePath2, null);
+        }
         this.inFlightDispatches--;
         if (this.inFlightDispatches === 0 && this.drainResolvers.length > 0) {
           const resolvers = this.drainResolvers.splice(0);
@@ -30380,13 +31128,39 @@ var ParallAgentGateway = class {
             item.resolve(false);
           break;
         }
-        const items = fork.queue.splice(0);
+        let items;
+        const head = fork.queue[0];
+        if (head && this.usesLaneLedger(head.event)) {
+          const headKey = this.dispatchGroupKey(head.event);
+          const splitAt = fork.queue.findIndex((it) => this.dispatchGroupKey(it.event) !== headKey);
+          items = splitAt === -1 ? fork.queue.splice(0) : fork.queue.splice(0, splitAt);
+        } else {
+          items = fork.queue.splice(0);
+        }
         const events = items.map((item) => item.event);
         const last = events[events.length - 1];
         const earlier = events.slice(0, -1);
         try {
           const batchText = [];
-          const dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
+          let dispatched;
+          if (this.usesLaneLedger(last)) {
+            const outcome = await this.dispatchLaneGroup({
+              events,
+              sessionKey: fork.fork.sessionKey,
+              body: buildForkScopePrefix(last) + buildEventBody(last),
+              earlier,
+              captureText: batchText,
+              hasMoreLocal: () => fork.queue.length > 0
+            });
+            if (outcome === "foreign") {
+              for (const item of items)
+                item.resolve(false);
+              break;
+            }
+            dispatched = outcome === "dispatched";
+          } else {
+            dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
+          }
           if (!dispatched) {
             for (const item of items) {
               item.resolve(false);
@@ -30489,9 +31263,9 @@ var ParallAgentGateway = class {
           this.opts.log?.info(`drainMainBuffer halted (shutting down) \u2014 ${this.dispatchState.mainBuffer.length} buffered, ${this.dispatchState.pendingForkResults.length} pending fork results left for catch-up`);
           break;
         }
-        const targetId = this.dispatchState.mainBuffer[0].targetId;
+        const groupKey = this.dispatchGroupKey(this.dispatchState.mainBuffer[0]);
         const events = [];
-        while (this.dispatchState.mainBuffer[0]?.targetId === targetId) {
+        while (this.dispatchState.mainBuffer[0] && this.dispatchGroupKey(this.dispatchState.mainBuffer[0]) === groupKey) {
           events.push(this.dispatchState.mainBuffer.shift());
         }
         const event = events[events.length - 1];
@@ -30500,7 +31274,36 @@ var ParallAgentGateway = class {
         const pendingFork = hasPendingInjections ? [] : this.dispatchState.pendingForkResults.splice(0);
         const forkPrefix = buildForkResultPrefix(pendingFork);
         this.dispatchState.mainCurrentTargetId = event.targetId;
+        this.mainCurrentGroupKey = groupKey;
         this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
+        if (this.usesLaneLedger(event)) {
+          let outcome;
+          try {
+            outcome = await this.dispatchLaneGroup({
+              events,
+              sessionKey: this.opts.runtimeKey,
+              body: forkPrefix + buildEventBody(event),
+              earlier,
+              hasMoreLocal: () => this.dispatchState.mainBuffer.some((e) => this.dispatchGroupKey(e) === groupKey)
+            });
+          } catch (err) {
+            this.opts.log?.error(`lane dispatch failed for ${event.messageId}: ${String(err)}`);
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            for (const ev of events)
+              this.dispatchedMessages.delete(ev.messageId);
+            continue;
+          }
+          if (outcome === "shutdown") {
+            this.dispatchState.mainBuffer.unshift(...events);
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            break;
+          }
+          if (outcome === "foreign") {
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            continue;
+          }
+          continue;
+        }
         try {
           await this.emitDispatchReceived(event);
         } catch (err) {
@@ -30529,6 +31332,7 @@ var ParallAgentGateway = class {
       this.draining = false;
       this.dispatchState.mainDispatching = false;
       this.dispatchState.mainCurrentTargetId = void 0;
+      this.mainCurrentGroupKey = void 0;
       this.dispatchState.mainPreDispatchBranchPoint = void 0;
       if (!this.shuttingDown && this.dispatchState.mainBuffer.length > 0) {
         setTimeout(() => {
@@ -30548,13 +31352,38 @@ var ParallAgentGateway = class {
         const forkPrefix = buildForkResultPrefix(pendingFork);
         this.dispatchState.mainDispatching = true;
         this.dispatchState.mainCurrentTargetId = event.targetId;
+        this.mainCurrentGroupKey = this.dispatchGroupKey(event);
         this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
+        if (this.usesLaneLedger(event)) {
+          let outcome = "shutdown";
+          try {
+            try {
+              outcome = await this.dispatchLaneGroup({
+                events: [event],
+                sessionKey: this.opts.runtimeKey,
+                body: forkPrefix + buildEventBody(event),
+                earlier: [],
+                hasMoreLocal: () => this.dispatchState.mainBuffer.some((e) => this.dispatchGroupKey(e) === this.dispatchGroupKey(event))
+              });
+            } catch (err) {
+              this.dispatchState.pendingForkResults.unshift(...pendingFork);
+              throw err;
+            }
+            if (outcome !== "dispatched") {
+              this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            }
+          } finally {
+            await this.drainMainBuffer();
+          }
+          return outcome === "dispatched";
+        }
         try {
           await this.emitDispatchReceived(event);
         } catch (err) {
           this.opts.log?.warn?.(`mark-received failed, leaving unacked for retry: ${String(err)}`);
           this.dispatchState.mainDispatching = false;
           this.dispatchState.mainCurrentTargetId = void 0;
+          this.mainCurrentGroupKey = void 0;
           this.dispatchState.mainPreDispatchBranchPoint = void 0;
           this.dispatchState.pendingForkResults.unshift(...pendingFork);
           return false;
@@ -30575,7 +31404,11 @@ var ParallAgentGateway = class {
           return false;
         }
         this.dispatchState.mainBuffer.push(event);
-        if (this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(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))) {
+            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))) {
           this.opts.log?.info(`steer injected for ${event.messageId} (will drain for bookkeeping)`);
         }
         if (!this.dispatchState.mainDispatching && !this.draining && this.dispatchState.mainBuffer.length > 0) {
@@ -30746,8 +31579,10 @@ var ParallAgentGateway = class {
     try {
       const dispatched = await this.handleInboundEvent(event);
       if (dispatched) {
-        this.opts.client.ackDispatch(this.opts.config.org_id, { source_type: "message", source_id: data.id }).catch(() => {
-        });
+        if (!this.usesLaneLedger(event)) {
+          this.opts.client.ackDispatch(this.opts.config.org_id, { source_type: "message", source_id: data.id }).catch(() => {
+          });
+        }
       } else {
         this.dispatchedMessages.delete(data.id);
       }
@@ -30756,7 +31591,21 @@ var ParallAgentGateway = class {
       this.dispatchedMessages.delete(data.id);
     }
   }
-  async handleTaskAssignment(task, ackSourceId) {
+  // Ledger re-drive consumption: dispatch.new message hints re-enter the
+  // shared WorkItem consumption path (same protocol as catch-up).
+  async handleMessageRedrive(item) {
+    if (!item.chat_id || !item.source_id)
+      return;
+    await this.consumeMessageWorkItem({
+      id: item.id,
+      source_id: item.source_id,
+      chat_id: item.chat_id
+    });
+  }
+  consumeMessageWorkItem(item) {
+    return consumeMessageWorkItem(this.laneFlowHost(), item);
+  }
+  async handleTaskAssignment(task, ackSourceId, dispatchEventId) {
     if (this.shuttingDown)
       return false;
     const dedupeKey = `${task.id}:${task.updated_at}`;
@@ -30785,7 +31634,8 @@ var ParallAgentGateway = class {
       body: parts.join("\n"),
       sentAt: task.updated_at ?? task.created_at,
       ackSourceType: "task_activity",
-      ackSourceId
+      ackSourceId,
+      dispatchEventId
     };
     const dispatched = await this.handleInboundEvent(event);
     if (!dispatched) {
@@ -30809,7 +31659,7 @@ var ParallAgentGateway = class {
       this.opts.log?.info(`skipping stale task dispatch ${ackSourceId ?? taskId} \u2014 assigned to ${task.assignee_id}, creator ${task.creator_id}`);
       return true;
     }
-    return this.handleTaskAssignment(task, ackSourceId);
+    return this.handleTaskAssignment(task, ackSourceId, opts.dispatchEventId);
   }
   async handleTaskComment(commentId, taskId, actorId, deliveryReason) {
     if (this.shuttingDown)
@@ -31020,6 +31870,75 @@ var ParallAgentGateway = class {
       return true;
     return this.handleExternalTriggerRun(run);
   }
+  // fetchAndHandleChannelMessage resolves a channel_message dispatch to its
+  // durable ChannelMessage + conversation and hands it to the inbound
+  // pipeline. targetId = the ChannelConversation id, so per-conversation
+  // multi-turn continuity rides the same per-target session mechanics as
+  // chats. Design: docs/engineering-design/external-im-channel-design.md.
+  async fetchAndHandleChannelMessage(messageId) {
+    if (this.shuttingDown)
+      return false;
+    const claimKey = `channel_message:${messageId}`;
+    if (!this.tryClaimMessage(claimKey))
+      return false;
+    let msg = null;
+    let conv = null;
+    try {
+      msg = await this.opts.client.getChannelMessage(this.opts.config.org_id, messageId);
+      conv = await this.opts.client.getChannelConversation(this.opts.config.org_id, msg.conversation_id);
+    } catch (err) {
+      const status = err?.status;
+      if (status === 404) {
+        this.opts.log?.warn(`channel message ${messageId} not accessible (404), acking stale dispatch`);
+        return true;
+      }
+      this.dispatchedMessages.delete(claimKey);
+      this.opts.log?.warn(`channel message fetch failed for ${messageId}, leaving pending: ${String(err)}`);
+      return false;
+    }
+    if (!msg || !conv) {
+      return true;
+    }
+    this.opts.log?.info(`channel message: ${msg.id} (conversation ${conv.id})`);
+    let provider = this.channelConnectionProviders.get(conv.connection_id);
+    if (!provider) {
+      try {
+        const connection = await this.opts.client.getChannelConnection(this.opts.config.org_id, conv.connection_id);
+        provider = connection.provider;
+        this.channelConnectionProviders.set(conv.connection_id, provider);
+      } catch {
+        provider = void 0;
+      }
+    }
+    const event = {
+      type: "channel_message",
+      targetId: conv.id,
+      targetName: conv.external_user_name || conv.external_conversation_id,
+      targetType: "channel_conversation",
+      senderId: msg.external_user_id || "external",
+      senderName: msg.external_user_name || msg.external_user_id || "external user",
+      messageId: msg.id,
+      body: msg.text,
+      sentAt: msg.received_at,
+      channelProvider: provider,
+      channelConversationType: conv.conversation_type || void 0,
+      channelExternalConversationId: conv.external_conversation_id,
+      channelExternalMessageId: msg.external_message_id,
+      ackSourceType: "channel_message",
+      ackSourceId: msg.id
+    };
+    let dispatched;
+    try {
+      dispatched = await this.handleInboundEvent(event);
+    } catch (err) {
+      this.dispatchedMessages.delete(claimKey);
+      throw err;
+    }
+    if (!dispatched) {
+      this.dispatchedMessages.delete(claimKey);
+    }
+    return dispatched;
+  }
   async handleExternalTriggerRun(run) {
     if (this.shuttingDown)
       return false;
@@ -31148,72 +32067,46 @@ var ParallAgentGateway = class {
         }
         processed++;
         try {
-          let dispatched = false;
+          const ackItem = () => {
+            this.opts.client.ackDispatchByID(this.opts.config.org_id, item.id).catch(() => {
+            });
+          };
           if (item.event_type === "task_assign" && item.task_id) {
             try {
-              dispatched = await this.handleTaskDispatch(item.task_id, item.source_id ?? item.task_id);
+              await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskDispatch(item.task_id ?? "", item.source_id ?? item.task_id ?? "", {
+                dispatchEventId
+              }), ackItem);
             } catch (err) {
               this.opts.log?.warn(`catch-up task fetch failed for ${item.task_id}, leaving pending: ${String(err)}`);
               continue;
             }
           } else if (item.event_type === "task_update" && item.task_id) {
             try {
-              dispatched = await this.handleTaskDispatch(item.task_id, item.source_id ?? item.task_id, { allowCreator: true });
+              await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskDispatch(item.task_id ?? "", item.source_id ?? item.task_id ?? "", {
+                allowCreator: true,
+                dispatchEventId
+              }), ackItem);
             } catch (err) {
               this.opts.log?.warn(`catch-up task fetch failed for ${item.task_id}, leaving pending: ${String(err)}`);
               continue;
             }
           } else if (item.event_type === "task_comment" && item.source_id && item.task_id) {
-            dispatched = await this.handleTaskComment(item.source_id, item.task_id, item.actor_id, item.delivery_reason);
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.handleTaskComment(item.source_id, item.task_id ?? "", item.actor_id, item.delivery_reason), ackItem);
           } else if (item.event_type === "wiki_comment" && item.source_id) {
-            dispatched = await this.handleWikiComment(item.source_id, item.actor_id, item.delivery_reason);
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.handleWikiComment(item.source_id, item.actor_id, item.delivery_reason), ackItem);
           } else if (item.event_type === "schedule.fire" && item.source_id) {
-            dispatched = await this.fetchAndHandleScheduleFire(item.source_id, item.actor_id);
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.fetchAndHandleScheduleFire(item.source_id, item.actor_id), ackItem);
           } else if (item.event_type === "external_trigger" && item.source_id) {
-            dispatched = await this.fetchAndHandleExternalTriggerRun(item.source_id);
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.fetchAndHandleExternalTriggerRun(item.source_id), ackItem);
+          } else if (item.event_type === "channel_message" && item.source_id) {
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.fetchAndHandleChannelMessage(item.source_id), ackItem);
           } else if (item.event_type === "approval_decided" && item.source_id) {
-            dispatched = await this.fetchAndHandleApprovalDecided(item.source_id, item.actor_id, item.chat_id ?? null);
+            await this.consumeTypedDispatch({ dispatchEventId: item.id }, () => this.fetchAndHandleApprovalDecided(item.source_id, item.actor_id, item.chat_id ?? null), ackItem);
           } else if (item.event_type === "message" && item.source_id && item.chat_id) {
-            if (!this.tryClaimMessage(item.source_id))
-              continue;
-            let msg = null;
-            let msgFetchFailed = false;
-            try {
-              msg = await this.opts.client.getMessage(item.source_id);
-            } catch (err) {
-              const status = err?.status;
-              if (status === 404) {
-                msg = null;
-              } else {
-                msgFetchFailed = true;
-                this.opts.log?.warn(`catch-up message fetch failed for ${item.source_id}, leaving pending: ${String(err)}`);
-              }
-            }
-            if (msgFetchFailed) {
-              this.dispatchedMessages.delete(item.source_id);
-              continue;
-            }
-            if (!msg || msg.sender_id === this.opts.agentUserId) {
-              this.dispatchedMessages.delete(item.source_id);
-              this.opts.client.ackDispatchByID(this.opts.config.org_id, item.id).catch(() => {
-              });
-              continue;
-            }
-            const decision = await this.buildMessageDispatchDecision(item.chat_id, msg);
-            if (decision.action === "retry") {
-              this.dispatchedMessages.delete(item.source_id);
-              continue;
-            }
-            if (decision.action === "skip") {
-              this.dispatchedMessages.delete(item.source_id);
-              this.opts.client.ackDispatchByID(this.opts.config.org_id, item.id).catch(() => {
-              });
-              continue;
-            }
-            dispatched = await this.handleInboundEvent(decision.event);
-          }
-          if (dispatched) {
-            this.opts.client.ackDispatchByID(this.opts.config.org_id, item.id).catch(() => {
+            await this.consumeMessageWorkItem({
+              id: item.id,
+              source_id: item.source_id,
+              chat_id: item.chat_id
             });
           }
         } catch (err) {
@@ -31279,6 +32172,14 @@ ${fullSummary}` : fullSummary;
         this.abortFork(targetId, "ws reconnect");
       }
     }
+    if (this.laneLedger && this.inFlightDispatches === 0 && this.laneLedger.activeCount > 0) {
+      log2?.info(`releasing ${this.laneLedger.activeCount} stale lane(s) on reconnect`);
+      await this.laneLedger.releaseAll();
+    }
+    if (this.laneLedger && this.ledgerDisabled) {
+      log2?.info("re-probing dispatch ledger after reconnect (was disabled)");
+      this.ledgerDisabled = false;
+    }
     const intervalSec = data.heartbeat_interval > 0 ? data.heartbeat_interval : 30;
     try {
       const count = await fetchAllChats(client, config.org_id, this.chatInfoMap);
@@ -31349,6 +32250,10 @@ ${fullSummary}` : fullSummary;
     }
     if (this.heartbeatTimer)
       clearInterval(this.heartbeatTimer);
+    if (this.laneLedger && this.laneLedger.activeCount > 0) {
+      this.opts.log?.info(`releasing ${this.laneLedger.activeCount} lane(s) on shutdown`);
+      await this.laneLedger.releaseAll();
+    }
     await this.opts.onBeforeDisconnect?.();
     this.opts.ws.disconnect();
     this.opts.log?.info(`disconnected`);
@@ -31356,8 +32261,8 @@ ${fullSummary}` : fullSummary;
 };
 
 // ts/agent-core/dist/platform-config.js
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 function isPlatformManagedProfile(profile) {
   return profile?.machine_id != null || profile?.model_management === "platform";
 }
@@ -31368,14 +32273,17 @@ function resolveRuntimeModel(isOperatorOverride, platformModel, configModel) {
   const operatorOverride = isOperatorOverride ? platformModel : null;
   return operatorOverride ?? configModel ?? platformModel ?? void 0;
 }
+function deriveModelIsPin(defaults, profile) {
+  return defaults.modelIsPin !== void 0 ? defaults.modelIsPin : isPlatformModelOverride(profile);
+}
 var CACHE_FILENAME = "parall-platform-config.json";
 var SUPPORTED_SCHEMA_VERSION = 1;
 function cachePath(stateDir) {
-  return path2.join(stateDir, CACHE_FILENAME);
+  return path3.join(stateDir, CACHE_FILENAME);
 }
 function loadCache(stateDir) {
   try {
-    const raw = fs2.readFileSync(cachePath(stateDir), "utf-8");
+    const raw = fs3.readFileSync(cachePath(stateDir), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -31385,33 +32293,38 @@ function saveCache(stateDir, response) {
   const cached = {
     version: response.version,
     config: response.config,
+    modelIsPin: response.model_is_pin,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const filePath = cachePath(stateDir);
   const tmpPath = `${filePath}.tmp`;
-  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
-  fs2.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
-  fs2.renameSync(tmpPath, filePath);
+  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs3.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
+  fs3.renameSync(tmpPath, filePath);
 }
 function runtimeModelName(canonicalModel, runtimeType, config) {
   const runtime = runtimeType?.trim();
-  if (!runtime || runtime === "openclaw")
+  if (!runtime || runtime === "openclaw" || runtime === "hermes")
     return canonicalModel;
   const models = config.models ?? {};
   const providers = models.providers ?? {};
   const parall = providers.parall ?? {};
   const catalog = Array.isArray(parall.models) ? parall.models : [];
   const match = catalog.find((model) => model.id === canonicalModel);
-  const runtimeNames = match?.runtime_names ?? {};
+  if (!match)
+    return null;
+  const runtimeNames = match.runtime_names ?? {};
   const runtimeName = runtimeNames[runtime];
-  return typeof runtimeName === "string" && runtimeName ? runtimeName : null;
+  if (typeof runtimeName === "string" && runtimeName)
+    return runtimeName;
+  return canonicalModel;
 }
 function extractDefaults(config, runtimeType) {
   const agents = config.agents ?? {};
   const defaults = agents.defaults ?? {};
   let model = null;
   if (typeof defaults.model === "string" && defaults.model) {
-    const canonicalModel = defaults.model.replace(/^parall\//, "");
+    const canonicalModel = defaults.model.replace(/^parall-anthropic\//, "").replace(/^parall\//, "");
     model = runtimeModelName(canonicalModel, runtimeType, config);
   }
   let thinkingEffort = null;
@@ -31423,13 +32336,20 @@ function extractDefaults(config, runtimeType) {
 function createPlatformConfigManager(opts) {
   const { client, stateDir, runtimeType, log: log2 } = opts;
   let cachedVersion;
-  let currentDefaults = { model: null, thinkingEffort: null };
+  let currentDefaults = {
+    model: null,
+    thinkingEffort: null,
+    modelIsPin: void 0
+  };
   let currentRawConfig = null;
   const cached = loadCache(stateDir);
   if (cached) {
-    cachedVersion = cached.version;
+    cachedVersion = cached.modelIsPin === void 0 ? void 0 : cached.version;
     currentRawConfig = cached.config;
-    currentDefaults = extractDefaults(cached.config, runtimeType);
+    currentDefaults = {
+      ...extractDefaults(cached.config, runtimeType),
+      modelIsPin: cached.modelIsPin
+    };
   }
   return {
     async fetch() {
@@ -31455,7 +32375,10 @@ function createPlatformConfigManager(opts) {
       saveCache(stateDir, fresh);
       cachedVersion = fresh.version;
       currentRawConfig = fresh.config;
-      currentDefaults = extractDefaults(fresh.config, runtimeType);
+      currentDefaults = {
+        ...extractDefaults(fresh.config, runtimeType),
+        modelIsPin: fresh.model_is_pin
+      };
       return currentDefaults;
     },
     current() {
@@ -31468,8 +32391,8 @@ function createPlatformConfigManager(opts) {
 }
 
 // ts/agent-core/dist/skills/index.js
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 
 // ts/agent-core/dist/skills/parall-platform.js
 var PARALL_PLATFORM_SKILL = `# Parall Platform
@@ -31572,16 +32495,35 @@ original discussion and its approval/rejection IS the precedent.
 
 Each \`[Event: message.new]\` includes \`[Chat: ... (prll://cht_xxx)]\` \u2014 use that chat URI to reply.
 
+> **How you pass the message body matters \u2014 your command runs through a shell.**
+> Inside double quotes the shell expands \`$\`, backticks, and \`$(...)\` *before*
+> the CLI sees them: \`--text "That costs $1,000"\` sends \`That costs ,000\`, and
+> \`--text "$(cmd)"\` runs \`cmd\`. Single quotes instead break on apostrophes
+> (\`I'm\`, \`don't\`). So do **not** wrap real message content in quotes \u2014 pass it
+> through \`--text-file\` (a written file, or a quoted heredoc \`<<'EOF'\` that
+> disables all expansion). Reserve \`--text "..."\` for short literals with no
+> \`$\`, backtick, or apostrophe.
+
 \`\`\`bash
-# Reply to a chat (use the chat URI from the event)
-parall messages send prll://cht_xxx --text "Your reply"
+# One-off reply \u2192 quoted heredoc into stdin. The quoted delimiter <<'EOF'
+# disables ALL shell expansion, so $, backticks and apostrophes pass verbatim.
+parall messages send prll://cht_xxx --text-file - <<'PARALL_EOF'
+Sure \u2014 that's $1,000, and $(whoami) stays literal. I'm on it.
+PARALL_EOF
 
-# Direct message by user URI or display name
-parall dm prll://usr_xxx --text "Hello"
+# Longer / multi-line reply \u2192 write it with your file tool (no shell touches
+# the body), then point --text-file at the file.
+parall messages send prll://cht_xxx --text-file /tmp/reply.md
+
+# Short literal with no $, backtick, or apostrophe \u2192 --text is fine.
+parall messages send prll://cht_xxx --text "On it"
+
+# Direct message by user URI or display name (same --text-file / heredoc rules)
+parall dm prll://usr_xxx --text-file /tmp/reply.md
 parall dm "Alice" --text "Hello"
 
 # Thread reply
-parall messages send prll://cht_xxx --text "Reply" --thread-root-id 01JWC...
+parall messages send prll://cht_xxx --text-file /tmp/reply.md --thread-root-id 01JWC...
 
 # FYI message (no response expected \u2014 the recipient sees \`[Hint: no_reply]\`)
 parall messages send prll://cht_xxx --text "FYI: done" --no-reply
@@ -31613,7 +32555,9 @@ parall messages send prll://cht_xxx --attachment att_xxx --text "See attached"
 parall dm "Alice" --file /tmp/report.pdf --text "Report attached"
 \`\`\`
 
-\`--file\` and \`--attachment\` are mutually exclusive. \`--text\` can be combined with either.
+\`--file\` and \`--attachment\` are mutually exclusive. A caption (\`--text\` for
+short literals, or \`--text-file\` for anything with \`$\`, backticks, or quotes)
+can be combined with either.
 
 ## Approvals
 
@@ -32221,13 +33165,13 @@ var SKILLS = [
   }
 ];
 function writeSkillFiles(targetDir) {
-  fs3.mkdirSync(targetDir, { recursive: true });
+  fs4.mkdirSync(targetDir, { recursive: true });
   for (const skill of SKILLS) {
-    fs3.writeFileSync(path3.join(targetDir, `${skill.name}.md`), skill.content, "utf8");
+    fs4.writeFileSync(path4.join(targetDir, `${skill.name}.md`), skill.content, "utf8");
   }
 }
 function buildSkillReferences(workspaceDir) {
-  const dir = path3.join(workspaceDir, ".parall", "skills");
+  const dir = path4.join(workspaceDir, ".parall", "skills");
   const lines = SKILLS.map((s) => `- ${s.description.split(":")[0]}: \`${dir}/${s.name}.md\``);
   return `## Platform Skills (read on demand)
 
@@ -32237,7 +33181,7 @@ ${lines.join("\n")}
 
 // ts/claude-agent/dist/config.js
 import * as os2 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 function requireEnv(env, name) {
   const value = env[name]?.trim();
   if (!value) {
@@ -32251,15 +33195,15 @@ function parseList(value) {
   return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
 }
 function resolvePath(value) {
-  return path4.isAbsolute(value) ? value : path4.resolve(process.cwd(), value);
+  return path5.isAbsolute(value) ? value : path5.resolve(process.cwd(), value);
 }
 function resolveClaudeAgentConfig(env = process.env) {
   const apiUrl = requireEnv(env, "PRLL_API_URL");
   const apiKey = requireEnv(env, "PRLL_API_KEY");
   const orgId = requireEnv(env, "PRLL_ORG_ID");
   const claudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os2.homedir());
-  const stateDir = resolvePath(env.PRLL_STATE_DIR?.trim() || path4.join(claudeHome, ".parall-agent"));
-  const workspaceDir = resolvePath(env.PRLL_WORKSPACE_DIR?.trim() || path4.join(stateDir, "workspace"));
+  const stateDir = resolvePath(env.PRLL_STATE_DIR?.trim() || path5.join(claudeHome, ".parall-agent"));
+  const workspaceDir = resolvePath(env.PRLL_WORKSPACE_DIR?.trim() || path5.join(stateDir, "workspace"));
   const additionalDirs = parseList(env.PRLL_CLAUDE_ADD_DIRS).map(resolvePath);
   return {
     apiUrl,
@@ -32294,20 +33238,23 @@ function buildClaudeRuntimeKey(agentUserId) {
 }
 function sessionStateFilePathForRuntime(stateDir, runtimeKey) {
   const fileName = Buffer.from(runtimeKey).toString("base64url");
-  return path4.join(stateDir, "sessions", `${fileName}.json`);
+  return path5.join(stateDir, "sessions", `${fileName}.json`);
 }
 function contextFilePathForSession(stateDir, sessionKey) {
   const fileName = Buffer.from(sessionKey).toString("base64url");
-  return path4.join(stateDir, "dispatch-context", `${fileName}.json`);
+  return path5.join(stateDir, "dispatch-context", `${fileName}.json`);
+}
+function dispatchContextDirPath(stateDir) {
+  return dispatchLaneContextDir(stateDir);
 }
 function stepIdFilePathForSession(stateDir, sessionKey) {
   const fileName = Buffer.from(sessionKey).toString("base64url");
-  return path4.join(stateDir, "step-ids", `${fileName}.txt`);
+  return path5.join(stateDir, "step-ids", `${fileName}.txt`);
 }
 
 // ts/claude-agent/dist/dispatch.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 { randomUUID } from "node:crypto";
 import { execSync as execSync2, spawn } from "node:child_process";
 
@@ -32315,8 +33262,8 @@ import { execSync as execSync2, spawn } from "node:child_process";
 import { execSync } from "node:child_process";
 import { constants } from "node:fs";
 import * as fsSync from "node:fs";
-import * as fs4 from "node:fs/promises";
-import * as path5 from "node:path";
+import * as fs5 from "node:fs/promises";
+import * as path6 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;
@@ -32346,11 +33293,11 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     };
   }
   const rootDir = await ensureAttachmentRootDir(opts.workspaceDir);
-  const messageDir = path5.join(rootDir, sanitizePathSegment(event.messageId));
+  const messageDir = path6.join(rootDir, sanitizePathSegment(event.messageId));
   await ensurePathIsNotSymlink(messageDir);
-  await fs4.mkdir(messageDir, { recursive: true });
+  await fs5.mkdir(messageDir, { recursive: true });
   await ensurePathIsNotSymlink(messageDir);
-  const activeMessageDir = path5.resolve(messageDir);
+  const activeMessageDir = path6.resolve(messageDir);
   activeAttachmentDirs.add(activeMessageDir);
   const maintenanceCooldownMs = opts.maintenanceCooldownMs ?? DEFAULT_MAINTENANCE_COOLDOWN_MS;
   const maintenancePromise = scheduleAttachmentMaintenance(rootDir, {
@@ -32367,7 +33314,7 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     const notes = [];
     let downloadedBytes = 0;
     for (const att of imageAttachments) {
-      const localPath = path5.join(messageDir, localFileName(att.id, att.fileName, att.mimeType));
+      const localPath = path6.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`);
@@ -32424,7 +33371,7 @@ async function appendPreparedLocalAttachmentRefs(body, event, context2, opts) {
   return { body: appendLocalAttachmentRefs(body, attachments), attachments };
 }
 function pinLocalAttachmentPaths(images) {
-  const dirs = new Set(images.map((image) => path5.resolve(path5.dirname(image.localPath))));
+  const dirs = new Set(images.map((image) => path6.resolve(path6.dirname(image.localPath))));
   for (const dir of dirs) {
     activeAttachmentDirs.add(dir);
   }
@@ -32439,7 +33386,7 @@ function pinLocalAttachmentPaths(images) {
   };
 }
 function attachmentRootDir(workspaceDir) {
-  return path5.join(path5.resolve(workspaceDir), ".parall", "attachments");
+  return path6.join(path6.resolve(workspaceDir), ".parall", "attachments");
 }
 function ensureLocalAttachmentGitExclude(workingDirectory) {
   try {
@@ -32448,8 +33395,8 @@ function ensureLocalAttachmentGitExclude(workingDirectory) {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const excludePath = path5.isAbsolute(rel) ? rel : path5.join(workingDirectory, rel);
-    fsSync.mkdirSync(path5.dirname(excludePath), { recursive: true });
+    const excludePath = path6.isAbsolute(rel) ? rel : path6.join(workingDirectory, rel);
+    fsSync.mkdirSync(path6.dirname(excludePath), { recursive: true });
     const existing = fsSync.existsSync(excludePath) ? fsSync.readFileSync(excludePath, "utf8") : "";
     if (existing.split(/\r?\n/).some((line) => line.trim() === ".parall/"))
       return;
@@ -32485,18 +33432,18 @@ function scheduleAttachmentMaintenance(rootDir, opts) {
   return run;
 }
 async function ensureAttachmentRootDir(workspaceDir) {
-  const workspaceRoot = path5.resolve(workspaceDir);
-  const parallDir = path5.join(workspaceRoot, ".parall");
+  const workspaceRoot = path6.resolve(workspaceDir);
+  const parallDir = path6.join(workspaceRoot, ".parall");
   const rootDir = attachmentRootDir(workspaceRoot);
-  await fs4.mkdir(workspaceRoot, { recursive: true });
+  await fs5.mkdir(workspaceRoot, { recursive: true });
   await ensurePathIsNotSymlink(parallDir);
-  await fs4.mkdir(parallDir, { recursive: true, mode: 448 });
+  await fs5.mkdir(parallDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(parallDir);
   await ensurePathIsNotSymlink(rootDir);
-  await fs4.mkdir(rootDir, { recursive: true, mode: 448 });
+  await fs5.mkdir(rootDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(rootDir);
-  const realWorkspace = await fs4.realpath(workspaceRoot);
-  const realRoot = await fs4.realpath(rootDir);
+  const realWorkspace = await fs5.realpath(workspaceRoot);
+  const realRoot = await fs5.realpath(rootDir);
   if (!isPathInside(realRoot, realWorkspace)) {
     throw new Error(`attachment root escapes workspace: ${rootDir}`);
   }
@@ -32504,7 +33451,7 @@ async function ensureAttachmentRootDir(workspaceDir) {
 }
 async function ensurePathIsNotSymlink(filePath) {
   try {
-    const stat = await fs4.lstat(filePath);
+    const stat = await fs5.lstat(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`refusing to use symlinked attachment path ${filePath}`);
     }
@@ -32515,8 +33462,8 @@ async function ensurePathIsNotSymlink(filePath) {
   }
 }
 function isPathInside(childPath, parentPath) {
-  const rel = path5.relative(parentPath, childPath);
-  return rel === "" || !!rel && !rel.startsWith("..") && !path5.isAbsolute(rel);
+  const rel = path6.relative(parentPath, childPath);
+  return rel === "" || !!rel && !rel.startsWith("..") && !path6.isAbsolute(rel);
 }
 async function existingUsableFile(filePath, expectedSize, rootDir) {
   try {
@@ -32527,30 +33474,30 @@ async function existingUsableFile(filePath, expectedSize, rootDir) {
   }
 }
 async function localFileStatInsideRoot(filePath, rootDir) {
-  const stat = await fs4.lstat(filePath);
+  const stat = await fs5.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 fs4.realpath(rootDir);
-  const realFile = await fs4.realpath(filePath);
+  const realRoot = await fs5.realpath(rootDir);
+  const realFile = await fs5.realpath(filePath);
   if (!isPathInside(realFile, realRoot)) {
     throw new Error(`attachment file escapes workspace: ${filePath}`);
   }
   return stat;
 }
 async function localDirectoryStatInsideRoot(dirPath, rootDir) {
-  const stat = await fs4.lstat(dirPath);
+  const stat = await fs5.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 fs4.realpath(rootDir);
-  const realDir = await fs4.realpath(dirPath);
+  const realRoot = await fs5.realpath(rootDir);
+  const realDir = await fs5.realpath(dirPath);
   if (!isPathInside(realDir, realRoot)) {
     throw new Error(`attachment directory escapes workspace: ${dirPath}`);
   }
@@ -32558,7 +33505,7 @@ async function localDirectoryStatInsideRoot(dirPath, rootDir) {
 }
 async function openLocalFileInsideRoot(filePath, rootDir) {
   const checkedStat = await localFileStatInsideRoot(filePath, rootDir);
-  const file = await fs4.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const file = await fs5.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
   let keepOpen = false;
   try {
     const openedStat = await file.stat();
@@ -32574,8 +33521,8 @@ async function openLocalFileInsideRoot(filePath, rootDir) {
   }
 }
 async function openLocalTempFileInsideRoot(filePath, rootDir) {
-  await localDirectoryStatInsideRoot(path5.dirname(filePath), rootDir);
-  const file = await fs4.open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  await localDirectoryStatInsideRoot(path6.dirname(filePath), rootDir);
+  const file = await fs5.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);
@@ -32600,7 +33547,7 @@ async function assertLocalFileIdentity(filePath, rootDir, expected) {
 async function removeLocalFileIfInside(filePath, rootDir) {
   try {
     await localFileStatInsideRoot(filePath, rootDir);
-    await fs4.rm(filePath, { force: true });
+    await fs5.rm(filePath, { force: true });
   } catch {
   }
 }
@@ -32613,7 +33560,7 @@ function sameFile(a, b) {
 async function cleanupOldAttachmentFiles(rootDir, ttlMs, log2, preserveDirs) {
   let entries;
   try {
-    entries = await fs4.readdir(rootDir, { withFileTypes: true });
+    entries = await fs5.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -32621,15 +33568,15 @@ async function cleanupOldAttachmentFiles(rootDir, ttlMs, log2, preserveDirs) {
   await Promise.all(entries.map(async (entry) => {
     if (!entry.isDirectory())
       return;
-    const fullPath = path5.join(rootDir, entry.name);
+    const fullPath = path6.join(rootDir, entry.name);
     try {
-      if (preserveDirs?.has(path5.resolve(fullPath)))
+      if (preserveDirs?.has(path6.resolve(fullPath)))
         return;
-      const stat = await fs4.lstat(fullPath);
+      const stat = await fs5.lstat(fullPath);
       if (!stat.isDirectory())
         return;
       if (stat.mtimeMs < cutoff) {
-        await fs4.rm(fullPath, { recursive: true, force: true });
+        await fs5.rm(fullPath, { recursive: true, force: true });
       }
     } catch (err) {
       log2?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
@@ -32641,7 +33588,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
     return;
   let entries;
   try {
-    entries = await fs4.readdir(rootDir, { withFileTypes: true });
+    entries = await fs5.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -32650,9 +33597,9 @@ async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const fullPath = path5.join(rootDir, entry.name);
+    const fullPath = path6.join(rootDir, entry.name);
     try {
-      const stat = await fs4.lstat(fullPath);
+      const stat = await fs5.lstat(fullPath);
       if (!stat.isDirectory())
         continue;
       const size = await directorySize(fullPath);
@@ -32668,10 +33615,10 @@ async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
   for (const dir of dirs) {
     if (total <= maxBytes)
       break;
-    if (preserveDirs?.has(path5.resolve(dir.path)))
+    if (preserveDirs?.has(path6.resolve(dir.path)))
       continue;
     try {
-      await fs4.rm(dir.path, { recursive: true, force: true });
+      await fs5.rm(dir.path, { recursive: true, force: true });
       total -= dir.size;
     } catch (err) {
       log2?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
@@ -32680,12 +33627,12 @@ async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
 }
 async function directorySize(dirPath) {
   let total = 0;
-  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs5.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path5.join(dirPath, entry.name);
+    const fullPath = path6.join(dirPath, entry.name);
     let stat;
     try {
-      stat = await fs4.lstat(fullPath);
+      stat = await fs5.lstat(fullPath);
     } catch {
       continue;
     }
@@ -32700,10 +33647,10 @@ async function directorySize(dirPath) {
   return total;
 }
 function activeDirsForRoot(rootDir) {
-  const root = path5.resolve(rootDir);
+  const root = path6.resolve(rootDir);
   const dirs = /* @__PURE__ */ new Set();
   for (const dir of activeAttachmentDirs) {
-    if (dir === root || dir.startsWith(`${root}${path5.sep}`)) {
+    if (dir === root || dir.startsWith(`${root}${path6.sep}`)) {
       dirs.add(dir);
     }
   }
@@ -32800,9 +33747,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
     }
     writtenStat = await file.stat();
     await closeFile();
-    await localDirectoryStatInsideRoot(path5.dirname(filePath), rootDir);
+    await localDirectoryStatInsideRoot(path6.dirname(filePath), rootDir);
     await assertLocalFileIdentity(tmpPath, rootDir, writtenStat);
-    await fs4.rename(tmpPath, filePath);
+    await fs5.rename(tmpPath, filePath);
     completed = true;
     return written;
   } finally {
@@ -32818,9 +33765,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
   }
 }
 function localFileName(attachmentId, fileName, mimeType) {
-  const safeName = sanitizePathSegment(path5.basename(fileName || attachmentId));
-  const ext = path5.extname(safeName) || extensionForMime(mimeType);
-  const stem = path5.basename(safeName, path5.extname(safeName)) || attachmentId;
+  const safeName = sanitizePathSegment(path6.basename(fileName || attachmentId));
+  const ext = path6.extname(safeName) || extensionForMime(mimeType);
+  const stem = path6.basename(safeName, path6.extname(safeName)) || attachmentId;
   return `${sanitizePathSegment(attachmentId)}-${stem}${ext}`;
 }
 function extensionForMime(mimeType) {
@@ -33100,7 +34047,11 @@ function buildSpawnEnv(parentEnv, claudeHome, context2, opts) {
     PRLL_TRIGGER_MESSAGE_ID: context2.triggerMessageId ?? "",
     PRLL_NO_REPLY: context2.noReply ? "1" : "",
     PRLL_CONTEXT_FILE: context2.contextFilePath ?? "",
-    PRLL_STEP_ID_FILE: context2.stepIdFilePath ?? ""
+    PRLL_STEP_ID_FILE: context2.stepIdFilePath ?? "",
+    // Per-lane dispatch context directory (stable for the bridge's lifetime,
+    // so pinning it at spawn is safe even for long-lived subprocesses). The
+    // CLI keys into it by send target to derive dispatch effect keys.
+    PRLL_CONTEXT_DIR: context2.contextDirPath ?? ""
   };
   if (!result.PRLL_WIKI_MOUNT_ROOT?.trim() && opts.wikiMountRoot) {
     result.PRLL_WIKI_MOUNT_ROOT = opts.wikiMountRoot;
@@ -33206,8 +34157,8 @@ var ClaudeCodeAdapter = class {
     if (!sessionId)
       return void 0;
     const projectSlug = this.opts.workspaceDir.replace(/[/.]/g, "-");
-    const filePath = path6.join(this.opts.claudeHome, ".claude", "projects", projectSlug, `${sessionId}.jsonl`);
-    return fs5.existsSync(filePath) ? filePath : void 0;
+    const filePath = path7.join(this.opts.claudeHome, ".claude", "projects", projectSlug, `${sessionId}.jsonl`);
+    return fs6.existsSync(filePath) ? filePath : void 0;
   }
   forkSession({ sessionKey }) {
     return this.opts.sessionManager.createForkSession(sessionKey);
@@ -33493,7 +34444,7 @@ var ClaudeCodeAdapter = class {
     if (this.opts.disallowedTools.length > 0) {
       args.push("--disallowedTools", this.opts.disallowedTools.join(","));
     }
-    args.push("--append-system-prompt-file", path6.join(this.opts.workspaceDir, ".parall", "system-prompt.md"));
+    args.push("--append-system-prompt-file", path7.join(this.opts.workspaceDir, ".parall", "system-prompt.md"));
     if (this.opts.appendSystemPrompt) {
       args.push("--append-system-prompt", this.opts.appendSystemPrompt);
     }
@@ -33518,14 +34469,15 @@ var ClaudeCodeAdapter = class {
       noReply: false,
       contextFilePath: this.opts.contextFilePathForSession?.(sessionKey) ?? "",
       stepIdFilePath: this.opts.stepIdFilePathForSession?.(sessionKey) ?? "",
+      contextDirPath: this.opts.contextDirPath ?? "",
       client: void 0
     };
   }
 };
 
 // ts/claude-agent/dist/session-manager.js
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs";
+import * as path8 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var ClaudeSessionManager = class _ClaudeSessionManager {
   mainSessionKey;
@@ -33674,13 +34626,13 @@ var ClaudeSessionManager = class _ClaudeSessionManager {
   clearMainSession() {
     this.sessionIds.delete(this.mainSessionKey);
     try {
-      fs6.unlinkSync(this.stateFilePath);
+      fs7.unlinkSync(this.stateFilePath);
     } catch {
     }
   }
   restore() {
     try {
-      const raw = fs6.readFileSync(this.stateFilePath, "utf8");
+      const raw = fs7.readFileSync(this.stateFilePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.runtimeKey === this.mainSessionKey && typeof parsed.sessionId === "string" && parsed.sessionId.trim()) {
         this.sessionIds.set(this.mainSessionKey, parsed.sessionId.trim());
@@ -33690,8 +34642,8 @@ var ClaudeSessionManager = class _ClaudeSessionManager {
   }
   persist(sessionId) {
     try {
-      fs6.mkdirSync(path7.dirname(this.stateFilePath), { recursive: true });
-      fs6.writeFileSync(this.stateFilePath, JSON.stringify({
+      fs7.mkdirSync(path8.dirname(this.stateFilePath), { recursive: true });
+      fs7.writeFileSync(this.stateFilePath, JSON.stringify({
         runtimeKey: this.mainSessionKey,
         sessionId
       }, null, 2));
@@ -33702,8 +34654,8 @@ var ClaudeSessionManager = class _ClaudeSessionManager {
 };
 
 // ts/claude-agent/dist/workspace.js
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs8 from "node:fs";
+import * as path9 from "node:path";
 function ensureClaudeWorkspace(workspaceDir, log2, agentIdentity) {
   const systemPrompt = [
     buildIdentity(agentIdentity),
@@ -33712,12 +34664,12 @@ function ensureClaudeWorkspace(workspaceDir, log2, agentIdentity) {
     PRLL_REFERENCE_GUIDE,
     buildSkillReferences(workspaceDir)
   ].join("\n\n");
-  fs7.mkdirSync(workspaceDir, { recursive: true });
-  fs7.mkdirSync(path8.join(workspaceDir, ".claude"), { recursive: true });
-  const parallDir = path8.join(workspaceDir, ".parall");
-  fs7.mkdirSync(parallDir, { recursive: true });
-  fs7.writeFileSync(path8.join(parallDir, "system-prompt.md"), systemPrompt, "utf8");
-  writeSkillFiles(path8.join(parallDir, "skills"));
+  fs8.mkdirSync(workspaceDir, { recursive: true });
+  fs8.mkdirSync(path9.join(workspaceDir, ".claude"), { recursive: true });
+  const parallDir = path9.join(workspaceDir, ".parall");
+  fs8.mkdirSync(parallDir, { recursive: true });
+  fs8.writeFileSync(path9.join(parallDir, "system-prompt.md"), systemPrompt, "utf8");
+  writeSkillFiles(path9.join(parallDir, "skills"));
   ensureLocalAttachmentGitExclude(workspaceDir);
 }
 
@@ -33792,14 +34744,13 @@ async function main() {
       log: agentLog
     });
     const platformDefaults = await configMgr.fetch();
-    let platformManaged = isPlatformManagedProfile(me.agent_profile);
-    let platformModelOverride = isPlatformModelOverride(me.agent_profile);
+    const platformModelOverride = deriveModelIsPin(platformDefaults, me.agent_profile);
     const resolvedModel = resolveRuntimeModel(platformModelOverride, platformDefaults.model, config.model);
-    const resolvedEffort = platformManaged ? platformDefaults.thinkingEffort ?? (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || void 0) : process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || void 0;
+    const resolvedEffort = platformDefaults.thinkingEffort ?? (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || void 0);
     if (platformDefaults.model)
-      agentLog.info(`platform config: model=${platformDefaults.model} \u2192 resolved=${resolvedModel ?? "cli-default"} (${platformModelOverride ? "platform-managed" : "floor/self"})`);
+      agentLog.info(`platform config: model=${platformDefaults.model} \u2192 resolved=${resolvedModel ?? "cli-default"} (${platformModelOverride ? "pin/override" : "floor"})`);
     if (platformDefaults.thinkingEffort)
-      agentLog.info(`platform config: thinking_effort=${platformDefaults.thinkingEffort} (${platformModelOverride ? "applied" : "ignored, model_management=self"})`);
+      agentLog.info(`platform config: thinking_effort=${platformDefaults.thinkingEffort}`);
     const adapter = new ClaudeCodeAdapter({
       claudeBin: config.claudeBin,
       claudeHome: config.claudeHome,
@@ -33819,11 +34770,29 @@ async function main() {
       apiKey: config.apiKey,
       orgId: config.orgId,
       contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
-      stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey)
+      stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
+      contextDirPath: dispatchContextDirPath(config.stateDir)
     });
     if (resolvedEffort) {
       adapter.updateConfig({ effort: resolvedEffort });
     }
+    const refreshPlatformConfig = async () => {
+      const updated = await configMgr.fetch();
+      let refreshedProfile;
+      if (updated.modelIsPin === void 0) {
+        try {
+          refreshedProfile = (await getAgentMeWithLegacyFallback(client, config.orgId)).agent_profile;
+        } catch (err) {
+          agentLog.warn(`platform config refresh: legacy /agents/me fallback failed: ${String(err)}`);
+        }
+      }
+      const isPin = deriveModelIsPin(updated, refreshedProfile);
+      const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
+      adapter.updateConfig({
+        model: resolveRuntimeModel(isPin, updated.model, config.model) ?? null,
+        effort: updated.thinkingEffort ?? localEffort
+      });
+    };
     const gateway = new ParallAgentGateway({
       accountId: agentUserId,
       client,
@@ -33850,28 +34819,9 @@ async function main() {
       dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
       contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
       stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
-      onConfigUpdate: async () => {
-        const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-        platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-        platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
-        const updated = await configMgr.fetch();
-        const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-        adapter.updateConfig({
-          model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
-          effort: platformManaged ? updated.thinkingEffort ?? localEffort : localEffort
-        });
-      },
-      onSessionReady: async () => {
-        const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-        platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-        platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
-        const updated = await configMgr.fetch();
-        const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-        adapter.updateConfig({
-          model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
-          effort: platformManaged ? updated.thinkingEffort ?? localEffort : localEffort
-        });
-      },
+      dispatchContextDir: dispatchContextDirPath(config.stateDir),
+      onConfigUpdate: refreshPlatformConfig,
+      onSessionReady: refreshPlatformConfig,
       // Long-lived `claude` subprocesses outlive a single dispatch, so the
       // gateway's shuttingDown flag alone does not tear them down. Piggyback on
       // onBeforeDisconnect to close stdin and SIGTERM any survivors after