@parall/parall 1.37.0 → 1.39.0

package/dist/index.bundle.mjs

@@ -17717,9 +17717,9 @@ var require_getMachineId_linux = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
-      for (const path7 of paths) {
+      for (const path8 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path7, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path8, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -21122,7 +21122,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path7) {
+function appendResourcePathToUrl(url, path8) {
   try {
     new URL(url);
   } catch (_a) {
@@ -21132,11 +21132,11 @@ function appendResourcePathToUrl(url, path7) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path7;
+  url += path8;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path7 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path8 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -26473,6 +26473,16 @@ function resolveParallAccount(params) {
   };
 }
 
+// ../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 laneContextFilePath(contextDir, targetUri, threadRootId) {
+  return path.join(contextDir, `${laneKeyForTarget(targetUri, threadRootId)}.json`);
+}
+
 // ../agent-core/dist/session-state.js
 function normalizeSessionKey(sessionKey) {
   return sessionKey.toLowerCase();
@@ -27021,8 +27031,8 @@ function isParallNoReplyCommand(command) {
 
 // ../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";
 
 // ../sdk/dist/types.js
 var MENTION_ALL_USER_ID = "all";
@@ -27297,6 +27307,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`,
@@ -27358,7 +27373,13 @@ var ENDPOINTS = {
   // the machine control-plane request/reply bridge that lives in api-server.
   BROWSER_PROFILE_VIEWER_COMMAND: (orgId, profileId) => `${API_BASE}/orgs/${orgId}/browser-profiles/${profileId}/viewer/command`,
   // Clip registry (global, served by clip-service → Pinix Hub proxy)
-  CLIP_REGISTRY: () => `${CLIP_BASE}/registry/clips`
+  CLIP_REGISTRY: () => `${CLIP_BASE}/registry/clips`,
+  // Edge device endpoints
+  ORG_EDGE_DEVICES: (orgId) => `/api/v1/orgs/${orgId}/edge/devices`,
+  ORG_EDGE_ONBOARDING: (orgId) => `/api/v1/orgs/${orgId}/edge/onboarding`,
+  ORG_EDGE_PROFILES: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
+  CLIP_CONNECTIONS: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/connections`,
+  CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`
 };
 var WS_EVENTS = {
   // Client -> Server
@@ -27417,6 +27438,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",
@@ -27512,8 +27534,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(path7) {
-    return path7.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+  baseUrlFor(path8) {
+    return path8.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
   }
   setToken(token) {
     this.token = token;
@@ -27540,10 +27562,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(path7) {
+  async ensureFreshToken(path8) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path7.replace(/^\/api\/v1/, "");
+    const pathSuffix = path8.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -27575,11 +27597,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path7, body, query, retried = false, opts) {
+  async request(method, path8, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path7);
+      await this.ensureFreshToken(path8);
     }
-    let url = `${this.baseUrlFor(path7)}${path7}`;
+    let url = `${this.baseUrlFor(path8)}${path8}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27609,12 +27631,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path7.replace(/^\/api\/v1/, "");
+      const pathSuffix = path8.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, path7, body, query, true, opts);
+          return this.request(method, path8, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27625,6 +27647,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) {
@@ -27643,15 +27666,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, path7, body, retried = false) {
+  async multipartRequest(method, path8, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path7);
+      await this.ensureFreshToken(path8);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrlFor(path7)}${path7}`, {
+      res = await fetch(`${this.baseUrlFor(path8)}${path8}`, {
         method,
         headers,
         body,
@@ -27661,12 +27684,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path7.replace(/^\/api\/v1/, "");
+      const pathSuffix = path8.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, path7, body, true);
+          return this.multipartRequest(method, path8, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27958,6 +27981,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);
   }
@@ -28345,8 +28383,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, path7) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path7 }, void 0, false, { timeoutMs: 15e3 });
+  async browseMachineFilesystem(orgId, machineId, path8) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path8 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -28419,6 +28457,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);
@@ -28883,8 +28945,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiRestriction(orgId, wikiId, restrictionId) {
     await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path7) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path7 ? { path: path7 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path8) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path8 ? { path: path8 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -28893,14 +28955,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, path7, params) {
+  async getWikiFileCommits(orgId, wikiId, path8, params) {
     return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-      path: path7,
+      path: path8,
       ...params
     });
   }
-  async getWikiBlame(orgId, wikiId, path7, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path7, ref });
+  async getWikiBlame(orgId, wikiId, path8, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path8, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -29146,6 +29208,26 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", url);
     return resp.data;
   }
+  // ---- Edge devices ----
+  async listEdgeDevices(orgId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
+  }
+  async getEdgeOnboarding(orgId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_ONBOARDING(orgId));
+  }
+  async listEdgeProfiles(orgId, edgeId) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
+  }
+  // ---- Clip connections ----
+  async listClipConnections(orgId, clipId) {
+    return this.request("GET", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId));
+  }
+  async createClipConnection(orgId, clipId, input) {
+    return this.request("POST", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId), input);
+  }
+  async deleteClipConnection(orgId, connId) {
+    return this.request("DELETE", ENDPOINTS.CLIP_CONNECTION(orgId, connId));
+  }
 };
 function normalizeWikiChangeset(changeset) {
   return {
@@ -29532,6 +29614,404 @@ var ParallWs = class {
   }
 };
 
+// ../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 {
+      }
+    }
+  }
+};
+
+// ../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;
+  }
+}
+
 // ../agent-core/dist/telemetry.js
 init_esm();
 var import_api_logs = __toESM(require_src(), 1);
@@ -29833,6 +30313,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
@@ -29842,6 +30330,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;
@@ -29911,14 +30407,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)}`);
       }
@@ -29928,11 +30428,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)}`);
         }
@@ -29940,11 +30439,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)}`);
         }
