@parall/daemon 1.37.0 → 1.38.0

package/bundle/parall-codex-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 path8 of paths) {
+      for (const path9 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path8, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path9, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -21123,7 +21123,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path8) {
+function appendResourcePathToUrl(url, path9) {
   try {
     new URL(url);
   } catch (_a) {
@@ -21133,11 +21133,11 @@ function appendResourcePathToUrl(url, path8) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path8;
+  url += path9;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path8 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path9 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -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();
@@ -27102,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";
@@ -27378,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`,
@@ -27498,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",
@@ -27593,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(path8) {
-    return path8.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+  baseUrlFor(path9) {
+    return path9.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
   }
   setToken(token) {
     this.token = token;
@@ -27621,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(path8) {
+  async ensureFreshToken(path9) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path8.replace(/^\/api\/v1/, "");
+    const pathSuffix = path9.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -27656,11 +27675,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path8, body, query, retried = false, opts) {
+  async request(method, path9, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path8);
+      await this.ensureFreshToken(path9);
     }
-    let url = `${this.baseUrlFor(path8)}${path8}`;
+    let url = `${this.baseUrlFor(path9)}${path9}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27690,12 +27709,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path8.replace(/^\/api\/v1/, "");
+      const pathSuffix = path9.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path8, body, query, true, opts);
+          return this.request(method, path9, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27706,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) {
@@ -27724,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, path8, body, retried = false) {
+  async multipartRequest(method, path9, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path8);
+      await this.ensureFreshToken(path9);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrlFor(path8)}${path8}`, {
+      res = await fetch(`${this.baseUrlFor(path9)}${path9}`, {
         method,
         headers,
         body,
@@ -27742,12 +27762,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path8.replace(/^\/api\/v1/, "");
+      const pathSuffix = path9.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path8, body, true);
+          return this.multipartRequest(method, path9, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -28039,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);
   }
@@ -28426,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, path8) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path8 }, void 0, false, { timeoutMs: 15e3 });
+  async browseMachineFilesystem(orgId, machineId, path9) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path9 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -28500,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);
@@ -28964,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, path8) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path8 ? { path: path8 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path9) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path9 ? { path: path9 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -28974,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, path8, params) {
+  async getWikiFileCommits(orgId, wikiId, path9, params) {
     return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-      path: path8,
+      path: path9,
       ...params
     });
   }
-  async getWikiBlame(orgId, wikiId, path8, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path8, ref });
+  async getWikiBlame(orgId, wikiId, path9, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path9, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -29613,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);
@@ -29914,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
@@ -29923,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;
@@ -29992,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)}`);
       }
@@ -30009,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)}`);
         }
@@ -30021,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)}`);
         }
@@ -30033,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)}`);
         }
@@ -30045,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)}`);
         }
@@ -30057,11 +30533,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)}`);
         }
@@ -30069,11 +30544,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)}`);
         }
@@ -30081,14 +30555,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`);
       }
@@ -30124,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 {
@@ -30140,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
     };
@@ -30179,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) {
@@ -30225,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":
@@ -30247,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, {
@@ -30266,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)}`);
     }
