agents-can-communicate 0.8.3 → 0.8.5

package/bin/acc-update-worker.mjs

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 // Private detached updater. It never opens workspace state or runs a model.
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { runWorker, recordWorkerFailure } from "@agents-can-communicate/cli/managed-worker";
 const [root, ...extra] = process.argv.slice(2);
+// The generation this worker belongs to, so it reclaims only as the active one.
+const generationRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 if (typeof root === "string" && path.isAbsolute(root) && extra.length === 0) {
-  await runWorker(root, { wait: true }).catch(error => recordWorkerFailure(root, error));
+  await runWorker(root, { wait: true, generationRoot }).catch(error => recordWorkerFailure(root, error));
 }

package/bin/entrypoints/acc-mcp.mjs

@@ -5,6 +5,7 @@ import { EXIT, createId } from "@agents-can-communicate/protocol";
 import { createCoordinationService } from "@agents-can-communicate/core";
 import { readInstalledLivePolicy } from "@agents-can-communicate/installer";
 import { createDeliveryRouter } from "@agents-can-communicate/delivery-router";
+import { registerDiscoveredSessions } from "@agents-can-communicate/hook-runner";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
 import { ALL_ADAPTERS, createGitProbe, discoverWorkspace, platformDataHome, runtimePaths }
   from "@agents-can-communicate/cli";
@@ -60,6 +61,8 @@ await serve({
     participantId,
     descriptor,
     runtimeDir: paths.root,
+    registerNativeSessions: () => registerDiscoveredSessions({ adapters,
+      workspaceId: descriptor.id, dataHome, env: process.env }),
   },
 });
 

package/bin/entrypoints/acc.mjs

@@ -5,6 +5,7 @@ import { readFile } from "node:fs/promises";
 import { createId } from "@agents-can-communicate/protocol";
 import { readInstalledLivePolicy } from "@agents-can-communicate/installer";
 import { createDeliveryRouter } from "@agents-can-communicate/delivery-router";
