agents-can-communicate 0.2.0 → 0.3.0

package/node_modules/@agents-can-communicate/adapter-claude-code/src/native-delivery.mjs

@@ -0,0 +1,229 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+
+import { PROTOCOL_CONTRACT, endpointDir, isSocketSafe, readRegistration, routeAck, routeReply }
+  from "./channel.mjs";
+
+// The five native-delivery adapter methods for Claude Code. They keep every
+// Claude flag, protocol name, and endpoint detail inside this package and hand
+// core only opaque facts: a probe verdict, an activation plan, a handshake with
+// an opaque endpoint id, and an offer result. offerMessage is the sender-side
+// half - it connects to the receiver's session endpoint and delivers one
+// envelope; the Channel process itself turns acc_reply into a real ACC answer.
+
+const MIN_VERSION = "2.1.258";
+const CHANNEL_PLUGIN = "plugin:agents-can-communicate@acc-local";
+const DEV_CHANNEL_FLAG = "--dangerously-load-development-channels";
+// The bytes the installed 2.1.258 Mach-O carries for the Channel MCP protocol;
+// a build without Channels has neither. Read-only, bounded.
+const PROBE_NEEDLE = Buffer.from("notifications/claude/channel");
+const PROBE_MAX_BYTES = 256 * 1024 * 1024;
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;
+
+function compare(left, right) {
+  const a = left.split("+")[0].split(".").map(Number);
+  const b = right.split("+")[0].split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  return 0;
+}
+
+async function executableHasChannel(realExecutable) {
+  let handle;
+  try {
+    handle = await (await import("node:fs/promises")).open(realExecutable, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const chunk = Buffer.alloc(1024 * 1024);
+    let carry = Buffer.alloc(0);
+    let read = 0;
+    let position = 0;
+    do {
+      ({ bytesRead: read } = await handle.read(chunk, 0, chunk.length, position));
+      if (read === 0) break;
+      const window = Buffer.concat([carry, chunk.subarray(0, read)]);
+      if (window.includes(PROBE_NEEDLE)) return true;
+      carry = window.subarray(Math.max(0, window.length - PROBE_NEEDLE.length));
+      position += read;
+    } while (position < PROBE_MAX_BYTES);
+    return false;
+  } finally {
+    await handle.close().catch(() => null);
+  }
+}
+
+// Read-only: a stable version at or above the minimum whose executable carries
+// the Channel protocol. Never launches the client.
+export async function probeNativeDelivery({ realExecutable, timeoutMs = 750,
+  hasChannel = executableHasChannel, readVersion = defaultReadVersion } = {}) {
+  const unsupported = reasonCode => ({ supported: false, clientVersion: null,
+    protocolContract: PROTOCOL_CONTRACT, executableFingerprint: null, modes: [], reasonCode });
+  if (typeof realExecutable !== "string" || realExecutable === "") return unsupported("feature_probe_failed");
+  const clientVersion = await withTimeout(readVersion(realExecutable, timeoutMs), timeoutMs)
+    .catch(() => null);
+  if (clientVersion === null || !STABLE_VERSION.test(clientVersion)) {
+    return { ...unsupported("feature_probe_failed"), clientVersion };
+  }
+  if (compare(clientVersion, MIN_VERSION) < 0) {
+    return { ...unsupported("below_minimum_version"), clientVersion };
+  }
+  const present = await withTimeout(Promise.resolve(hasChannel(realExecutable)), timeoutMs)
+    .catch(() => false);
+  if (!present) return { ...unsupported("protocol_mismatch"), clientVersion };
+  return { supported: true, clientVersion, protocolContract: PROTOCOL_CONTRACT,
+    executableFingerprint: null, modes: ["livePush", "idleWake", "busyQueue", "replyRoute"],
+    reasonCode: null };
+}
+
+function defaultReadVersion(realExecutable, timeoutMs) {
+  return new Promise(resolve => {
+    import("node:child_process").then(({ execFile }) => {
+      execFile(realExecutable, ["--version"], { timeout: timeoutMs, windowsHide: true },
+        (error, stdout, stderr) => {
+          if (error !== null) return resolve(null);
+          resolve(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/.exec(`${stdout}${stderr}`)?.[1] ?? null);
+        });
+    });
+  });
+}
+
+function withTimeout(work, ms) {
+  let timer = null;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(Object.assign(new Error("native probe timed out"),
+      { code: "ETIMEDOUT" })), ms);
+  });
+  return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
+}
+
+// The shell bootstrap adds only the captured Channel flag; the .mcp.json the
+// adapter's own install writes is the native-config artifact. ACC never
+// suppresses Claude's experimental warning.
+export function planNativeActivation({ detection, livePolicy }) {
+  if (detection?.realExecutable === undefined || detection.realExecutable === null) {
+    return { eligible: false, reasonCode: "feature_probe_failed", mechanisms: [] };
+  }
+  void livePolicy;
+  return { eligible: true, reasonCode: null, mechanisms: [
+    { kind: "native-config", artifactIds: ["claude-channel-mcp"] },
+    { kind: "shell-bootstrap", command: "claude", realExecutable: detection.realExecutable,
+      prefixArgs: [DEV_CHANNEL_FLAG, CHANNEL_PLUGIN] },
+  ] };
+}
+
+async function currentRegistrations(runtimeDir) {
+  const dir = endpointDir(runtimeDir);
+  let names;
+  try { names = await readdir(dir); } catch { return []; }
+  const registrations = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const record = readRegistration(await readFile(path.join(dir, name), "utf8"));
+      registrations.push(record);
+    } catch { /* skip a malformed neighbour */ }
+  }
+  return registrations;
+}
+
+// Bind the exact Channel the hook-resolved Claude process owns: match clientPid,
+// verify the protocol, and return an opaque endpoint id. Never selects the first
+// registration; two Claude sessions cannot receive each other's endpoint.
+export async function bindNativeSession({ clientPid, clientVersion, runtimeDir, timeoutMs = 750,
+  intervalMs = 50, now = () => Date.now(),
+  sleep = ms => new Promise(resolve => setTimeout(resolve, ms)) }) {
+  const closed = reasonCode => ({ supported: false, clientVersion: clientVersion ?? null,
+    protocolContract: PROTOCOL_CONTRACT, modes: [], opaqueEndpointRef: null, leaseUntil: null,
+    reasonCode });
+  if (!Number.isInteger(clientPid) || clientPid <= 0) return closed("handshake_failed");
+  // Both sides of this handshake are started by SessionStart: the hook writes
+  // the session binding and then calls here, while the Channel is still waiting
+  // for that same binding before it can listen and register. So the endpoint
+  // reliably appears after this begins, and a single read gave up on a channel
+  // that was moments from ready - measured, a healthy endpoint landed on disk
+  // just after the hook had already recorded no binding at all.
+  //
+  // The budget was always passed in for this. It stops one interval short of
+  // the hook's own timer, which races the same budget: an answer that arrives
+  // together with that timer is a coin toss the session loses.
+  const deadline = now() + Math.max(0, timeoutMs - intervalMs);
+  for (;;) {
+    const matches = (await currentRegistrations(runtimeDir))
+      .filter(record => record.clientPid === clientPid
+        && record.protocolContract === PROTOCOL_CONTRACT
+        && Date.parse(record.leaseUntil) > Date.now());
+    // Exactly one, still: waiting must not relax the rule that two Claude
+    // sessions can never be handed each other's endpoint.
+    if (matches.length === 1 && isSocketSafe(matches[0].socketPath)) {
+      const [record] = matches;
+      return { supported: true, clientVersion: clientVersion ?? null,
+        protocolContract: PROTOCOL_CONTRACT, modes: [...record.modes],
+        opaqueEndpointRef: record.endpointId, leaseUntil: record.leaseUntil, reasonCode: null };
+    }
+    if (now() >= deadline) return closed("handshake_failed");
+    await sleep(intervalMs);
+  }
+}
+
+// Sender side: resolve the endpoint id to its registration under this
+// workspace's runtime dir, connect to the session-scoped socket, and deliver one
+// envelope. Returns only accepted/duplicate plus the bound client version.
+export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 2_000,
+  connect = net.createConnection }) {
+  const rejected = safeErrorCode => ({ accepted: false, transport: "claude-channel",
+    clientVersion: binding?.clientVersion ?? null, safeErrorCode });
+  if (typeof runtimeDir !== "string" || binding?.opaqueEndpointRef === undefined) {
+    return rejected("recipient_unavailable");
+  }
+  const file = path.join(endpointDir(runtimeDir), `${binding.opaqueEndpointRef}.json`);
+  if (path.dirname(file) !== endpointDir(runtimeDir)) return rejected("recipient_unavailable");
+  let record;
+  try {
+    record = readRegistration(await readFile(file, "utf8"));
+  } catch {
+    return rejected("recipient_unavailable");
+  }
+  if (record.endpointId !== binding.opaqueEndpointRef
+    || record.protocolContract !== PROTOCOL_CONTRACT
+    || Date.parse(record.leaseUntil) <= Date.now()
+    || !(await stat(record.socketPath).then(s => s.isSocket(), () => false))
+    || !isSocketSafe(record.socketPath)) {
+    return rejected("recipient_unavailable");
+  }
+  return sendEnvelope({ record, message, binding, connect, timeoutMs, rejected });
+}
+
+function sendEnvelope({ record, message, binding, connect, timeoutMs, rejected }) {
+  const envelope = { nonce: record.nonce, messageId: message.messageId, kind: message.kind,
+    subject: message.subject ?? "", body: message.body ?? "",
+    ...(typeof message.inReplyTo === "string" ? { inReplyTo: message.inReplyTo } : {}) };
+  return new Promise(resolve => {
+    const socket = connect(record.socketPath);
+    let settled = false;
+    const finish = value => { if (settled) return; settled = true; clearTimeout(timer);
+      socket.destroy(); resolve(value); };
+    const timer = setTimeout(() => finish(rejected("transport_error")), timeoutMs);
+    socket.once("error", () => finish(rejected("recipient_unavailable")));
+    socket.once("connect", () => {
+      socket.write(`${JSON.stringify(envelope)}\n`);
+      let buffer = "";
+      socket.on("data", chunk => {
+        buffer += chunk.toString("utf8");
+        const newline = buffer.indexOf("\n");
+        if (newline === -1) return;
+        let response;
+        try { response = JSON.parse(buffer.slice(0, newline)); }
+        catch { return finish(rejected("transport_rejected")); }
+        if (response.accepted === true) {
+          return finish({ accepted: true, transport: "claude-channel",
+            clientVersion: binding.clientVersion });
+        }
+        finish(rejected("transport_rejected"));
+      });
+    });
+  });
+}
+
+export { MIN_VERSION, endpointDir, routeAck, routeReply };