@@ -30295,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)}`);
     }
@@ -30304,7 +30823,7 @@ var ParallAgentGateway = class {
   /** @deprecated Use writeContextFile / updateContextFileStepId. */
   clearStepIdFile(filePath) {
     try {
-      fs.writeFileSync(filePath, "", "utf8");
+      fs2.writeFileSync(filePath, "", "utf8");
     } catch {
     }
   }
@@ -30313,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) {
@@ -30357,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;
   }
@@ -30383,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(() => {
@@ -30417,7 +30952,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);
@@ -30449,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);
           }
@@ -30465,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);
@@ -30487,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;
@@ -30530,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);
@@ -30587,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);
@@ -30696,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];
@@ -30707,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) {
@@ -30736,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(() => {
@@ -30755,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;
@@ -30782,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) {
@@ -30953,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);
       }
@@ -30963,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}`;
@@ -30992,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) {
@@ -31016,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)
@@ -31424,74 +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) {
-            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) {
@@ -31557,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);
@@ -31627,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`);
@@ -31634,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";
 }
@@ -31652,11 +32279,11 @@ function deriveModelIsPin(defaults, 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;
@@ -31671,9 +32298,9 @@ function saveCache(stateDir, response) {
   };
   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();
@@ -31764,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
@@ -32538,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)
 
@@ -32554,7 +33181,7 @@ ${lines.join("\n")}
 
 // ts/codex-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) {
@@ -32563,15 +33190,15 @@ function requireEnv(env, name) {
   return value;
 }
 function resolvePath(value) {
-  return path4.isAbsolute(value) ? value : path4.resolve(process.cwd(), value);
+  return path5.isAbsolute(value) ? value : path5.resolve(process.cwd(), value);
 }
 function resolveCodexAgentConfig(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 codexHome = resolvePath(env.PRLL_CODEX_HOME?.trim() || env.CODEX_HOME?.trim() || path4.join(env.HOME || os2.homedir(), ".codex"));
-  const stateDir = resolvePath(env.PRLL_STATE_DIR?.trim() || path4.join(env.HOME || os2.homedir(), ".parall-agent"));
-  const workspaceDir = resolvePath(env.PRLL_WORKSPACE_DIR?.trim() || path4.join(stateDir, "workspace"));
+  const codexHome = resolvePath(env.PRLL_CODEX_HOME?.trim() || env.CODEX_HOME?.trim() || path5.join(env.HOME || os2.homedir(), ".codex"));
+  const stateDir = resolvePath(env.PRLL_STATE_DIR?.trim() || path5.join(env.HOME || os2.homedir(), ".parall-agent"));
+  const workspaceDir = resolvePath(env.PRLL_WORKSPACE_DIR?.trim() || path5.join(stateDir, "workspace"));
   return {
     apiUrl,
     apiKey,
@@ -32625,28 +33252,31 @@ function buildCodexRuntimeKey(agentUserId) {
 }
 function sessionStateFilePathForRuntime(stateDir, runtimeKey) {
   const fileName = Buffer.from(runtimeKey).toString("base64url");
-  return path4.join(stateDir, "threads", `${fileName}.json`);
+  return path5.join(stateDir, "threads", `${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/codex-agent/dist/dispatch.js
 import { execSync as execSync2, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 
 // ts/agent-core/dist/internal/attachment-input.js
 import { execSync } from "node:child_process";
 import { constants } from "node:fs";
 import * as fsSync from "node:fs";
-import * as 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;
@@ -32676,11 +33306,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, {
@@ -32697,7 +33327,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`);
@@ -32754,7 +33384,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);
   }
@@ -32769,7 +33399,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 {
@@ -32778,8 +33408,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;
@@ -32815,18 +33445,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}`);
   }
@@ -32834,7 +33464,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}`);
     }
@@ -32845,8 +33475,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 {
@@ -32857,30 +33487,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}`);
   }
@@ -32888,7 +33518,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();
@@ -32904,8 +33534,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);
@@ -32930,7 +33560,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 {
   }
 }
@@ -32943,7 +33573,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;
   }
@@ -32951,15 +33581,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)}`);
@@ -32971,7 +33601,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;
   }
@@ -32980,9 +33610,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);
@@ -32998,10 +33628,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)}`);
@@ -33010,12 +33640,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;
     }
@@ -33030,10 +33660,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);
     }
   }
