agents-can-communicate 0.3.1 → 0.4.1

package/README.md

@@ -1,18 +1,19 @@
 # agents-can-communicate
 
-**Open your agents. Let them coordinate.**
+**Independent AI sessions. Shared work context.**
 
-Give Codex the backend. Ask Claude Code to build the interface. Keep working as usual.
+Give Codex the backend. Ask Claude Code to build the interface. Keep using the clients
+and models you prefer.
 
-ACC makes supported sessions in the same project aware of each other and gives them
-instructions for coordinating. Agents discover their peers, share what they're working
-on, and decide when to ask questions, agree on changes, or avoid overlapping edits.
+ACC is a local coordination layer for AI sessions you open yourself. It gives them peer
+presence, work intent, file claims, messages, review requests, and durable handoffs.
+Each session keeps its own conversation, permissions, and task. The agents decide when
+coordination helps their work.
 
-Think of the coordination you expect from subagents, extended across the independent
-sessions you open yourself — with different clients and models. You keep giving them
-ordinary tasks; they handle the conversations around their work.
+Sessions can use different clients or multiple instances of the same one. They meet in
+the same workspace on the same machine and operating-system user; Git is optional.
 
-[Try it](#try-it) · [Supported clients](#when-messages-arrive) · [Documentation](docs/index.md)
+[Try it](#try-it) · [Client support](#when-messages-arrive) · [Update ACC](#update-or-remove-acc) · [Documentation](docs/index.md)
 
 [![CI](https://github.com/automatis-tools/agents-can-communicate/actions/workflows/ci.yml/badge.svg)](https://github.com/automatis-tools/agents-can-communicate/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
@@ -27,9 +28,9 @@ Open two sessions in your project and give each its task:
 | Codex | Build the backend for account registration. |
 | Claude Code | Build the registration screen. |
 
-ACC's integration tells the agents that peers are present and teaches them how to find
-out what those peers are doing. As they work, they can notice the dependency and coordinate
-on their own. An illustrative exchange:
+Supported integrations introduce peer awareness and teach agents how to find out what
+others are doing. As they work, they can notice a dependency and coordinate. An
+illustrative exchange:
 
 ```text
 Claude → Codex   I'm building the registration screen. What will your endpoint accept?
@@ -37,71 +38,111 @@ Codex → Claude   Email and password. I'll return the new user and handle valid
 Claude → Codex   I'll use that shape and keep my changes in the UI files.
 ```
 
-The agents identify who to talk to and what to agree on. Your prompts stay focused on
-the feature you want to build.
+Your prompts stay focused on the feature. Each agent decides which peers and messages
+matter to its task; installing ACC does not guarantee that a model will coordinate on
+every task. [Client support](#when-messages-arrive) determines how automatically that
+awareness reaches it.
 
-Each session keeps its own conversation and instructions. Response timing depends on the
-receiving client: see [when messages arrive](#when-messages-arrive).
+The same setup supports review and recovery. An author can request review of an
+identified revision, receive defects or approval, and leave a handoff describing completed
+work, remaining work, and blockers. A later session can look up that history. Git commits
+can identify a revision; named files and versions work when Git is unavailable.
+See [requests and replies](docs/CLI.md#messages-and-requests) and
+[handoffs](docs/CLI.md#handoff).
 
 ## Try it
 
 You'll need **macOS or Linux, Node.js 24 or newer**, and two AI sessions in the same
-project. They can use different clients or the same one.
+project. Install once on the machine:
 
 ```bash
 npm install -g agents-can-communicate
 acc install
 ```
 
-The installer connects the clients it finds. Open a new terminal and restart your AI
-clients to load the integration. If you use Codex, accept its plugin trust prompt.
+The installer connects the supported clients it finds. Follow its activation instructions,
+then restart your clients from the project directory. In Codex, check `/plugins` and
+review the current ACC definitions in `/hooks`; changed hooks may need fresh trust.
+[Getting started](docs/GETTING_STARTED.md) covers activation and preserved sandbox settings.
 
-Open two sessions in your project and give them ordinary tasks, as in the example above.
-On supported clients, ACC introduces peer awareness through the client's own integration;
-its installed instructions guide the agents to coordinate when their work overlaps.
+Open two sessions and give them ordinary tasks, as above. Look for an agent discovering a
+peer, checking who is changing a file, asking about a shared dependency, or replying to a
+review request.
 
-Look for coordination in the agents' own activity: discovering a peer, checking who is
-changing a file, or asking about a shared dependency. Each agent decides what is relevant
-to its task; the integration provides awareness, not a guarantee that a model will
-coordinate on every task. [Client support](#when-messages-arrive) determines how
-automatically peers and messages reach it.
+Run `acc doctor` from the project if a peer is missing. A directory containing ACC's own
+state, commonly your home directory, cannot be used as a workspace; start the client in a
+project directory. See [Troubleshooting](docs/TROUBLESHOOTING.md).
 
-If the other session doesn't appear, run `acc doctor` from your project directory.
-[Get help with setup](docs/TROUBLESHOOTING.md).
+Already using ACC? Follow the [upgrade guide](docs/UPGRADING.md), including the 0.4.0 →
+0.4.1 update and the data-format boundary when moving from 0.3.1.
 
 ## When messages arrive
 
-ACC connects sessions **on the same machine** and saves messages locally, so a waiting
-session can pick them up later. Delivery depends on the client:
+Messages are saved locally before delivery is attempted. A durable inbox remains
+available when a faster route cannot be used.
 
 | Client | How the agent receives a message |
 |---|---|
-| Codex CLI, Claude Code, Gemini CLI, Kimi Code | At the next normal turn on verified versions and platforms; otherwise by checking its ACC inbox. |
-| Grok or another client connected through [MCP](docs/MCP.md) | By checking its ACC inbox. |
+| Codex CLI, Claude Code, Gemini CLI, Kimi Code | At the next normal turn on the exact verified versions and platforms; otherwise through explicit ACC inbox reads. |
+| Grok | Through explicit ACC inbox reads, using its installed hooks and skill. CLI ownership was verified on Grok 1.0.24. |
+| Other clients connected through [MCP](docs/MCP.md) | Through ACC tools and inbox reads. Generic MCP requires its own client configuration and coordination instructions. |
+
+Grok's updated skill first runs public status through the terminal. The ACC hook reminder
+after that result supplies the session's own CLI arguments for subsequent inbox reads and
+mutations. It adds no automatic peer-message injection or idle delivery. A relocated
+`GROK_HOME` is respected by install, doctor, and uninstall.
+
+**Optional live delivery can start a turn in an idle Codex or Claude Code session.** It is
+experimental, off by default, and can spend model tokens. On Apple Silicon Macs, Codex
+0.152.1 or newer requires an already-running LocalDaemon and a verified session;
+Claude Code 2.1.258 or newer requires zsh and shows its development-channel warning at
+startup. Messages arriving mid-turn wait for the turn to finish. The receiving session's
+opt-in policy and current reachability determine whether delivery can proceed.
+
+A Codex thread retained by LocalDaemon can receive opted-in messages after its terminal
+exits. Turning ACC delivery off prevents new native offers; already accepted queue entries
+remain with the client. [Compatibility and delivery controls](docs/CAPABILITIES.md) describe
+the exact evidence, versions, platforms, and fallback paths.
+
+A recorded message is send success. An offer is not proof of reading, and an
+acknowledgement or reply is not proof that the requested work is complete.
 
-**Claude Code can also reply while idle.** This optional mode is experimental and off by
-default. It supports Apple Silicon Macs with zsh and Claude Code 2.1.258 or newer, subject
-to compatibility checks. It can spend model tokens and requires accepting Claude's
-development-channel warning at startup. Messages arriving mid-turn wait for it to finish.
+## Keep the workflow you like
 
-Each direction follows the receiving client's rules: Claude's reply won't start a new
-Codex turn. Codex can pick it up on a supported next turn or by checking its inbox.
+- **Your usual tools.** Start clients with their normal commands. You choose each agent's
+  task, model, and permissions.
+- **Separate checkouts, one project.** Git worktrees share an ACC workspace. Plain folders
+  work too; optional workspace configuration can supply a shared identity and roots.
+- **Agree before editing.** Agents can claim files and identify overlapping work. CLI claims
+  default to advisory. Guarded claims require certified guards from every live participant.
+  [How claims work](docs/CONCEPTS.md#intent-is-awareness-a-claim-commits).
+- **Focused context and durable history.** Normal turn context is bounded. Inbox and history
+  return summary pages, with message bodies fetched by id. Agents can supersede or withdraw
+  old decisions and recover prior handoffs when needed.
+- **Local coordination.** State lives in app data outside your project. ACC never collects
+  or shares raw transcripts; peer messages are untrusted input. Your clients keep using
+  their usual model providers.
 
-[Full compatibility details](docs/CAPABILITIES.md).
+One npm package. ACC needs no separate account, model API key, or hosted service.
 
-## Keep the workflow you like
+## Update or remove ACC
+
+Initial installation enables automatic updates. ACC downloads stable releases in the
+background and waits for active clients and ACC processes to exit before switching the
+runtime and refreshing integrations. Restart clients afterward and complete any requested
+hook or plugin trust review.
 
-- **Your usual tools.** Start clients with their normal commands. You choose each
-  agent's task, model, and permissions.
-- **Separate checkouts, one project.** Git worktrees share an ACC workspace.
-  Plain project folders work too; Git is optional.
-- **Agree before editing.** Agents can reserve files and identify overlapping work.
-  Reservations are advisory unless the clients support enforcement.
-  [How reservations work](docs/CONCEPTS.md#intent-is-awareness-a-claim-commits).
-- **Local coordination.** Messages live in app data outside your project. ACC doesn't
-  collect or share raw transcripts. Your clients use their usual model providers.
+For an immediate update:
+
+```bash
+acc update
+```
 
-One npm package. No account or separate coordination service to set up.
+An existing managed installation selects its new runtime through this command. Updates
+also support an explicit opt-out and version pinning. Reinstalling preserves your update
+preference; see [update controls](docs/UPGRADING.md#automatic-updates-after-installation).
+If you fully uninstalled ACC 0.4.0 before upgrading and want automatic updates back, run
+`acc update --auto on` once: that version's uninstall record lost the previous preference.
 
 To remove the integrations:
 
@@ -109,7 +150,9 @@ To remove the integrations:
 acc uninstall
 ```
 
-ACC preserves configuration changes you've made since installation.
+ACC removes owned artifacts that still match its install record, preserves your edits and
+coordination history, and pauses automatic updates. A later install remembers the update
+preference.
 
 ## Go further
 

package/SECURITY.md

@@ -19,7 +19,7 @@ version. A reproduction against a throwaway `ACC_DATA_HOME` is ideal.
 | Peer text escaping its quoted block | An attacker who already has write access to your data home |
 | Any path escaping the managed root | A model choosing to obey persuasive peer text |
 | Uninstall deleting files ACC did not write | Vulnerabilities in Codex, Claude Code, Gemini, Grok, or Kimi themselves |
-| ACC writing into a repository | Denial of service by a trusted peer |
+| Unexpected ACC runtime/state or installer artifacts in a repository (excluding user-requested `acc.workspace.json`) | Denial of service by a trusted peer |
 | Session impersonation across MCP | |
 
 Reasoning behind each: [docs/SECURITY_MODEL.md](docs/SECURITY_MODEL.md).

package/bin/acc-bootstrap.mjs

@@ -1,56 +1,7 @@
 #!/usr/bin/env node
-// Internal entry point behind an ACC-owned shell shim: is this exact vendor
-// executable eligible for native delivery right now? Exit 0 means yes and the
-// shim exports its owned policy before `exec`; any other exit - including a
-// crash, a missing adapter, or a damaged install - means the shim launches the
-// vendor command untouched. Nothing is ever written to stdout, and stderr stays
-// empty unless ACC_BOOTSTRAP_DEBUG=1 asks for one safe line.
-import { checkNativeBootstrap } from "@agents-can-communicate/installer";
+import { fileURLToPath } from "node:url";
+import { invokedDirectly, runEntry } from "@agents-can-communicate/cli/managed-entry";
 
-import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-code";
-import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
-import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
-import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
-import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-
-const FLAGS = new Map([["--adapter", "adapter"], ["--real-executable", "realExecutable"],
-  ["--data-home", "dataHome"]]);
-
-function debug(line) {
-  if (process.env.ACC_BOOTSTRAP_DEBUG === "1") process.stderr.write(`acc-bootstrap: ${line}\n`);
-}
-
-function parse(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 2) {
-    const key = FLAGS.get(args[index]);
-    const value = args[index + 1];
-    if (key === undefined || typeof value !== "string" || value === "" || key in options) return null;
-    options[key] = value;
-  }
-  return FLAGS.values().every(key => key in options) ? options : null;
-}
-
-try {
-  const options = parse(process.argv.slice(2));
-  if (options === null) {
-    debug("usage: --adapter <id> --real-executable <path> --data-home <path>");
-    process.exit(2);
-  }
-  const registry = {
-    claude_code: createClaudeCodeAdapter, codex: createCodexAdapter,
-    gemini_cli: createGeminiCliAdapter, grok: createGrokAdapter, kimi: createKimiAdapter,
-  };
-  const adapter = registry[options.adapter]?.();
-  if (adapter === undefined) {
-    debug(`${options.adapter}: unknown adapter`);
-    process.exit(1);
-  }
-  const result = await checkNativeBootstrap({ adapter, realExecutable: options.realExecutable,
-    platform: `${process.platform}-${process.arch}`, dataHome: options.dataHome, timeoutMs: 750 });
-  debug(`${options.adapter}: ${result.supported ? "supported" : result.reasonCode}`);
-  process.exit(result.supported ? 0 : 1);
-} catch (error) {
-  debug(`failed: ${String(error?.code ?? error?.name ?? "error")}`);
-  process.exit(1);
-}
+if (invokedDirectly(import.meta.url)) await runEntry({
+  kind: "acc-bootstrap", packageRoot: fileURLToPath(new URL("..", import.meta.url)),
+});

package/bin/acc-claude-channel.mjs

@@ -1,177 +1,10 @@
 #!/usr/bin/env node
-// The ACC Channel binary Claude Code spawns as a stdio MCP child. It composes
-// the same workspace discovery, session binding, core service, and local
-// data-home rules as acc-hook, opens a session-scoped endpoint for the delivery
-// router, and turns the model's explicit acc_reply / acc_ack into real ACC
-// records. It never collects a transcript or runs a model, and it fails open:
-// any composition error leaves Claude a plain MCP server that simply offers no
-// tools rather than crashing the session.
-import { randomBytes } from "node:crypto";
-import { realpathSync } from "node:fs";
-import path from "node:path";
 import { fileURLToPath } from "node:url";
-
-import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-code";
-import { listSessionBindings } from "@agents-can-communicate/adapter-sdk";
-import { createCoordinationService } from "@agents-can-communicate/core";
-import { resolveClientPid } from "@agents-can-communicate/hook-runner/client-pid";
-import { readProcessTable } from "@agents-can-communicate/hook-runner/process-table";
-import { createId } from "@agents-can-communicate/protocol";
-import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
-import { createGitProbe, discoverWorkspace, platformDataHome, runtimePaths }
-  from "@agents-can-communicate/cli";
-
-import { createAccChannel, createInertChannel, endpointDir, routeAck, routeReply }
-  from "@agents-can-communicate/adapter-claude-code/channel";
-
-const clock = { now: () => new Date().toISOString() };
-const ids = { next: kind => createId(kind, randomBytes) };
-
-/**
- * The ACC session this Claude process opened - decided by which client process
- * this Channel is running under, never by how many sessions happen to be
- * visible.
- *
- * There used to be a fallback here: if exactly one session was live, it was
- * taken to be this one. On a single-session machine that looked safe, and with
- * two sessions it silently handed one client the other's identity. The Channel
- * starts while its own SessionStart hook is still writing its binding, so the
- * only binding a second client can see at that moment is the *first* client's -
- * and the wait that was added to survive that race then locks the wrong answer
- * in on the first attempt, because it is a complete, live, plausible binding.
- *
- * Measured on two real 2.1.259 sessions: both Channels registered an endpoint
- * under the first client's pid. `bindNativeSession` refuses two registrations
- * for one pid, so the session that had been receiving live messages dropped
- * back to the durable inbox - and an `acc_reply` from the second window would
- * have been recorded as the first session's answer, which is a false record
- * rather than a lost message.
- *
- * This process was spawned by its client, so its own ancestry names that
- * client, and no race can change that. Ownership is decided by it.
- */
-export async function resolveSession({ runtimeDir, service, env, ownClientPid,
-  listBindings = listSessionBindings }) {
-  if (!Number.isInteger(ownClientPid)) return null;
-  const bindings = await listBindings({ runtimeDir });
-  if (bindings.length === 0) return null;
-  const status = await service.collectStatus({});
-  const live = new Set(status.participants
-    .filter(participant => participant.presence !== "offline")
-    .map(participant => participant.sessionId));
-  const mine = bindings.filter(binding => live.has(binding.accSessionId)
-    && binding.clientPid === ownClientPid);
-  // One client process can outlive a session and open another, so the pid alone
-  // can still name two. The harness session id the client exports separates
-  // them; with nothing to separate them the answer is nobody, as before.
-  const exported = new Set(Object.values(env ?? {}).filter(value => typeof value === "string"));
-  const matched = mine.filter(binding => exported.has(binding.harnessSessionId));
-  const chosen = mine.length === 1 ? mine[0] : matched.length === 1 ? matched[0] : null;
-  return chosen === null ? null
-    : { sessionId: chosen.accSessionId, generation: chosen.generation, clientPid: chosen.clientPid };
-}
-
-/** The client process this Channel was spawned by, or null when nobody knows. */
-export async function ownClient({ table = null, from = process.pid,
-  command = createClaudeCodeAdapter().client.command } = {}) {
-  return resolveClientPid({ table: table ?? await readProcessTable(), from, command });
-}
-
-// How long the Channel will wait for the hook to publish this session's
-// binding. Claude spawns this child while SessionStart is still running - both
-// landed in the same second on a real 2.1.259 launch - and a single lookup
-// loses that race often enough to make native delivery activate or not per
-// launch. Bounded, because a session with no ACC binding must still be answered.
-const BINDING_WAIT_MS = 5_000;
-const BINDING_POLL_MS = 100;
-
-/**
- * The session binding, once it exists - or null when the wait runs out.
- *
- * A binding with no `clientPid` names no process, and the Channel binds an
- * exact one, so it does not count as resolved: the hook writes the identity
- * first and the certified facts after, and reading in between must keep waiting
- * rather than settle for the half-written answer.
- */
-export async function resolveWithin({ resolve, deadline, intervalMs = BINDING_POLL_MS,
-  now = () => Date.now(), sleep = ms => new Promise(resolve_ => setTimeout(resolve_, ms)) }) {
-  for (;;) {
-    const session = await resolve();
-    if (session !== null && Number.isInteger(session?.clientPid)) return session;
-    if (now() >= deadline) return null;
-    await sleep(intervalMs);
-  }
-}
-
-async function main() {
-  const descriptor = await discoverWorkspace({ cwd: process.cwd(), env: process.env,
-    gitProbe: createGitProbe() });
-  const paths = runtimePaths({ dataHome: platformDataHome({ platform: process.platform,
-    env: process.env }), workspaceId: descriptor.id, workspaceRoots: descriptor.roots });
-  const store = await openFilesystemStore({ root: paths.root, clock, ids,
-    workspaceId: descriptor.id });
-  const service = createCoordinationService({ store, clock, ids });
-  const write = payload => process.stdout.write(`${JSON.stringify(payload)}\n`);
-  // Read once: the ancestry that decides ownership cannot change while this
-  // process runs, and re-reading it on every poll would spawn `ps` in a loop.
-  const clientPid = await ownClient();
-  const session = await resolveWithin({
-    resolve: () => resolveSession({ runtimeDir: paths.root, service, env: process.env,
-      ownClientPid: clientPid }),
-    deadline: Date.now() + BINDING_WAIT_MS });
-  // No binding to serve - but Claude is already speaking MCP to this child, and
-  // returning here left the event loop empty: the process exited in 75ms
-  // without answering `initialize`, and Claude reported the server as failed to
-  // connect on every session that enables the plugin without ACC's shim.
-  if (session === null || !Number.isInteger(session.clientPid)) {
-    const inert = createInertChannel({ write });
-    pump(inert.handleLine, () => process.exit(0));
-    return inert;
-  }
-
-  const channel = createAccChannel({
-    endpointDir: endpointDir(paths.root),
-    clientPid: session.clientPid,
-    write,
-    routeReply: ({ messageId, body }) => routeReply({ service, session, messageId, body }),
-    routeAck: ({ messageId }) => routeAck({ service, session, messageId }),
-    // This process is the only party that knows the endpoint is still being
-    // served, and Claude publishes no heartbeat, so nothing else would move
-    // ACC's lease while the session sits idle - which is when live delivery is
-    // worth having.
-    refreshBinding: leaseUntil => service.refreshDeliveryBinding({
-      sessionId: session.sessionId, generation: session.generation, leaseUntil }),
-  });
-  await channel.listen();
-  pump(channel.handleLine, () => { channel.close(); process.exit(0); });
-  return channel;
-}
-
-/** One line-delimited JSON pump, for the bound server and the unbound one alike. */
-function pump(handleLine, shutdown) {
-  let buffer = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", async chunk => {
-    buffer += chunk;
-    let newline = buffer.indexOf("\n");
-    while (newline !== -1) {
-      const line = buffer.slice(0, newline).trim();
-      buffer = buffer.slice(newline + 1);
-      newline = buffer.indexOf("\n");
-      if (line !== "") await handleLine(line);
-    }
-  });
-  process.stdin.on("end", shutdown);
-  process.once("SIGTERM", shutdown);
-  process.once("SIGINT", shutdown);
-  // Keeps the child answerable for as long as Claude holds the transport open.
-  process.stdin.resume();
-}
-
-const invokedDirectly = typeof process.argv[1] === "string"
-  && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
-if (invokedDirectly) {
-  // Fail open: a Channel that cannot compose is simply absent, never a crash in
-  // front of the user's session.
-  await main().catch(() => { process.stdin.resume(); });
-}
+import { invokedDirectly, runEntry } from "@agents-can-communicate/cli/managed-entry";
+export const resolveSession = async options => (await import("./entrypoints/acc-claude-channel.mjs")).resolveSession(options);
+export const ownClient = async options => (await import("./entrypoints/acc-claude-channel.mjs")).ownClient(options);
+export const resolveWithin = async options => (await import("./entrypoints/acc-claude-channel.mjs")).resolveWithin(options);
+
+if (invokedDirectly(import.meta.url)) await runEntry({
+  kind: "acc-claude-channel", packageRoot: fileURLToPath(new URL("..", import.meta.url)),
+});

package/bin/acc-hook.mjs

@@ -1,137 +1,8 @@
 #!/usr/bin/env node
-// Hook entry point: `acc-hook <adapter-id> <kind>`, payload on stdin.
-//
-// Every harness runs this as a short-lived child process in front of the user's
-// turn. The one rule that overrides all others here: never be the reason
-// someone's session stops working. Unknown adapter, malformed payload, broken
-// store, missing binding - all of them end in "allow, exit 0".
-import { randomBytes } from "node:crypto";
-import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { invokedDirectly, runEntry } from "@agents-can-communicate/cli/managed-entry";
+export { writeOutput, completeHookOutput } from "./entrypoints/hook-output.mjs";
 
-import { createId } from "@agents-can-communicate/protocol";
-import { runHook } from "@agents-can-communicate/hook-runner";
-
-import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-code";
-import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
-import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
-import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
-import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-
-const adapters = {
-  claude_code: createClaudeCodeAdapter(),
-  codex: createCodexAdapter(),
-  gemini_cli: createGeminiCliAdapter(),
-  grok: createGrokAdapter(),
-  kimi: createKimiAdapter(),
-};
-
-const readStdin = () => new Promise(resolve => {
-  // A hook is always given its payload on stdin, but a client that closes it
-  // without writing must not leave this process hanging in front of a turn.
-  if (process.stdin.isTTY) return resolve("");
-  let raw = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", chunk => { raw += chunk; });
-  process.stdin.on("end", () => resolve(raw));
-  process.stdin.on("error", () => resolve(""));
-  return undefined;
+if (invokedDirectly(import.meta.url)) await runEntry({
+  kind: "acc-hook", packageRoot: fileURLToPath(new URL("..", import.meta.url)),
 });
-
-export const writeOutput = (stream, output, { deadlineAt } = {}) => {
-  if (output === "") return Promise.resolve();
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let timer;
-    const finish = error => {
-      if (settled) return;
-      settled = true;
-      if (timer !== undefined) clearTimeout(timer);
-      if (error === undefined || error === null) resolve();
-      else reject(error);
-    };
-    if (deadlineAt !== undefined) {
-      const remaining = deadlineAt - Date.now();
-      if (remaining <= 0) {
-        finish(new Error("hook budget exhausted before stdout write"));
-        return;
-      }
-      timer = setTimeout(() => finish(
-        new Error("hook budget exhausted waiting for stdout callback")), remaining);
-    }
-    try {
-      stream.write(output, finish);
-    } catch (error) {
-      finish(error);
-    }
-  });
-};
-
-const DIAGNOSTIC_BYTES = 512;
-
-function boundedDiagnostic(label, error) {
-  const detail = String(error?.message ?? error).replace(/[\u0000-\u001f\u007f]/g, " ");
-  let line = `acc: ${label}: ${detail}`;
-  while (Buffer.byteLength(`${line}\n`, "utf8") > DIAGNOSTIC_BYTES && line.length > 0) {
-    line = line.slice(0, -1);
-  }
-  return `${line}\n`;
-}
-
-function tryWrite(stream, output) {
-  if (output === "") return;
-  try {
-    stream.write(output, () => {});
-  } catch {
-    // A broken diagnostic stream must not turn a failed-open hook into a crash.
-  }
-}
-
-export async function completeHookOutput(result,
-  { stdout = process.stdout, stderr = process.stderr } = {}) {
-  try {
-    await writeOutput(stdout, result.stdout ?? "", { deadlineAt: result.deadlineAt });
-  } catch (error) {
-    tryWrite(stderr, boundedDiagnostic("stdout write failed", error));
-    return { exitCode: 0, wroteStdout: false, committedOffers: false };
-  }
-
-  let committedOffers = true;
-  try {
-    await result.commitOffers?.();
-  } catch (error) {
-    committedOffers = false;
-    tryWrite(stderr, boundedDiagnostic("offer commit failed", error));
-  }
-  if (result.stderr) tryWrite(stderr, `${result.stderr}\n`);
-  return { exitCode: 0, wroteStdout: true, committedOffers };
-}
-
-async function main() {
-  const [adapterId] = process.argv.slice(2);
-
-  let payload = null;
-  try {
-    payload = JSON.parse(await readStdin());
-  } catch {
-    payload = null;
-  }
-
-  const result = await runHook({ adapterId, payload, adapters,
-    runtime: { clock: { now: () => new Date().toISOString() },
-      ids: { next: kind => createId(kind, randomBytes) } },
-    env: process.env });
-
-  const completed = await completeHookOutput(result);
-  process.exitCode = result.exitCode ?? completed.exitCode;
-}
-
-let isMain = false;
-try {
-  isMain = process.argv[1] !== undefined
-    && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
-} catch {
-  isMain = false;
-}
-
-if (isMain) await main();