@@ -29952,11 +30450,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)}`);
         }
@@ -29964,11 +30464,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)}`);
         }
@@ -29976,11 +30475,10 @@ 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)}`);
         }
@@ -29988,11 +30486,10 @@ var ParallAgentGateway = class {
         if (!data.source_id)
           return;
         try {
-          const dispatched = await this.fetchAndHandleChannelMessage(data.source_id);
-          if (dispatched) {
+          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)}`);
         }
@@ -30000,14 +30497,19 @@ var ParallAgentGateway = class {
         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`);
       }
@@ -30043,6 +30545,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 {
@@ -30059,6 +30594,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
     };
@@ -30098,7 +30634,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) {
@@ -30144,6 +30680,9 @@ var ParallAgentGateway = class {
           } else if (stepIdFilePath) {
             this.writeStepIdFile(stepIdFilePath, step.id);
           }
+          if (laneContextFilePath2) {
+            this.updateContextFileStepId(laneContextFilePath2, step.id);
+          }
           break;
         }
         case "tool_result":
@@ -30166,6 +30705,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, {
@@ -30185,28 +30727,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)}`);
     }
@@ -30214,8 +30756,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)}`);
     }
@@ -30223,7 +30765,7 @@ var ParallAgentGateway = class {
   /** @deprecated Use writeContextFile / updateContextFileStepId. */
   clearStepIdFile(filePath) {
     try {
-      fs.writeFileSync(filePath, "", "utf8");
+      fs2.writeFileSync(filePath, "", "utf8");
     } catch {
     }
   }
@@ -30232,7 +30774,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) {
@@ -30276,6 +30818,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;
   }
@@ -30302,14 +30847,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(() => {
@@ -30336,7 +30894,7 @@ var ParallAgentGateway = class {
         })) {
           if (runtimeEvent.type === "runtime_session") {
             const priorAgentSessionId = binding?.agentSessionId;
-            binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath);
+            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);
@@ -30368,6 +30926,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);
           }
@@ -30384,7 +30945,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);
@@ -30406,7 +30967,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;
@@ -30449,6 +31010,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);
@@ -30506,13 +31070,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);
@@ -30615,9 +31205,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];
@@ -30626,7 +31216,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) {
@@ -30655,6 +31274,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(() => {
@@ -30674,13 +31294,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;
@@ -30701,7 +31346,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) {
@@ -30872,8 +31521,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);
       }
@@ -30882,7 +31533,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}`;
@@ -30911,7 +31576,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) {
@@ -30935,7 +31601,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)
@@ -31343,74 +32009,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) {
-            dispatched = await this.fetchAndHandleChannelMessage(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) {
@@ -31476,6 +32114,14 @@ ${fullSummary}` : fullSummary;
         this.abortFork(targetId, "ws reconnect");
       }
     }
+    if (this.laneLedger && this.inFlightDispatches === 0 && this.laneLedger.activeCount > 0) {
+      log?.info(`releasing ${this.laneLedger.activeCount} stale lane(s) on reconnect`);
+      await this.laneLedger.releaseAll();
+    }
+    if (this.laneLedger && this.ledgerDisabled) {
+      log?.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);
@@ -31546,6 +32192,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`);
@@ -31556,8 +32206,8 @@ ${fullSummary}` : fullSummary;
 import { execSync } from "node:child_process";
 import { constants } from "node:fs";
 import * as fsSync from "node:fs";
-import * as fs2 from "node:fs/promises";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs/promises";
+import * as path3 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;
@@ -31587,11 +32237,11 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     };
   }
   const rootDir = await ensureAttachmentRootDir(opts.workspaceDir);
-  const messageDir = path2.join(rootDir, sanitizePathSegment(event.messageId));
+  const messageDir = path3.join(rootDir, sanitizePathSegment(event.messageId));
   await ensurePathIsNotSymlink(messageDir);
-  await fs2.mkdir(messageDir, { recursive: true });
+  await fs3.mkdir(messageDir, { recursive: true });
   await ensurePathIsNotSymlink(messageDir);
-  const activeMessageDir = path2.resolve(messageDir);
+  const activeMessageDir = path3.resolve(messageDir);
   activeAttachmentDirs.add(activeMessageDir);
   const maintenanceCooldownMs = opts.maintenanceCooldownMs ?? DEFAULT_MAINTENANCE_COOLDOWN_MS;
   const maintenancePromise = scheduleAttachmentMaintenance(rootDir, {
@@ -31608,7 +32258,7 @@ async function prepareLocalImageAttachments(event, context2, opts) {
     const notes = [];
     let downloadedBytes = 0;
     for (const att of imageAttachments) {
-      const localPath = path2.join(messageDir, localFileName(att.id, att.fileName, att.mimeType));
+      const localPath = path3.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`);
@@ -31665,7 +32315,7 @@ async function appendPreparedLocalAttachmentRefs(body, event, context2, opts) {
   return { body: appendLocalAttachmentRefs(body, attachments), attachments };
 }
 function pinLocalAttachmentPaths(images) {
-  const dirs = new Set(images.map((image) => path2.resolve(path2.dirname(image.localPath))));
+  const dirs = new Set(images.map((image) => path3.resolve(path3.dirname(image.localPath))));
   for (const dir of dirs) {
     activeAttachmentDirs.add(dir);
   }
@@ -31680,7 +32330,7 @@ function pinLocalAttachmentPaths(images) {
   };
 }
 function attachmentRootDir(workspaceDir) {
-  return path2.join(path2.resolve(workspaceDir), ".parall", "attachments");
+  return path3.join(path3.resolve(workspaceDir), ".parall", "attachments");
 }
 function ensureLocalAttachmentGitExclude(workingDirectory) {
   try {
@@ -31689,8 +32339,8 @@ function ensureLocalAttachmentGitExclude(workingDirectory) {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const excludePath = path2.isAbsolute(rel) ? rel : path2.join(workingDirectory, rel);
-    fsSync.mkdirSync(path2.dirname(excludePath), { recursive: true });
+    const excludePath = path3.isAbsolute(rel) ? rel : path3.join(workingDirectory, rel);
+    fsSync.mkdirSync(path3.dirname(excludePath), { recursive: true });
     const existing = fsSync.existsSync(excludePath) ? fsSync.readFileSync(excludePath, "utf8") : "";
     if (existing.split(/\r?\n/).some((line) => line.trim() === ".parall/"))
       return;
@@ -31726,18 +32376,18 @@ function scheduleAttachmentMaintenance(rootDir, opts) {
   return run;
 }
 async function ensureAttachmentRootDir(workspaceDir) {
-  const workspaceRoot = path2.resolve(workspaceDir);
-  const parallDir = path2.join(workspaceRoot, ".parall");
+  const workspaceRoot = path3.resolve(workspaceDir);
+  const parallDir = path3.join(workspaceRoot, ".parall");
   const rootDir = attachmentRootDir(workspaceRoot);
-  await fs2.mkdir(workspaceRoot, { recursive: true });
+  await fs3.mkdir(workspaceRoot, { recursive: true });
   await ensurePathIsNotSymlink(parallDir);
-  await fs2.mkdir(parallDir, { recursive: true, mode: 448 });
+  await fs3.mkdir(parallDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(parallDir);
   await ensurePathIsNotSymlink(rootDir);
-  await fs2.mkdir(rootDir, { recursive: true, mode: 448 });
+  await fs3.mkdir(rootDir, { recursive: true, mode: 448 });
   await ensurePathIsNotSymlink(rootDir);
-  const realWorkspace = await fs2.realpath(workspaceRoot);
-  const realRoot = await fs2.realpath(rootDir);
+  const realWorkspace = await fs3.realpath(workspaceRoot);
+  const realRoot = await fs3.realpath(rootDir);
   if (!isPathInside(realRoot, realWorkspace)) {
     throw new Error(`attachment root escapes workspace: ${rootDir}`);
   }
@@ -31745,7 +32395,7 @@ async function ensureAttachmentRootDir(workspaceDir) {
 }
 async function ensurePathIsNotSymlink(filePath) {
   try {
-    const stat = await fs2.lstat(filePath);
+    const stat = await fs3.lstat(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`refusing to use symlinked attachment path ${filePath}`);
     }
@@ -31756,8 +32406,8 @@ async function ensurePathIsNotSymlink(filePath) {
   }
 }
 function isPathInside(childPath, parentPath) {
-  const rel = path2.relative(parentPath, childPath);
-  return rel === "" || !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  const rel = path3.relative(parentPath, childPath);
+  return rel === "" || !!rel && !rel.startsWith("..") && !path3.isAbsolute(rel);
 }
 async function existingUsableFile(filePath, expectedSize, rootDir) {
   try {
@@ -31768,30 +32418,30 @@ async function existingUsableFile(filePath, expectedSize, rootDir) {
   }
 }
 async function localFileStatInsideRoot(filePath, rootDir) {
-  const stat = await fs2.lstat(filePath);
+  const stat = await fs3.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 fs2.realpath(rootDir);
-  const realFile = await fs2.realpath(filePath);
+  const realRoot = await fs3.realpath(rootDir);
+  const realFile = await fs3.realpath(filePath);
   if (!isPathInside(realFile, realRoot)) {
     throw new Error(`attachment file escapes workspace: ${filePath}`);
   }
   return stat;
 }
 async function localDirectoryStatInsideRoot(dirPath, rootDir) {
-  const stat = await fs2.lstat(dirPath);
+  const stat = await fs3.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 fs2.realpath(rootDir);
-  const realDir = await fs2.realpath(dirPath);
+  const realRoot = await fs3.realpath(rootDir);
+  const realDir = await fs3.realpath(dirPath);
   if (!isPathInside(realDir, realRoot)) {
     throw new Error(`attachment directory escapes workspace: ${dirPath}`);
   }
@@ -31799,7 +32449,7 @@ async function localDirectoryStatInsideRoot(dirPath, rootDir) {
 }
 async function openLocalFileInsideRoot(filePath, rootDir) {
   const checkedStat = await localFileStatInsideRoot(filePath, rootDir);
-  const file = await fs2.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const file = await fs3.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
   let keepOpen = false;
   try {
     const openedStat = await file.stat();
@@ -31815,8 +32465,8 @@ async function openLocalFileInsideRoot(filePath, rootDir) {
   }
 }
 async function openLocalTempFileInsideRoot(filePath, rootDir) {
-  await localDirectoryStatInsideRoot(path2.dirname(filePath), rootDir);
-  const file = await fs2.open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  await localDirectoryStatInsideRoot(path3.dirname(filePath), rootDir);
+  const file = await fs3.open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
   let keepOpen = false;
   try {
     const checkedStat = await localFileStatInsideRoot(filePath, rootDir);
@@ -31841,7 +32491,7 @@ async function assertLocalFileIdentity(filePath, rootDir, expected) {
 async function removeLocalFileIfInside(filePath, rootDir) {
   try {
     await localFileStatInsideRoot(filePath, rootDir);
-    await fs2.rm(filePath, { force: true });
+    await fs3.rm(filePath, { force: true });
   } catch {
   }
 }
@@ -31854,7 +32504,7 @@ function sameFile(a, b) {
 async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
   let entries;
   try {
-    entries = await fs2.readdir(rootDir, { withFileTypes: true });
+    entries = await fs3.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -31862,15 +32512,15 @@ async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
   await Promise.all(entries.map(async (entry) => {
     if (!entry.isDirectory())
       return;
-    const fullPath = path2.join(rootDir, entry.name);
+    const fullPath = path3.join(rootDir, entry.name);
     try {
-      if (preserveDirs?.has(path2.resolve(fullPath)))
+      if (preserveDirs?.has(path3.resolve(fullPath)))
         return;
-      const stat = await fs2.lstat(fullPath);
+      const stat = await fs3.lstat(fullPath);
       if (!stat.isDirectory())
         return;
       if (stat.mtimeMs < cutoff) {
-        await fs2.rm(fullPath, { recursive: true, force: true });
+        await fs3.rm(fullPath, { recursive: true, force: true });
       }
     } catch (err) {
       log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
@@ -31882,7 +32532,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
     return;
   let entries;
   try {
-    entries = await fs2.readdir(rootDir, { withFileTypes: true });
+    entries = await fs3.readdir(rootDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -31891,9 +32541,9 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const fullPath = path2.join(rootDir, entry.name);
+    const fullPath = path3.join(rootDir, entry.name);
     try {
-      const stat = await fs2.lstat(fullPath);
+      const stat = await fs3.lstat(fullPath);
       if (!stat.isDirectory())
         continue;
       const size = await directorySize(fullPath);
@@ -31909,10 +32559,10 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
   for (const dir of dirs) {
     if (total <= maxBytes)
       break;
-    if (preserveDirs?.has(path2.resolve(dir.path)))
+    if (preserveDirs?.has(path3.resolve(dir.path)))
       continue;
     try {
-      await fs2.rm(dir.path, { recursive: true, force: true });
+      await fs3.rm(dir.path, { recursive: true, force: true });
       total -= dir.size;
     } catch (err) {
       log?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
@@ -31921,12 +32571,12 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
 }
 async function directorySize(dirPath) {
   let total = 0;
-  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path2.join(dirPath, entry.name);
+    const fullPath = path3.join(dirPath, entry.name);
     let stat;
     try {
-      stat = await fs2.lstat(fullPath);
+      stat = await fs3.lstat(fullPath);
     } catch {
       continue;
     }
@@ -31941,10 +32591,10 @@ async function directorySize(dirPath) {
   return total;
 }
 function activeDirsForRoot(rootDir) {
-  const root = path2.resolve(rootDir);
+  const root = path3.resolve(rootDir);
   const dirs = /* @__PURE__ */ new Set();
   for (const dir of activeAttachmentDirs) {
-    if (dir === root || dir.startsWith(`${root}${path2.sep}`)) {
+    if (dir === root || dir.startsWith(`${root}${path3.sep}`)) {
       dirs.add(dir);
     }
   }
@@ -32041,9 +32691,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
     }
     writtenStat = await file.stat();
     await closeFile();
-    await localDirectoryStatInsideRoot(path2.dirname(filePath), rootDir);
+    await localDirectoryStatInsideRoot(path3.dirname(filePath), rootDir);
     await assertLocalFileIdentity(tmpPath, rootDir, writtenStat);
-    await fs2.rename(tmpPath, filePath);
+    await fs3.rename(tmpPath, filePath);
     completed = true;
     return written;
   } finally {
@@ -32059,9 +32709,9 @@ async function writeResponseToFileWithLimit(res, filePath, maxBytes, rootDir) {
   }
 }
 function localFileName(attachmentId, fileName, mimeType) {
-  const safeName = sanitizePathSegment(path2.basename(fileName || attachmentId));
-  const ext = path2.extname(safeName) || extensionForMime(mimeType);
-  const stem = path2.basename(safeName, path2.extname(safeName)) || attachmentId;
+  const safeName = sanitizePathSegment(path3.basename(fileName || attachmentId));
+  const ext = path3.extname(safeName) || extensionForMime(mimeType);
+  const stem = path3.basename(safeName, path3.extname(safeName)) || attachmentId;
   return `${sanitizePathSegment(attachmentId)}-${stem}${ext}`;
 }
 function extensionForMime(mimeType) {
@@ -32127,7 +32777,7 @@ function parseContentLength(value) {
 // dist/gateway.js
 import * as crypto2 from "node:crypto";
 import * as os2 from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 
 // dist/runtime.js
 var runtime = null;
@@ -32185,15 +32835,15 @@ function buildOrchestratorSessionKey(accountId) {
 }
 
 // dist/config-manager.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";
 var CACHE_FILENAME = "parall-platform-config.json";
 function cachePath(stateDir) {
-  return path3.join(stateDir, CACHE_FILENAME);
+  return path4.join(stateDir, CACHE_FILENAME);
 }
 function loadCachedConfig(stateDir) {
   try {
-    const raw = fs3.readFileSync(cachePath(stateDir), "utf-8");
+    const raw = fs4.readFileSync(cachePath(stateDir), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -32207,14 +32857,14 @@ function saveCachedConfig(stateDir, config) {
   };
   const filePath = cachePath(stateDir);
   const tmpPath = `${filePath}.tmp`;
-  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
-  fs3.renameSync(tmpPath, filePath);
+  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
+  fs4.renameSync(tmpPath, filePath);
 }
 function applyToOpenClawConfig(configPath, platformConfig, credentials) {
   let existing = {};
   try {
-    const raw = fs3.readFileSync(configPath, "utf-8");
+    const raw = fs4.readFileSync(configPath, "utf-8");
     existing = JSON.parse(raw);
   } catch {
   }
@@ -32286,9 +32936,9 @@ function applyToOpenClawConfig(configPath, platformConfig, credentials) {
   agents.defaults = cleanedExisting;
   existing.agents = agents;
   const tmpPath = `${configPath}.tmp`;
-  fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
-  fs3.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
-  fs3.renameSync(tmpPath, configPath);
+  fs4.mkdirSync(path4.dirname(configPath), { recursive: true });
+  fs4.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
+  fs4.renameSync(tmpPath, configPath);
 }
 async function fetchAndApplyPlatformConfig(opts) {
   const { client, stateDir, configPath, credentials, log } = opts;
@@ -32327,7 +32977,7 @@ async function fetchAndApplyPlatformConfig(opts) {
 
 // dist/wiki-helper.js
 import { spawn, spawnSync } from "node:child_process";
-import path4 from "node:path";
+import path5 from "node:path";
 var DEFAULT_SYNC_TIMEOUT_MS = 9e4;
 var DEFAULT_WATCH_INTERVAL_SEC = 30;
 function isCommandMissing(error) {
@@ -32342,7 +32992,7 @@ function resolveParallCli() {
   return _cli;
 }
 function resolveMountRoot(stateDir) {
-  return process.env.PRLL_WIKI_MOUNT_ROOT?.trim() || path4.join(stateDir, "workspace");
+  return process.env.PRLL_WIKI_MOUNT_ROOT?.trim() || path5.join(stateDir, "workspace");
 }
 function resolveWatchIntervalSec() {
   const raw = process.env.PRLL_WIKI_REFRESH_INTERVAL_SEC?.trim();
@@ -32458,7 +33108,7 @@ async function startWikiHelper(params) {
 // dist/oc-session.js
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join3, resolve as resolve2 } from "node:path";
+import { join as join4, resolve as resolve2 } from "node:path";
 var CURRENT_SESSION_VERSION = 3;
 function generateId(existing) {
   for (let i = 0; i < 100; i++) {
@@ -32604,7 +33254,7 @@ var SessionManager = class _SessionManager {
     this.leafId = null;
     this.flushed = false;
     const ts = timestamp.replace(/[:.]/g, "-");
-    this.sessionFile = join3(this.sessionDir, `${ts}_${this.sessionId}.jsonl`);
+    this.sessionFile = join4(this.sessionDir, `${ts}_${this.sessionId}.jsonl`);
   }
   buildIndex() {
     this.byId.clear();
@@ -32651,14 +33301,14 @@ var SessionManager = class _SessionManager {
   }
   // -- Branching -------------------------------------------------------------
   getBranch(fromId) {
-    const path7 = [];
+    const path8 = [];
     const startId = fromId ?? this.leafId;
     let current = startId ? this.byId.get(startId) : void 0;
     while (current) {
-      path7.unshift(current);
+      path8.unshift(current);
       current = current.parentId ? this.byId.get(current.parentId) : void 0;
     }
-    return path7;
+    return path8;
   }
   createBranchedSession(leafId) {
     const branch = this.getBranch(leafId);
@@ -32668,7 +33318,7 @@ var SessionManager = class _SessionManager {
     const newId = randomUUID();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const ts = timestamp.replace(/[:.]/g, "-");
-    const newFile = join3(this.sessionDir, `${ts}_${newId}.jsonl`);
+    const newFile = join4(this.sessionDir, `${ts}_${newId}.jsonl`);
     const header = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -32714,50 +33364,50 @@ var SessionManager = class _SessionManager {
     return newFile;
   }
   // -- Factory ---------------------------------------------------------------
-  static open(path7) {
-    const entries = loadEntries(path7);
+  static open(path8) {
+    const entries = loadEntries(path8);
     const header = entries.find((e) => e.type === "session");
     const cwd = header?.cwd ?? process.cwd();
-    const dir = resolve2(path7, "..");
-    return new _SessionManager(cwd, dir, path7);
+    const dir = resolve2(path8, "..");
+    return new _SessionManager(cwd, dir, path8);
   }
 };
 
 // dist/fork.js
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
 import * as crypto from "node:crypto";
 function readStoreEntry(sessionsDir, sessionKey) {
-  const storeFile = path5.join(sessionsDir, "sessions.json");
+  const storeFile = path6.join(sessionsDir, "sessions.json");
   try {
-    const store = JSON.parse(fs4.readFileSync(storeFile, "utf-8"));
+    const store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
     return store[sessionKey] ?? store[sessionKey.toLowerCase()] ?? null;
   } catch {
     return null;
   }
 }
 function writeStoreEntry(sessionsDir, sessionKey, entry) {
-  const storeFile = path5.join(sessionsDir, "sessions.json");
+  const storeFile = path6.join(sessionsDir, "sessions.json");
   try {
     let store = {};
     try {
-      store = JSON.parse(fs4.readFileSync(storeFile, "utf-8"));
+      store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
     } catch {
     }
     store[sessionKey.toLowerCase()] = entry;
-    fs4.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs5.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
     return true;
   } catch {
     return false;
   }
 }
 function deleteStoreEntry(sessionsDir, sessionKey) {
-  const storeFile = path5.join(sessionsDir, "sessions.json");
+  const storeFile = path6.join(sessionsDir, "sessions.json");
   try {
-    const store = JSON.parse(fs4.readFileSync(storeFile, "utf-8"));
+    const store = JSON.parse(fs5.readFileSync(storeFile, "utf-8"));
     delete store[sessionKey];
     delete store[sessionKey.toLowerCase()];
-    fs4.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs5.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
   } catch {
   }
 }
@@ -32769,17 +33419,17 @@ function resolveTranscriptFile(sessionsDir, sessionKey) {
   if (!entry?.sessionId)
     return null;
   if (entry.sessionFile) {
-    const resolved = path5.isAbsolute(entry.sessionFile) ? entry.sessionFile : path5.join(sessionsDir, entry.sessionFile);
-    if (fs4.existsSync(resolved))
+    const resolved = path6.isAbsolute(entry.sessionFile) ? entry.sessionFile : path6.join(sessionsDir, entry.sessionFile);
+    if (fs5.existsSync(resolved))
       return resolved;
   }
-  const conventional = path5.join(sessionsDir, `${entry.sessionId}.jsonl`);
-  if (fs4.existsSync(conventional))
+  const conventional = path6.join(sessionsDir, `${entry.sessionId}.jsonl`);
+  if (fs5.existsSync(conventional))
     return conventional;
   try {
-    const files = fs4.readdirSync(sessionsDir);
+    const files = fs5.readdirSync(sessionsDir);
     const match = files.find((file) => file.includes(entry.sessionId) && file.endsWith(".jsonl"));
-    return match ? path5.join(sessionsDir, match) : null;
+    return match ? path6.join(sessionsDir, match) : null;
   } catch {
     return null;
   }
@@ -32790,7 +33440,7 @@ function resolveSessionId(sessionsDir, sessionKey) {
 }
 function forkOrchestratorSession(opts) {
   const { orchestratorSessionKey, accountId, transcriptFile, sessionsDir } = opts;
-  if (!fs4.existsSync(transcriptFile))
+  if (!fs5.existsSync(transcriptFile))
     return null;
   try {
     const manager = SessionManager.open(transcriptFile);
@@ -32810,7 +33460,7 @@ function forkOrchestratorSession(opts) {
       sessionId = crypto.randomUUID();
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-      sessionFile = path5.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
+      sessionFile = path6.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
       const header = {
         type: "session",
         version: CURRENT_SESSION_VERSION,
@@ -32819,7 +33469,7 @@ function forkOrchestratorSession(opts) {
         cwd: manager.getCwd(),
         parentSession: transcriptFile
       };
-      fs4.writeFileSync(sessionFile, `${JSON.stringify(header)}
+      fs5.writeFileSync(sessionFile, `${JSON.stringify(header)}
 `, {
         encoding: "utf-8",
         mode: 384,
@@ -32829,7 +33479,7 @@ function forkOrchestratorSession(opts) {
     const forkSessionKey = `${orchestratorSessionKey}:fork:${sessionId}`;
     const wrote = writeStoreEntry(sessionsDir, forkSessionKey, {
       sessionId,
-      sessionFile: path5.relative(sessionsDir, sessionFile),
+      sessionFile: path6.relative(sessionsDir, sessionFile),
       updatedAt: Date.now(),
       spawnedBy: orchestratorSessionKey,
       parentSessionKey: orchestratorSessionKey,
@@ -32844,8 +33494,8 @@ function forkOrchestratorSession(opts) {
 }
 function cleanupForkSession(opts) {
   try {
-    if (fs4.existsSync(opts.sessionFile)) {
-      fs4.unlinkSync(opts.sessionFile);
+    if (fs5.existsSync(opts.sessionFile)) {
+      fs5.unlinkSync(opts.sessionFile);
     }
   } catch {
   }
@@ -33155,8 +33805,8 @@ var parallGateway = {
     const telemetry = await initAgentTelemetry("parall-openclaw-agent", "openclaw");
     const otelLog = createOtelLogger("agent", "openclaw-agent");
     try {
-      const stateDir = process.env.OPENCLAW_STATE_DIR || path6.join(process.env.HOME || "/data", ".openclaw");
-      const openclawConfigPath = path6.join(stateDir, "openclaw.json");
+      const stateDir = process.env.OPENCLAW_STATE_DIR || path7.join(process.env.HOME || "/data", ".openclaw");
+      const openclawConfigPath = path7.join(stateDir, "openclaw.json");
       const configManagerOpts = {
         client,
         stateDir,
@@ -33192,7 +33842,7 @@ var parallGateway = {
         wsUrl
       });
       const orchestratorKey = buildOrchestratorSessionKey(ctx.accountId);
-      const sessionsDir = path6.join(stateDir, "agents", "main", "sessions");
+      const sessionsDir = path7.join(stateDir, "agents", "main", "sessions");
       const workspaceDir = process.cwd();
       ensureLocalAttachmentGitExclude(workspaceDir);
       const dispatchAdapter = createOpenClawDispatchAdapter({