package/node_modules/@agents-can-communicate/adapter-codex/certification.json

@@ -12,7 +12,9 @@
       "idleBehavior": "fires when a client session starts",
       "busyBehavior": "fires before the first model turn",
       "authorityLevel": "advisory",
-      "limitations": ["plugin hooks must be explicitly trusted by the user"],
+      "limitations": [
+        "plugin hooks must be explicitly trusted by the user"
+      ],
       "result": "pass"
     },
     {
@@ -27,7 +29,9 @@
       "idleBehavior": "fires when a client session exits",
       "busyBehavior": "does not run until the session exits",
       "authorityLevel": "advisory",
-      "limitations": ["plugin hooks must be explicitly trusted by the user"],
+      "limitations": [
+        "plugin hooks must be explicitly trusted by the user"
+      ],
       "result": "pass"
     },
     {
@@ -42,7 +46,9 @@
       "idleBehavior": "waits for the next user prompt",
       "busyBehavior": "does not interrupt an in-progress turn",
       "authorityLevel": "context",
-      "limitations": ["stdout arrives as an unwrapped developer-role message"],
+      "limitations": [
+        "stdout arrives as an unwrapped developer-role message"
+      ],
       "result": "pass"
     },
     {
@@ -57,7 +63,9 @@
       "idleBehavior": "no write exists to guard",
       "busyBehavior": "blocks an apply_patch call before disk mutation",
       "authorityLevel": "blocking",
-      "limitations": ["runtime and unrecognised shell writes can bypass the guard"],
+      "limitations": [
+        "runtime and unrecognised shell writes can bypass the guard"
+      ],
       "result": "pass"
     },
     {
@@ -72,7 +80,9 @@
       "idleBehavior": "offers complete peer messages at the next prompt",
       "busyBehavior": "does not interrupt an in-progress turn",
       "authorityLevel": "context",
-      "limitations": ["delivery requires the next normal user turn"],
+      "limitations": [
+        "delivery requires the next normal user turn"
+      ],
       "result": "pass"
     },
     {
@@ -112,6 +122,29 @@
         "idle, busy, reply, duplicate, and fallback branches were not observed"
       ],
       "result": "fail"