@@ -33130,9 +33760,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 {
@@ -33148,9 +33778,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) {
@@ -33933,6 +34563,9 @@ var CodexAppServerAdapter = class {
     if (this.opts.contextFilePath) {
       env.PRLL_CONTEXT_FILE = this.opts.contextFilePath;
     }
+    if (this.opts.contextDirPath) {
+      env.PRLL_CONTEXT_DIR = this.opts.contextDirPath;
+    }
     if (!env.PRLL_WIKI_MOUNT_ROOT?.trim()) {
       env.PRLL_WIKI_MOUNT_ROOT = this.opts.workspaceDir;
     }
@@ -34078,7 +34711,7 @@ var TurnSink = class {
   }
 };
 function ensureGitRepo(workingDirectory) {
-  fs5.mkdirSync(workingDirectory, { recursive: true });
+  fs6.mkdirSync(workingDirectory, { recursive: true });
   try {
     execSync2("git rev-parse --is-inside-work-tree", { cwd: workingDirectory, stdio: "pipe" });
     ensureLocalAttachmentGitExclude(workingDirectory);
@@ -34148,8 +34781,8 @@ function errToString(err) {
 }
 
 // ts/codex-agent/dist/session-manager.js
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 var CodexSessionManager = class {
   mainSessionKey;
   stateFilePath;
@@ -34186,14 +34819,14 @@ var CodexSessionManager = class {
   clearMainThread() {
     this.threadIds.delete(this.mainSessionKey);
     try {
-      fs6.rmSync(this.stateFilePath, { force: true });
+      fs7.rmSync(this.stateFilePath, { force: true });
     } catch (error) {
       this.logger?.warn(`codex-agent: failed to clear main thread state at ${this.stateFilePath}: ${String(error)}`);
     }
   }
   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.threadId === "string" && parsed.threadId.trim()) {
         this.threadIds.set(this.mainSessionKey, parsed.threadId.trim());
@@ -34206,10 +34839,10 @@ var CodexSessionManager = class {
   }
   persist(threadId) {
     try {
-      fs6.mkdirSync(path6.dirname(this.stateFilePath), { recursive: true });
+      fs7.mkdirSync(path7.dirname(this.stateFilePath), { recursive: true });
       const tmpPath = `${this.stateFilePath}.tmp`;
-      fs6.writeFileSync(tmpPath, JSON.stringify({ runtimeKey: this.mainSessionKey, threadId }, null, 2));
-      fs6.renameSync(tmpPath, this.stateFilePath);
+      fs7.writeFileSync(tmpPath, JSON.stringify({ runtimeKey: this.mainSessionKey, threadId }, null, 2));
+      fs7.renameSync(tmpPath, this.stateFilePath);
     } catch (error) {
       this.logger?.warn(`codex-agent: failed to persist thread state at ${this.stateFilePath}: ${String(error)}`);
     }
@@ -34217,8 +34850,8 @@ var CodexSessionManager = class {
 };
 
 // ts/codex-agent/dist/workspace.js
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 
 // ts/node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -34912,12 +35545,12 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 
 // ts/codex-agent/dist/workspace.js
 function ensureWorkspaceTrusted(codexHome, workspaceDir, log2) {
-  const configPath = path7.join(codexHome, "config.toml");
-  const normalizedPath = path7.resolve(workspaceDir);
+  const configPath = path8.join(codexHome, "config.toml");
+  const normalizedPath = path8.resolve(workspaceDir);
   try {
     let content = "";
     try {
-      content = fs7.readFileSync(configPath, "utf8");
+      content = fs8.readFileSync(configPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
@@ -34957,14 +35590,14 @@ ${trustLine}
           content = content.substring(0, afterHeader) + trustLine + "\n" + content.substring(afterHeader);
         }
       }
-      fs7.writeFileSync(configPath, content, "utf8");
+      fs8.writeFileSync(configPath, content, "utf8");
     } else if (projects?.[normalizedPath] !== void 0) {
       log2?.warn(`Codex config.toml has non-canonical header for ${normalizedPath}; skipping trust write`);
     } else if (projects && !content.includes("[projects.")) {
       log2?.warn(`Codex config.toml uses inline table for projects; skipping trust write for ${normalizedPath}`);
     } else {
-      fs7.mkdirSync(codexHome, { recursive: true });
-      fs7.appendFileSync(configPath, `
+      fs8.mkdirSync(codexHome, { recursive: true });
+      fs8.appendFileSync(configPath, `
 ${sectionHeader}
 ${trustLine}
 `, "utf8");
@@ -34981,12 +35614,12 @@ function isParallProxyMode(env = process.env) {
   return baseUrl === apiUrl || baseUrl.startsWith(`${apiUrl}/`);
 }
 function ensureParallProvider(codexHome, apiUrl, log2) {
-  const configPath = path7.join(codexHome, "config.toml");
+  const configPath = path8.join(codexHome, "config.toml");
   const baseUrl = apiUrl.replace(/\/$/, "") + "/api/llm/v1";
   try {
     let content = "";
     try {
-      content = fs7.readFileSync(configPath, "utf8");
+      content = fs8.readFileSync(configPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
@@ -35017,8 +35650,8 @@ function ensureParallProvider(codexHome, apiUrl, log2) {
     } else {
       content = content.trimEnd() + "\n\n" + providerBlock + "\n";
     }
-    fs7.mkdirSync(codexHome, { recursive: true });
-    fs7.writeFileSync(configPath, content, "utf8");
+    fs8.mkdirSync(codexHome, { recursive: true });
+    fs8.writeFileSync(configPath, content, "utf8");
   } catch (err) {
     throw new Error(`failed to write Parall provider config: ${String(err)}`);
   }
@@ -35035,18 +35668,18 @@ function ensureCodexWorkspace(workspaceDir, log2, agentIdentity) {
     PRLL_REFERENCE_GUIDE,
     buildSkillReferences(workspaceDir)
   ].join("\n\n");
-  fs7.mkdirSync(workspaceDir, { recursive: true });
-  const parallDir = path7.join(workspaceDir, ".parall");
-  fs7.mkdirSync(parallDir, { recursive: true });
-  fs7.writeFileSync(path7.join(parallDir, "system-prompt.md"), systemPrompt, "utf8");
-  writeSkillFiles(path7.join(parallDir, "skills"));
-  const codexConfigDir = path7.join(workspaceDir, ".codex");
-  fs7.mkdirSync(codexConfigDir, { recursive: true });
+  fs8.mkdirSync(workspaceDir, { recursive: true });
+  const parallDir = path8.join(workspaceDir, ".parall");
+  fs8.mkdirSync(parallDir, { recursive: true });
+  fs8.writeFileSync(path8.join(parallDir, "system-prompt.md"), systemPrompt, "utf8");
+  writeSkillFiles(path8.join(parallDir, "skills"));
+  const codexConfigDir = path8.join(workspaceDir, ".codex");
+  fs8.mkdirSync(codexConfigDir, { recursive: true });
   const toml = `developer_instructions = """
 ${systemPrompt.replace(/\\/g, "\\\\").replace(/"""/g, '\\"""')}
 """
 `;
-  fs7.writeFileSync(path7.join(codexConfigDir, "config.toml"), toml, "utf8");
+  fs8.writeFileSync(path8.join(codexConfigDir, "config.toml"), toml, "utf8");
 }
 
 // ts/codex-agent/dist/index.js
@@ -35139,6 +35772,7 @@ async function main() {
       sessionManager,
       log: agentLog,
       contextFilePath: mainContextFilePath,
+      contextDirPath: dispatchContextDirPath(config.stateDir),
       useParallProvider
     });
     const refreshPlatformConfig = async () => {
@@ -35184,6 +35818,7 @@ async function main() {
       dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
       contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
       stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
+      dispatchContextDir: dispatchContextDirPath(config.stateDir),
       onConfigUpdate: refreshPlatformConfig,
       onSessionReady: refreshPlatformConfig,
       onNewSession: () => {