+import { registerDiscoveredSessions } from "@agents-can-communicate/hook-runner";
 import { ALL_ADAPTERS, askConfirmation, main as runCli } from "@agents-can-communicate/cli";
 
 export async function main({ managerRoot = null, packageRoot, managementOnly = false } = {}) {
@@ -27,6 +28,10 @@ const runtime = {
     createDeliveryRouter({ service, adapters, clock,
       readLivePolicy: ({ adapter }) => readInstalledLivePolicy({ dataHome,
         adapterId: adapter.id }) }),
+  // Chats a client holds before their first turn, registered before status
+  // is read so a peer can address them (#167).
+  registerNativeSessions: ({ workspaceId, dataHome }) =>
+    registerDiscoveredSessions({ adapters, workspaceId, dataHome, env: process.env }),
   // Asked only by `acc config init`, and only when stdout is a terminal. There
   // was no port here at all, so the question went to the fallback that always
   // answers no: in a real terminal the command printed "not written" and never

package/docs/ADAPTER_AUTHORING.md

@@ -192,6 +192,9 @@ transport that is technically different on some platform is the probe's fact to
 `docs/design/2026-09-26-native-delivery-across-platforms.md` in the repository.
 - Native methods return closed facts (`validateNativeActivationPlan()` closes the
   activation plan) and never put vendor data - endpoints, sockets, raw errors - into core.
+  A refused handshake may add `launchOption`: the bare command-line option, such as
+  `--search`, that made the client refuse. Doctor and the sender name it; a value, a vendor
+  string or anything but an option token is rejected.
 
 `nativeDelivery.policySource` accepts only `"installation-record"`, which is also the
 default. Hooks and senders read the current recorded recipient consent, independently of

package/docs/ARCHITECTURE.md

@@ -231,8 +231,13 @@ store contract this one does, and run the active generation otherwise. Apart fro
 `SessionEnd`, only the client's confirmed death releases a pin, so a session whose client
 process cannot be found is not pinned, and a pin that names no client is reaped. A
 generation directory is reclaimed once no control pointer, live lease, live pin or staging
-hold names it. Parsed help, version, and update recovery remain available when workspace
-admission is unavailable.
+hold names it. An update is run by the installed code, so right after an activation the
+activated generation's own reclaim runs from its files, and its worker reclaims on every later
+pass; each pass is recorded in `reclaim.json`. The updating process still runs from the
+generation it replaced, and its lease keeps that one through the pass. Such a pass, like one an
+unknown holder postponed, is recorded as unfinished, and the next ACC command an hour or more
+later starts the worker that finishes it. Parsed help, version, and update recovery remain
+available when workspace admission is unavailable.
 
 An independent worker downloads npm packages with lifecycle scripts disabled, checks exact
 stable package identity and the discovered integrity, and health-checks the staged runtime.

package/docs/CLI.md

@@ -122,7 +122,13 @@ participant for it again. A waiting participant's latest session stays listed as
 with that number as `waiting`, and with `endReason` when the client said why the session
 ended, such as `"clear"` for Claude Code's `/clear`. The text line names each one:
 `waiting for a closed session: claude_code-b (cleared, 2)`. `acc status --all` lists every
-session. Default `sync` reads
+session.
+
+Before it reads, `status` registers chats a client already holds but ACC has not seen, so a
+peer can address a new Codex chat before anyone types in it. Codex's shared app-server daemon
+lists them; a chat is registered when it is idle, is not a subagent, and ACC's hooks are enabled
+and trusted in its directory. Its first turn, whether typed or started by a peer's message,
+continues that session. `acc doctor` and the MCP `acc_status` tool do the same. Default `sync` reads
 events after a 16-digit event cursor (100 by
 default, up to 500). `--scope history` discovers historical message headers and reads
 selected records; `--scope full` adds an unbounded snapshot for explicit workspace forensics.

package/docs/CONCEPTS.md

@@ -134,8 +134,8 @@ The durable inbox is universal. An adapter whose captures reach the installed cl
 also offer messages at the next normal turn. Codex LocalDaemon and the Claude Code inbox
 wake add experimental live delivery, off by default and subject to recipient policy and
 current reachability. A Claude Code wake makes the session run a turn, and that turn's
-next-turn hook shows the message. Codex can retain an eligible daemon thread after its
-terminal exits. [Capabilities](CAPABILITIES.md) gives the current limits.
+next-turn hook shows the message. Codex can retain an eligible daemon thread for about a minute
+after its terminal exits. [Capabilities](CAPABILITIES.md) gives the current limits.
 
 ## Handoffs preserve explicit context
 

package/docs/CONFIGURATION.md

@@ -149,8 +149,9 @@ never overrides them. See
 
 Codex LocalDaemon delivery separately requires Codex 0.152.1 or newer, a
 current feature probe, and exact thread, canonical cwd, process, version and protocol
-checks. On Codex 0.154.0 or newer, explicit complete setup can download a missing matching
-standalone package and prepare a definitely absent service. The setup choice names the
+checks. On Codex 0.154.0 through 0.157.0, explicit complete setup can download a missing
+matching standalone package and prepare a definitely absent service. Codex 0.157.1 and newer
+install the service's own package when it first starts, so setup only starts it. The setup choice names the
 download. Existing service-start consent alone does not permit it. Codex files remain
 under the selected `CODEX_HOME`; the existing CLI command and shell profiles are preserved.
 Message delivery does not install Codex, start it, or stop it.

package/docs/GETTING_STARTED.md

@@ -58,8 +58,9 @@ hooks wherever the client is at or after a captured version.
 An interactive install asks one default-No question for all selected clients that need a
 choice. Use `--delivery actionable|all` for explicit noninteractive consent. Use
 `--delivery off` to disable incoming automatic requests. A dry run does not ask, write
-configuration, download Codex, or start a service. On macOS or Linux with Codex 0.154.0 or newer,
-the choice includes downloading a missing standalone package from OpenAI. ACC selects the
+configuration, download Codex, or start a service. On macOS or Linux with Codex 0.154.0 through
+0.157.0, the choice includes downloading a missing standalone package from OpenAI; Codex
+0.157.1 and newer install the service's own package when it first starts. ACC selects the
 matching version and keeps your existing npm or Homebrew command and shell profiles.
 When supported Codex service preparation succeeds, it
 means the infrastructure is ready. Start a Codex session and complete the client's hook and
@@ -146,13 +147,15 @@ Apple Silicon macOS. They are experimental and can spend tokens. Codex queues a
 until a running turn finishes. A busy Claude Code session takes the wake between two tool
 calls. Claude Code requires 2.1.282 or newer and recorded opt-in, and it wakes through the
 inbox that each session opens itself. Codex requires 0.152.1 or newer, LocalDaemon
-infrastructure, recorded opt-in, and a verified session. Supported explicit setup can
-prepare a missing service. Start the client with your normal command. A loaded daemon thread can receive
-messages after its terminal exits. Antigravity CLI 1.2.7 and later has one too: with delivery enabled,
-ACC's context asks the agent to start a relay from its own shell, up to three times while
-none is running, and you approve that command at the client's prompt. Antigravity also asks
-before each shell command, so install adds a rule that lets ACC's own commands run without
-that prompt, and a woken session can answer while you are away; see
+infrastructure, recorded opt-in, and a verified session. A new Codex chat becomes
+addressable before its first message: `acc status` registers it. Supported explicit setup can
+prepare a missing service. Start the client with your normal command. A loaded daemon
+thread can receive messages for about a minute after its terminal exits, until the daemon
+unloads it and ACC closes its session. Antigravity CLI 1.2.7 and later has one too: with
+delivery enabled, ACC's context asks the agent to start a relay from its own shell, up to
+three times while none is running, and you approve that command at the client's prompt.
+Antigravity also asks before each shell command, so install adds a rule that lets ACC's own
+commands run without that prompt, and a woken session can answer while you are away; see
 [Antigravity CLI command approval](CONFIGURATION.md#antigravity-cli-command-approval).
 [Capabilities](CAPABILITIES.md) explains policy, versions and fallback.
 

package/docs/HOW_IT_WORKS.md

@@ -115,7 +115,8 @@ All recipients have the same durable record, but adapters expose different accel
   minimum of 0.152.1 plus a current probe and exact session checks allow delivery
   to an independently opened thread. It is experimental, off by default, and can
   spend tokens. Messages wait for a running turn to finish; a daemon-retained
-  thread can receive them after its terminal exits. ACC adds no launch arguments
+  thread can receive them for about a minute after its terminal exits, until the
+  daemon unloads it and ACC closes its session. ACC adds no launch arguments
   and does not manage the vendor daemon during message delivery. Separately,
   [confirmed update maintenance](UPGRADING.md#confirmed-client-service-maintenance) can restart it.
 

package/docs/TROUBLESHOOTING.md

@@ -125,8 +125,9 @@ ambiguous recipients or failed identity checks retain durable inbox access.
 `native_endpoint_unavailable` means the local service endpoint is missing or is not a safe socket;
 `native_session_unavailable` means the service answered but has no loaded thread to probe.
 An interactive install can save consent in either case. ACC preserves it through a temporary
-outage. On Codex 0.154.0 or newer, an explicit install can download the missing official
-standalone package and prepare a missing service. The single setup choice covers the
+outage. On Codex 0.154.0 through 0.157.0, an explicit install can download the missing official
+standalone package and prepare a missing service. Codex 0.157.1 and newer install the
+service's own package at its first start, and an explicit install only starts it. The single setup choice covers the
 download. Older consent for service start receives one expanded choice. To change a saved
 download refusal, run `acc install --adapter codex --delivery actionable` (or `all` to retain
 that policy). ACC preserves an existing npm or Homebrew command and shell profiles.
@@ -135,6 +136,21 @@ doctor. Download failure keeps the installed integration and its inbox fallback.
 service is infrastructure only. Open a new Codex session afterward and complete the
 client-owned hook and trust review.
 
+After a reboot no Codex service runs. Codex 0.157.1 and newer start it when the next Codex
+session opens (`daemon_auto_start`), and doctor then says so instead of advising `acc install`.
+A Codex chat that started without the service runs on its own embedded service until it closes,
+and no peer can reach it live. ACC reports it as `client_session_embedded`: the chat shows the
+user a notice once, a sender sees the cause beside `no live transport`, and doctor names it on
+the session line. Open a new Codex chat while the service runs; start it with
+`codex app-server daemon start` if Codex does not.
+
+Some launch options make Codex run a chat embedded even while the service runs: `-c`/`--config`,
+`--enable`, `--disable`, `--search`, `-p`/`--profile`, `--oss`, `--strict-config`,
+`--dangerously-bypass-hook-trust` and `--no-daemon`, and also the `CODEX_EXEC_SERVER_URL`
+environment variable. ACC names the option in the notice, the sender's line and doctor. For live
+delivery, start Codex without it; put a setting you need in `config.toml` instead of `-c`,
+`--enable`, `--disable`, `--search` or `--profile`.
+
 If a reply stays queued with `transport_permission_denied`, the sender's permissions
 blocked local transport. This is distinct from an unavailable recipient. The message was
 recorded successfully; the error does not mean it was read or acknowledged.

package/docs/UPGRADING.md

@@ -39,6 +39,41 @@ npm_config_prefer_online=true acc update
 
 From 0.8.3, the download does this itself.
 
+0.8.4 changes what you see around Codex and after an update:
+
+- **A new Codex chat is addressable before anyone types in it.** `acc status`, `acc doctor` and
+  the MCP `acc_status` tool register chats that Codex's daemon holds, when ACC's hooks are
+  enabled and trusted in their directory. The chat's first turn continues that session.
+- **A Codex chat that runs without the daemon says so.** It is told once that live delivery is
+  off; a sender sees the cause beside `no live transport`. After a reboot, doctor advises
+  opening Codex rather than `acc install` when Codex starts its own service.
+- **A new `CODEX_HOME` on Codex 0.157.1 or newer needs no standalone download.** `acc install`
+  only starts the service; Codex installs its own package.
+- **One background pass after the update from 0.8.3.** The first client hook or agent command
+  after the update starts the new version's update worker once, even with automatic updates
+  off, to reclaim old runtime generations with the new rule, and records `reclaim.json` in the
+  runtime directory. These run through ACC's own launchers; an `acc` that npm installed
+  globally keeps the entry of the version npm installed, so it does not start this pass.
+
+This release adds no store event type or field.
+
+0.8.5 changes what a Codex chat that runs without the daemon is told:
+
+- **The launch option that caused it is named.** Codex also runs a chat embedded, even while
+  its daemon runs, when it starts with `-c`/`--config`, `--enable`, `--disable`, `--search`,
+  `-p`/`--profile`, `--oss`, `--strict-config`, `--dangerously-bypass-hook-trust` or
+  `--no-daemon`. The notice, a sender's line and doctor name the option and advise starting
+  Codex without it; put a setting you need in `config.toml` instead.
+- **You see the notice yourself.** Codex shows it once in the chat as a hook message
+  (`↳ Hook · ACC: …`); the model receives its own line, as before.
+- **The previous runtime generation goes an hour after the update.** `acc update` runs from
+  the generation it replaces, so it cannot remove that one itself. It records the reclaim as
+  unfinished in `reclaim.json`, and the first ACC command an hour or more later removes the old
+  generation, with automatic updates on or off.
+
+This release adds no store event type or field. A sender's delivery JSON may carry
+`nativeLaunchOption` beside `nativeReasonCode`.
+
 ## From 0.7.x
 
 Claude Code live delivery wakes each session through the inbox socket that Claude Code opens

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-antigravity",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-antigravity/plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "acc",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Coordinate this Antigravity CLI session with other AI agent sessions working in the same workspace."
 }

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-claude-code",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-codex/src/adapter.mjs

@@ -1,9 +1,11 @@
 import { defineAdapter, projectContext, projectContextResult }
   from "@agents-can-communicate/adapter-sdk";
-import { probeNativeDelivery, planNativeActivation, bindNativeSession, refreshNativeSession, retireNativeSession, offerMessage } from "./native-delivery.mjs";
+import { probeNativeDelivery, planNativeActivation, bindNativeSession, refreshNativeSession, retireNativeSession, offerMessage,
+  nativeActivationHint } from "./native-delivery.mjs";
 import certification from "../certification.json" with { type: "json" };
 import { createCodexServiceSetup } from "./service-setup.mjs";
 import { createCodexMaintenance } from "./maintenance.mjs";
+import { createCodexDiscovery } from "./native-discovery.mjs";
 export { sameMaintenanceIdentity } from "./maintenance.mjs";
 
 import { CODEX_QUEUE_MINIMUM, PROTOCOL_CONTRACT } from "./app-server-client.mjs";
@@ -68,10 +70,14 @@ export function createCodexAdapter() {
     },
     probeNativeDelivery, planNativeActivation, bindNativeSession,
     refreshNativeSession, retireNativeSession, offerMessage,
+    // A chat that runs embedded is told once why nothing reaches it live.
+    nativeActivationHint,
     // A Codex sender reaches another Codex session through its control socket.
     inboundSockets: context => [controlSocket(context)],
     ...createCodexMaintenance(),
     ...createCodexServiceSetup(),
+    // Chats the daemon holds before their first turn, for registration (#167).
+    ...createCodexDiscovery(),
     startSession: async () => ({ ok: true, changes: [], diagnostics: [] }),
     endSession: async () => ({ ok: true, changes: [], diagnostics: [] }),
     guardWrite: async () => ({ ok: true, changes: [], diagnostics: [] }),

package/node_modules/@agents-can-communicate/adapter-codex/src/app-server-client.mjs

@@ -9,7 +9,7 @@ import { openWebSocketPeer } from "./ws-json-rpc.mjs";
 // The Codex App Server queue protocol, captured on codex-cli 0.152.1. Every
 // method here is official and present in the generated schema: initialize,
 // thread/loaded/list, thread/list, metadata-only thread/read, thread/queue/list,
-// thread/queue/add. Thread history is never requested; metadata reads explicitly
+// thread/queue/add, hooks/list. Thread history is never requested; metadata reads explicitly
 // exclude turns. Closed safe results only; no vendor string escapes to core.
 
 export const PROTOCOL_CONTRACT = "codex-app-server-thread-queue-v1";
@@ -109,6 +109,29 @@ function threadEntries(items) {
   return items;
 }
 
+// What discovery may know about a loaded thread, and nothing more: never the
+// preview, never a turn. A thread the daemon cannot describe is left out.
+const THREAD_METADATA = ["id", "cwd", "status", "parentThreadId", "ephemeral"];
+export async function loadedThreadMetadata(peer) {
+  const threads = [];
+  for (const threadId of await pageAll(peer, "thread/loaded/list", {})) {
+    if (typeof threadId !== "string" || threadId === "") throw protocolError();
+    const thread = (await peer.request("thread/read", { threadId, includeTurns: false }))?.thread;
+    if (thread?.id !== threadId) continue;
+    threads.push(Object.fromEntries(THREAD_METADATA.map(key => [key, thread[key] ?? null])));
+  }
+  return threads;
+}
+
+// Each directory's hooks as this daemon would run them, with their enablement
+// and trust (`hooks/list`, present in the 0.158.0 generated schema).
+export async function hooksForDirectories(peer, cwds) {
+  const response = await peer.request("hooks/list", { cwds });
+  if (!Array.isArray(response?.data)) throw protocolError();
+  return response.data.map(entry => ({ cwd: entry?.cwd,
+    hooks: Array.isArray(entry?.hooks) ? entry.hooks : [] }));
+}
+
 export async function canonicalCwd(cwd) {
   if (typeof cwd !== "string" || !path.isAbsolute(cwd) || cwd.includes("\0")) return null;
   try {

package/node_modules/@agents-can-communicate/adapter-codex/src/embedded-host.mjs

@@ -0,0 +1,108 @@
+import path from "node:path";
+
+import { runMaintenanceCommand } from "./maintenance-host.mjs";
+
+// Which process runs a hook tells a daemon-hosted thread from an embedded chat.
+// Measured on 0.158.0: a daemon thread's hook runs under
+// `codex app-server --listen unix:// --managed-daemon`, while a TUI that found
+// no daemon (and did not start one) hosts its own app server and runs the hook
+// itself - for the rest of its life, since a later daemon never adopts it.
+
+// Every subcommand `codex --help` lists on 0.158.0 that runs no interactive
+// chat. `resume` and `fork` open one, so they are absent.
+const NOT_INTERACTIVE = new Set(["exec", "e", "review", "login", "logout", "mcp", "mcp-server",
+  "plugin", "app-server", "remote-control", "app", "completion", "update", "doctor", "sandbox",
+  "debug", "apply", "a", "queue", "archive", "delete", "migrate-rollouts", "unarchive", "cloud",
+  "exec-server", "features", "agents"]);
+// Options whose value is the next word, so that word is not a subcommand.
+const VALUE_OPTIONS = new Set(["-c", "--config", "-m", "--model", "-p", "--profile", "-s",
+  "--sandbox", "-a", "--ask-for-approval", "-C", "--cd", "-i", "--image", "--add-dir", "--enable",
+  "--disable", "--local-provider"]);
+
+export async function hostArgv(pid) {
+  const result = await runMaintenanceCommand("/bin/ps", ["-o", "args=", "-p", String(pid)],
+    { timeout: 500 });
+  if (result.status !== 0) throw new Error("host process unreadable");
+  return result.stdout.trim().split(/\s+/).filter(Boolean);
+}
+
+// The arguments after Codex itself, or null for any process that is not Codex:
+// `codex ...`, or a node script named codex, as `node [options] codex.js ...`.
+function codexArguments(argv) {
+  const [program, ...rest] = argv;
+  if (path.basename(program ?? "") === "codex") return rest;
+  if (path.basename(program ?? "") !== "node") return null;
+  const script = rest.findIndex(word => !word.startsWith("-"));
+  return script >= 0 && path.basename(rest[script]).replace(/\.[mc]?js$/, "") === "codex"
+    ? rest.slice(script + 1) : null;
+}
+
+/**
+ * Whether this command line is an interactive Codex TUI: no subcommand,
+ * `resume`, `fork`, or a prompt. `ps` drops quoting, so a prompt whose first
+ * word names a subcommand reads as not interactive - the safe direction, which
+ * only withholds a notice.
+ */
+export function interactiveHost(argv) {
+  const words = codexArguments(argv);
+  if (words === null) return false;
+  let value = false;
+  for (const word of words) {
+    if (value) { value = false; continue; }
+    if (word.startsWith("-")) { value = VALUE_OPTIONS.has(word); continue; }
+    return !NOT_INTERACTIVE.has(word);
+  }
+  return true;
+}
+
+// Options that make Codex run a chat on its own embedded app server even while
+// the daemon runs. Measured on 0.159.1, which says so only behind its status
+// line: "Running without the shared background server: command-line
+// configuration overrides (-c, --enable, --disable, or --search) requires
+// embedded mode." The same sentence names --profile, --oss, --strict-config,
+// --dangerously-bypass-hook-trust and --no-daemon.
+const EMBEDDING_OPTIONS = new Set(["-c", "--config", "--enable", "--disable", "--search", "-p",
+  "--profile", "--oss", "--strict-config", "--dangerously-bypass-hook-trust", "--no-daemon"]);
+const OPENS_CHAT = new Set(["resume", "fork"]);
+
+// `--config=x` and `-cx` carry their value; both name the option they spell.
+const optionName = word => word.startsWith("--") ? word.split("=", 1)[0] : word.slice(0, 2);
+
+/**
+ * The first option on this interactive command line that keeps the chat
+ * embedded, as typed, or null. Scanning stops at the prompt: `ps` drops quotes,
+ * so a later word may be the prompt's own text.
+ */
+export function embeddingOption(argv) {
+  const words = codexArguments(argv);
+  if (words === null) return null;
+  let value = false;
+  let opened = false;
+  for (const word of words) {
+    if (value) { value = false; continue; }
+    // `--` ends the options: what follows is the prompt, however it reads.
+    if (word === "--") return null;
+    if (word.startsWith("-")) {
+      if (EMBEDDING_OPTIONS.has(optionName(word))) return optionName(word);
+      value = VALUE_OPTIONS.has(word);
+      continue;
+    }
+    if (opened || !OPENS_CHAT.has(word)) return null;
+    opened = true;
+  }
+  return null;
+}
+
+/**
+ * For a host that was read and is an interactive TUI, `{ launchOption }` - the
+ * option that keeps it embedded, or null when its command line shows none.
+ * Null for any other host or an unreadable one; never throws.
+ */
+export async function embeddedHost(pid, argvOf = hostArgv) {
+  try {
+    const argv = await argvOf(pid);
+    return interactiveHost(argv) ? { launchOption: embeddingOption(argv) } : null;
+  } catch {
+    return null;
+  }
+}

package/node_modules/@agents-can-communicate/adapter-codex/src/hooks.mjs

@@ -138,15 +138,25 @@ export function allowOutcome() {
 /**
  * Context for the next turn.
  *
- * This client wraps nothing: a UserPromptSubmit hook's stdout arrives at the
- * model as a `developer` role message, verbatim. So the injection is plain
- * text - emitting Claude Code's JSON envelope would put the envelope itself
- * into the conversation, the same mistake it would be on Kimi Code.
+ * This client wraps nothing: a UserPromptSubmit hook's plain stdout arrives at
+ * the model as a `developer` role message, verbatim, so the ordinary injection
+ * is plain text. Codex also parses a JSON answer - 0.147.0, 0.155.1 and 0.159.1
+ * took `hookSpecificOutput.additionalContext` into the same developer message
+ * and kept the envelope out of the conversation, measured 2026-09-29 - which
+ * is how a notice for the user rides beside the context.
  *
  * The developer role is the most direct channel of the four, which is a reason
  * to be careful with what goes into it: anything a peer wrote must stay framed
  * as data, because at this role the model reads text as instruction.
  */
-export function injectOutcome(context) {
-  return { stdout: context, stderr: "", exitCode: 0 };
+export function injectOutcome(context, notice) {
+  if (typeof notice?.userMessage !== "string") return { stdout: context, stderr: "", exitCode: 0 };
+  // A line the user must see rides as the hook's systemMessage, which Codex
+  // shows in the chat and never sends to the model; the context goes to the
+  // model as additionalContext, the same developer message plain text becomes.
+  // Measured with a probe hook on 0.147.0, 0.155.1 and 0.159.1. Only the ask's
+  // one turn prints JSON; every other turn keeps the plain text above.
+  return { stdout: JSON.stringify({ systemMessage: notice.userMessage,
+    hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } }),
+  stderr: "", exitCode: 0 };
 }

package/node_modules/@agents-can-communicate/adapter-codex/src/install.mjs

@@ -32,6 +32,8 @@ const PLUGIN_NAME = "agents-can-communicate";
 // again to confirm a root of ACC's own is accepted and reported enabled.
 const MARKETPLACE = "acc-local";
 const QUALIFIED = `${PLUGIN_NAME}@${MARKETPLACE}`;
+// The id Codex reports for ACC's plugin, in `hooks/list` among other places.
+export const CODEX_PLUGIN_ID = QUALIFIED;
 const HOOK_REVIEW = "hook readiness unverified: open codex; check ACC is enabled in /plugins; in /hooks, review "
   + "each ACC hook and enable/trust its current definition if needed, then restart the session";
 

package/node_modules/@agents-can-communicate/adapter-codex/src/maintenance-host.mjs

@@ -12,8 +12,19 @@ export const failMaintenance = reasonCode => { throw Object.assign(new Error(rea
 const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
 export const startTimeValid = value => typeof value === "string"
   && /^[A-Z][a-z]{2} [A-Z][a-z]{2} [ \d]\d \d\d:\d\d:\d\d \d{4}$/.test(value);
-export const managedExecutablePaths = codexHome => ["bin/codex", "codex"].map(name =>
-  path.join(codexHome, "packages/standalone/current", name));
+// The two packages a Codex daemon runs from, measured. The standalone install
+// keeps its PID in app-server.pid (0.154.0-0.159.0); a home with no standalone
+// package gets the daemon's own package from `app-server daemon start` on
+// 0.157.1 and newer, with its PID in daemon.pid (0.159.0, 2026-09-29). A home
+// that has the standalone package keeps using it, so it is looked for first.
+const DAEMON_LAYOUTS = Object.freeze([
+  { name: "standalone", packageDir: "packages/standalone", executables: ["current/bin/codex", "current/codex"],
+    pidFile: "app-server-daemon/app-server.pid" },
+  { name: "self-installed", packageDir: "packages/app-server-daemon", executables: ["current/bin/codex"],
+    pidFile: "app-server-daemon/daemon.pid" },
+]);
+export const managedExecutablePaths = codexHome => DAEMON_LAYOUTS.flatMap(layout =>
+  layout.executables.map(name => path.join(codexHome, layout.packageDir, name)));
 
 // Where lsof lives: /usr/sbin on macOS, /usr/bin on Linux. A fixed list of
 // absolute paths, never PATH, so a directory an operator can write to cannot
@@ -57,15 +68,28 @@ export async function maintenanceContext(context = {}) {
   let codexHome = env.CODEX_HOME ?? path.join(home, ".codex");
   if (!absolute(home) || !absolute(codexHome)) failMaintenance("invalid_service_home");
   codexHome = await canonicalFuturePath(codexHome);
-  const [binPath, legacyPath] = managedExecutablePaths(codexHome);
-  const managedPath = await metadataExists(binPath) ? binPath : legacyPath;
+  const { layout, managedPath } = await installedLayout(codexHome);
   return { codexHome, socketPath: path.join(codexHome, "app-server-control/app-server-control.sock"),
-    pidPath: path.join(codexHome, "app-server-daemon/app-server.pid"),
+    pidPath: path.join(codexHome, layout.pidFile), layout: layout.name,
+    packageDir: path.join(codexHome, layout.packageDir),
     managedPath,
     platform: context.platform ?? `${process.platform}-${process.arch}`,
     options: { cwd: codexHome, env: { ...env, HOME: home, CODEX_HOME: codexHome } } };
 }
 
+// The first layout whose executable exists. With none installed, the
+// standalone layout's legacy path, which service setup reports as missing.
+async function installedLayout(codexHome) {
+  for (const layout of DAEMON_LAYOUTS) {
+    for (const name of layout.executables) {
+      const managedPath = path.join(codexHome, layout.packageDir, name);
+      if (await metadataExists(managedPath)) return { layout, managedPath };
+    }
+  }
+  const [standalone] = DAEMON_LAYOUTS;
+  return { layout: standalone, managedPath: path.join(codexHome, standalone.packageDir, "current/codex") };
+}
+
 export async function metadataExists(file) {
   try { await lstat(file); return true; }
   catch (error) { if (error.code === "ENOENT") return false; throw error; }
@@ -143,16 +167,16 @@ export function socketListedIn(stdout, socketPaths) {
 
 // The daemon's command line as measured: 0.154.0 ran `<current path> app-server
 // --listen unix://`; 0.157.1 runs the resolved releases path with
-// `--managed-daemon` appended. The executable must live in the standalone tree
-// and be the managed binary itself, however the tree names it.
+// `--managed-daemon` appended. The executable must live in the package tree of
+// the installed layout and be the managed binary itself, however it is named.
 const DAEMON_COMMAND = /^(\/.+?) app-server --listen unix:\/\/(?: --managed-daemon)?$/;
 
 export async function verifyMaintenanceProcess(snapshot, paths, run, { lsof = resolveLsof } = {}) {
   const process = await observeMaintenanceProcess(snapshot.pid, paths, run);
   const executable = DAEMON_COMMAND.exec(process.command ?? "")?.[1] ?? null;
-  const standalone = path.join(paths.codexHome, "packages", "standalone") + path.sep;
+  const packages = (paths.packageDir ?? path.join(paths.codexHome, "packages", "standalone")) + path.sep;
   if (process.state !== "alive" || process.processStartTime !== snapshot.processStartTime
-    || executable === null || !executable.startsWith(standalone)
+    || executable === null || !executable.startsWith(packages)
     || await realpath(executable).catch(() => null) !== await realpath(paths.managedPath)) {
     failMaintenance("daemon_identity_unavailable");
   }