+    },
+    {
+      "client": "codex-cli",
+      "version": "0.152.1",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-09-03T04:45:00.000Z",
+      "capability": "delivery.livePush",
+      "fixture": "fixtures/delivery/codex-cli-0.152.1-remote-workspace.json",
+      "provenance": "fixtures/certification-provenance.json",
+      "provenanceId": "native-delivery-0-152-1-remote-workspace",
+      "idleBehavior": "unobserved",
+      "busyBehavior": "unobserved",
+      "authorityLevel": "experimental",
+      "limitations": [
+        "release capture on the installed tarball, with the vendor daemon already running from a directory other than the session's",
+        "native delivery requires codex --remote unix://, and in that mode the session runs inside the daemon",
+        "the SessionStart hook payload reported cwd as the daemon's directory rather than the client's: the client was working in a temporary capture project while the payload named the daemon's own checkout",
+        "the App Server's own thread/list recorded that same daemon directory for the live thread, so the session's workspace is not available from anything ACC can reach",
+        "ACC placed the session in an unrelated workspace and injected that workspace's peers into it",
+        "no delivery branch could be observed because the session was never addressable from the workspace it was actually in",
+        "the earlier 0.152.1 pass started the daemon itself in the session's own directory, so the two directories coincided and the substitution was invisible"
+      ],
+      "result": "fail"
     }
   ]
 }

package/node_modules/@agents-can-communicate/adapter-codex/fixtures/certification-provenance.json

@@ -2,64 +2,197 @@
   "schemaVersion": 1,
   "captures": [
     {
-      "id": "session-start", "client": "codex-cli", "version": "0.147.0",
-      "platform": "darwin-arm64", "observedAt": "2026-08-16",
+      "id": "session-start",
+      "client": "codex-cli",
+      "version": "0.147.0",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-08-16",
       "fixture": "fixtures/SessionStart.json",
       "sha256": "1580157d6b48c10f6de5f155aa1d7c68d1695409a5a178eb36c85ce5e01de956",
-      "event": "SessionStart", "tool": null,
-      "claims": [{ "capability": "lifecycle.sessionStart", "result": "pass",
-        "outcome": { "kind": "event-observed", "idle": "fires when a client session starts",
-          "busy": "fires before the first model turn", "authority": "advisory",
-          "limitations": ["plugin hooks must be explicitly trusted by the user"] } }]
+      "event": "SessionStart",
+      "tool": null,
+      "claims": [
+        {
+          "capability": "lifecycle.sessionStart",
+          "result": "pass",
+          "outcome": {
+            "kind": "event-observed",
+            "idle": "fires when a client session starts",
+            "busy": "fires before the first model turn",
+            "authority": "advisory",
+            "limitations": [
+              "plugin hooks must be explicitly trusted by the user"
+            ]
+          }
+        }
+      ]
     },
     {
-      "id": "session-end", "client": "codex-cli", "version": "0.147.0",
-      "platform": "darwin-arm64", "observedAt": "2026-08-16",
+      "id": "session-end",
+      "client": "codex-cli",
+      "version": "0.147.0",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-08-16",
       "fixture": "fixtures/SessionEnd.json",
       "sha256": "e1468c9d5cd2ff5408184158004e9877684f1ae2815239691bbaa386327fe58e",
-      "event": "SessionEnd", "tool": null,
-      "claims": [{ "capability": "lifecycle.sessionEnd", "result": "pass",
-        "outcome": { "kind": "event-observed", "idle": "fires when a client session exits",
-          "busy": "does not run until the session exits", "authority": "advisory",
-          "limitations": ["plugin hooks must be explicitly trusted by the user"] } }]
+      "event": "SessionEnd",
+      "tool": null,
+      "claims": [
+        {
+          "capability": "lifecycle.sessionEnd",
+          "result": "pass",
+          "outcome": {
+            "kind": "event-observed",
+            "idle": "fires when a client session exits",
+            "busy": "does not run until the session exits",
+            "authority": "advisory",
+            "limitations": [
+              "plugin hooks must be explicitly trusted by the user"
+            ]
+          }
+        }
+      ]
     },
     {
-      "id": "user-prompt-submit", "client": "codex-cli", "version": "0.147.0",
-      "platform": "darwin-arm64", "observedAt": "2026-08-16",
+      "id": "user-prompt-submit",
+      "client": "codex-cli",
+      "version": "0.147.0",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-08-16",
       "fixture": "fixtures/UserPromptSubmit.json",
       "sha256": "1774062b17ea917cf67d8adca3408525a928c5b9b88adda1ff6b92f3e89a459f",
-      "event": "UserPromptSubmit", "tool": null,
+      "event": "UserPromptSubmit",
+      "tool": null,
       "claims": [
-        { "capability": "context.beforeTurnInjection", "result": "pass",
-          "outcome": { "kind": "model-context-observed", "idle": "waits for the next user prompt",
-            "busy": "does not interrupt an in-progress turn", "authority": "context",
-            "limitations": ["stdout arrives as an unwrapped developer-role message"] } },
-        { "capability": "delivery.nextTurn", "result": "pass",
-          "outcome": { "kind": "model-context-observed", "idle": "offers complete peer messages at the next prompt",
-            "busy": "does not interrupt an in-progress turn", "authority": "context",
-            "limitations": ["delivery requires the next normal user turn"] } }
+        {
+          "capability": "context.beforeTurnInjection",
+          "result": "pass",
+          "outcome": {
+            "kind": "model-context-observed",
+            "idle": "waits for the next user prompt",
+            "busy": "does not interrupt an in-progress turn",
+            "authority": "context",
+            "limitations": [
+              "stdout arrives as an unwrapped developer-role message"
+            ]
+          }
+        },
+        {
+          "capability": "delivery.nextTurn",
+          "result": "pass",
+          "outcome": {
+            "kind": "model-context-observed",
+            "idle": "offers complete peer messages at the next prompt",
+            "busy": "does not interrupt an in-progress turn",
+            "authority": "context",
+            "limitations": [
+              "delivery requires the next normal user turn"
+            ]
+          }
+        }
       ]
     },
     {
-      "id": "pre-tool-use", "client": "codex-cli", "version": "0.147.0",
-      "platform": "darwin-arm64", "observedAt": "2026-08-16",
+      "id": "pre-tool-use",
+      "client": "codex-cli",
+      "version": "0.147.0",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-08-16",
       "fixture": "fixtures/PreToolUse.json",
       "sha256": "8d3785cfcffbe9affef6c10c1dbbeaf5a0b7062eaed4414e4a66c073f0397a77",
-      "event": "PreToolUse", "tool": "apply_patch",
-      "claims": [{ "capability": "guards.beforeWrite", "result": "pass",
-        "outcome": { "kind": "tool-denied-before-mutation", "idle": "no write exists to guard",
-          "busy": "blocks an apply_patch call before disk mutation", "authority": "blocking",
-          "limitations": ["runtime and unrecognised shell writes can bypass the guard"] } }]
+      "event": "PreToolUse",
+      "tool": "apply_patch",
+      "claims": [
+        {
+          "capability": "guards.beforeWrite",
+          "result": "pass",
+          "outcome": {
+            "kind": "tool-denied-before-mutation",
+            "idle": "no write exists to guard",
+            "busy": "blocks an apply_patch call before disk mutation",
+            "authority": "blocking",
+            "limitations": [
+              "runtime and unrecognised shell writes can bypass the guard"
+            ]
+          }
+        }
+      ]
     },
     {
-      "id": "native-delivery-0-152-0", "client": "codex-cli", "version": "0.152.0",
-      "platform": "darwin-arm64", "observedAt": "2026-09-01T16:20:40.386Z",
+      "id": "native-delivery-0-152-0",
+      "client": "codex-cli",
+      "version": "0.152.0",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-09-01T16:20:40.386Z",
       "fixture": "fixtures/delivery/codex-cli-0.152.0.json",
-      "sha256": "e7879ed95374a4e0450a3c8c0e291357a8c9cf41f6bee90978d920a14f9dc954",
-      "event": null, "tool": null,
+      "sha256": "1f3a57d5ab6fecf827fd54a1fd452c3c7a8d0ac199dd2af025f1954aa83b3cf8",
+      "event": null,
+      "tool": null,
+      "claims": [
+        {
+          "capability": "delivery.livePush",
+          "result": "fail",
+          "outcome": {
+            "kind": "native-capture-failed"
+          }
+        },
+        {
+          "capability": "delivery.replyRoute",
+          "result": "fail",
+          "outcome": {
+            "kind": "native-capture-failed"
+          }
+        }
+      ]
+    },
+    {
+      "id": "native-delivery-0-152-1",
+      "client": "codex-cli",
+      "version": "0.152.1",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-09-02T21:32:19.320Z",
+      "fixture": "fixtures/delivery/codex-cli-0.152.1.json",
+      "sha256": "8254ce1ec25926228109edfa20f970c0036d3c2e012a0dd58af610afc57f7a39",
+      "event": null,
+      "tool": null,
+      "claims": [
+        {
+          "capability": "delivery.livePush",
+          "result": "pass",
+          "outcome": {
+            "kind": "native-delivery-observed",
+            "idle": "offered",
+            "busy": "queued_after_turn",
+            "authority": "experimental",
+            "limitations": [
+              "captured on darwin-arm64 only; Linux and Windows remain uncaptured",
+              "no daemon pre-existed; codex app-server daemon start created it for this capture and daemon stop removed it",
+              "the daemon speaks JSON-RPC over WebSocket on its control Unix socket; a submission queued on the idle thread started a turn by itself, and one queued during a turn was presented after that turn as a user prompt",
+              "the model answered through the ACC CLI (acc reply), which proves the product loop but not a native reply route; delivery.replyRoute stays uncertified",
+              "thread/queue/add has no native idempotency once a submission has been consumed: a retried clientUserMessageId created a second submission and a short turn but no second ACC answer; idempotency holds while the submission is still queued, where thread/queue/list exposes it"
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "id": "native-delivery-0-152-1-remote-workspace",
+      "client": "codex-cli",
+      "version": "0.152.1",
+      "platform": "darwin-arm64",
+      "observedAt": "2026-09-03T04:45:00.000Z",
+      "fixture": "fixtures/delivery/codex-cli-0.152.1-remote-workspace.json",
+      "sha256": "e4f419111d254223f3930eeee61c30c447bb68dd51a4faf81be2a33b144bbaca",
+      "event": null,
+      "tool": null,
       "claims": [
-        { "capability": "delivery.livePush", "result": "fail", "outcome": { "kind": "native-capture-failed" } },
-        { "capability": "delivery.replyRoute", "result": "fail", "outcome": { "kind": "native-capture-failed" } }
+        {
+          "capability": "delivery.livePush",
+          "result": "fail",
+          "outcome": {
+            "kind": "native-capture-failed"
+          }
+        }
       ]
     }
   ]

package/node_modules/@agents-can-communicate/adapter-codex/fixtures/delivery/codex-cli-0.152.0.json

@@ -3,9 +3,11 @@
   "version": "0.152.0",
   "platform": "darwin-arm64",
   "observedAt": "2026-09-01T16:20:40.386Z",
-  "capability": "native_delivery_existing_session",
+  "capability": "native_delivery",
   "result": "fail",
   "fixture": "codex-cli-0.152.0-existing-session",
+  "launchMode": "no-client-launched",
+  "protocolContract": "codex-app-server-turn-start-v0",
   "idle": "unobserved",
   "busy": "unobserved",
   "reply": "unobserved",

package/node_modules/@agents-can-communicate/adapter-codex/fixtures/delivery/codex-cli-0.152.1-remote-workspace.json

@@ -0,0 +1,25 @@
+{
+  "client": "codex-cli",
+  "version": "0.152.1",
+  "platform": "darwin-arm64",
+  "observedAt": "2026-09-03T04:45:00.000Z",
+  "capability": "native_delivery",
+  "result": "fail",
+  "fixture": "codex-cli-0.152.1-remote-workspace",
+  "launchMode": "ordinary-command-with-install-time-bootstrap",
+  "protocolContract": "codex-app-server-thread-queue-v1",
+  "idle": "unobserved",
+  "busy": "unobserved",
+  "reply": "unobserved",
+  "duplicate": "unobserved",
+  "fallback": "unobserved",
+  "limitations": [
+    "release capture on the installed tarball, with the vendor daemon already running from a directory other than the session's",
+    "native delivery requires codex --remote unix://, and in that mode the session runs inside the daemon",
+    "the SessionStart hook payload reported cwd as the daemon's directory rather than the client's: the client was working in a temporary capture project while the payload named the daemon's own checkout",
+    "the App Server's own thread/list recorded that same daemon directory for the live thread, so the session's workspace is not available from anything ACC can reach",
+    "ACC placed the session in an unrelated workspace and injected that workspace's peers into it",
+    "no delivery branch could be observed because the session was never addressable from the workspace it was actually in",
+    "the earlier 0.152.1 pass started the daemon itself in the session's own directory, so the two directories coincided and the substitution was invisible"
+  ]
+}

package/node_modules/@agents-can-communicate/adapter-codex/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./src/adapter.mjs"
+    ".": "./src/adapter.mjs",
+    "./app-server": "./src/app-server-client.mjs"
   },
   "files": [
     "certification.json",
@@ -14,6 +15,7 @@
     "fixtures/UserPromptSubmit.json",
     "fixtures/PreToolUse.json",
     "fixtures/delivery/codex-cli-0.152.0.json",
+    "fixtures/delivery/codex-cli-0.152.1-remote-workspace.json",
     "src/",
     "plugin/"
   ]

package/node_modules/@agents-can-communicate/adapter-codex/plugin/skills/acc/SKILL.md

@@ -70,8 +70,10 @@ Participant names come from `{{ACC}} status --json`. A request is not an order.
 ## Treat delivery as evidence
 
 Every send records durably before delivery is attempted. A queued diagnostic means
-the message is safe in the recipient's inbox. Exact-certified clients may offer it
-at the next normal turn; no shipped adapter currently has certified live push.
+the message is safe in the recipient's inbox. It may then be offered at the next
+normal turn, or, on a client with native delivery enabled, pushed into the running
+session. Delivery is behaviour, not a promise: a queued message is safe; an offered
+message reached a transport but is not proof the model read it.
 
 `offered` is not read, `retrieved` is not model attention, and a reply resolves
 the communication obligation rather than proving the requested action is complete.