agents-can-communicate 0.5.9 → 0.6.0

package/node_modules/@agents-can-communicate/cli/src/install-command.mjs

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import path from "node:path";
 
+import { createAntigravityAdapter } from "@agents-can-communicate/adapter-antigravity";
 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";
@@ -27,7 +28,8 @@ export { decideDelivery } from "./install-delivery-consent.mjs";
 // Each client keeps its own directory under the user's home, and an adapter
 // pointed at the home itself writes beside them rather than inside them. That
 // install reports success and the client never reads a byte of it.
-export const clientContext = (home, stateRoot, { shell = null, env = {}, dataHome } = {}) => ({
+export const clientContext = (home, stateRoot,
+  { shell = null, env = {}, dataHome, cwd = process.cwd() } = {}) => ({
   home,
   ...(dataHome === undefined ? {} : { dataHome }),
   configDir: path.join(home, ".claude"),
@@ -42,6 +44,18 @@ export const clientContext = (home, stateRoot, { shell = null, env = {}, dataHom
   // shim would exec. Detection reads them; nothing here writes.
   shell,
   env,
+  // Antigravity CLI keeps its hooks in the `~/.gemini` tree Gemini CLI also
+  // uses, and reads none of the same files. Two locations load - the
+  // machine-wide `~/.gemini/config/hooks.json` and a project's own
+  // `.agents/hooks.json`, the second only while that project is an open
+  // workspace. Global is the default (issue #178), because a workspace
+  // registration in a folder nobody opened as one registers nothing and says
+  // nothing. ACC_ANTIGRAVITY_HOOKS is carried through exactly as it was set,
+  // wrong values included, so the adapter can refuse one by name rather than
+  // quietly installing somewhere else.
+  antigravityWorkspace: cwd,
+  antigravityHookLocation: typeof env.ACC_ANTIGRAVITY_HOOKS === "string"
+    && env.ACC_ANTIGRAVITY_HOOKS !== "" ? env.ACC_ANTIGRAVITY_HOOKS : "global",
   // Where ACC keeps its own state, for the client that has to be told. Codex
   // sandboxes the commands a model runs to the workspace, and ACC's state is
   // outside every workspace on purpose - so an agent there could read the
@@ -50,8 +64,8 @@ export const clientContext = (home, stateRoot, { shell = null, env = {}, dataHom
   stateRoot,
 });
 
-export const ALL_ADAPTERS = () => [createClaudeCodeAdapter(), createCodexAdapter(),
-  createGeminiCliAdapter(), createGrokAdapter(), createKimiAdapter()];
+export const ALL_ADAPTERS = () => [createAntigravityAdapter(), createClaudeCodeAdapter(),
+  createCodexAdapter(), createGeminiCliAdapter(), createGrokAdapter(), createKimiAdapter()];
 
 /**
  * How long to wait for a client to say its version.

package/node_modules/@agents-can-communicate/cli/src/main.mjs

@@ -24,6 +24,7 @@ import { canonicalClaim } from "./claim-spelling.mjs";
 import { platformDataHome, runtimePaths } from "./runtime-paths.mjs";
 import { resolveOwner } from "./session-owner.mjs";
 import { discoverWorkspace } from "./workspace-discovery.mjs";
+import { resolveSavedHookWorkspace } from "./hook-workspace.mjs";
 
 const DEFAULT_CADENCE_MS = 30_000;
 
@@ -68,14 +69,17 @@ async function claimOn(options, context) {
  * looking is safe.
  */
 async function locateContext(options, runtime) {
-  const descriptor = await discoverWorkspace({
+  const dataHome = runtime.dataHome ?? platformDataHome({ platform: runtime.platform,
+    env: runtime.env });
+  const discovery = {
     cwd: options.cwd ?? runtime.cwd,
     env: runtime.env,
     gitProbe: runtime.gitProbe ?? createGitProbe(),
     explicitConfig: options.workspace,
-  });
-  const dataHome = runtime.dataHome ?? platformDataHome({ platform: runtime.platform,
-    env: runtime.env });
+  };
+  const saved = await resolveSavedHookWorkspace({ ...discovery, dataHome,
+    reference: options.workspace });
+  const descriptor = saved?.descriptor ?? await discoverWorkspace(discovery);
   const paths = runtimePaths({
     dataHome,
     workspaceId: descriptor.id,

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/command-prefix.mjs

@@ -0,0 +1,26 @@
+// Shared with CLI parsing, but dependency-free: immutable launchers cannot load
+// workspace modules before runtime admission. Consume values, never search for
+// command words that might appear inside a path or a message.
+export const GLOBAL_OPTIONS = Object.freeze(["json", "workspace", "cwd"]);
+
+export function commandPrefix(argv) {
+  const leading = [];
+  let offset = 0;
+  while (offset < argv.length) {
+    const token = argv[offset];
+    const name = token.startsWith("--") ? token.slice(2).split("=", 1)[0] : "";
+    if (!GLOBAL_OPTIONS.includes(name)) break;
+    leading.push(token);
+    offset += 1;
+    if (name !== "json" && !token.includes("=")) {
+      const value = argv[offset];
+      if (value === undefined || value.startsWith("--")
+        && GLOBAL_OPTIONS.includes(value.slice(2).split("=", 1)[0])) {
+        return { error: `option --${name} requires a value` };
+      }
+      leading.push(value);
+      offset += 1;
+    }
+  }
+  return { command: argv[offset], leading, rest: argv.slice(offset + 1) };
+}

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/entry.mjs

@@ -4,9 +4,10 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { scheduleWorker } from "./schedule.mjs";
 import { acquireRuntime } from "./leases.mjs";
 import { canonicalManagerRoot, readControl, readManagedJson } from "./state.mjs";
+import { commandPrefix } from "./command-prefix.mjs";
 
 export const ENTRY_KINDS = Object.freeze([
-  "acc", "acc-hook", "acc-mcp", "acc-bootstrap", "acc-claude-channel",
+  "acc", "acc-hook", "acc-mcp", "acc-bootstrap", "acc-claude-channel", "acc-antigravity-relay",
 ]);
 
 const BOOTSTRAP_FLAGS = new Map([["--adapter", "adapter"], ["--real-executable", "realExecutable"],
@@ -42,7 +43,7 @@ export function invokedDirectly(url) {
 
 function unavailable(kind) {
   // Never reflect control file content or payloads into a client diagnostic.
-  if (kind === "acc-hook" || kind === "acc-claude-channel") {
+  if (kind === "acc-hook" || kind === "acc-claude-channel" || kind === "acc-antigravity-relay") {
     process.stderr.write("acc: coordination unavailable during runtime update; session may continue\n");
     process.exitCode = 0;
   } else if (kind === "acc-bootstrap") {
@@ -81,6 +82,7 @@ async function updateImplementation(packageRoot, control) {
 /** The lease lasts until OS process death, including callbacks after main returns. */
 export async function runEntry({ kind, packageRoot, managerRoot, managedRequired = false }) {
   if (!ENTRY_KINDS.includes(kind)) throw new Error("unknown ACC entry point");
+  const command = kind === "acc" ? commandPrefix(process.argv.slice(2)).command : null;
   const bootstrapOptions = kind === "acc-bootstrap" ? parseBootstrapOptions(process.argv.slice(2)) : null;
   if (kind === "acc-bootstrap" && bootstrapOptions === null) {
     if (process.env.ACC_BOOTSTRAP_DEBUG === "1") {
@@ -107,7 +109,7 @@ export async function runEntry({ kind, packageRoot, managerRoot, managedRequired
     if (control !== null) {
       selected = control.active.root;
       managed = root;
-      const update = kind === "acc" && ["update", "doctor"].includes(process.argv[2])
+      const update = kind === "acc" && ["update", "doctor"].includes(command)
         ? await updateImplementation(packageRoot, control) : null;
       if (update !== null) {
         selected = update;
@@ -116,7 +118,7 @@ export async function runEntry({ kind, packageRoot, managerRoot, managedRequired
         const lease = await acquireRuntime(root, { pid: process.pid, kind });
         selected = lease.runtime.root;
         const quiet = kind === "acc" && ["update", "install", "uninstall", "help", "version",
-          "--help", "-h", "--version", "-v", "-V"].includes(process.argv[2]);
+          "--help", "-h", "--version", "-v", "-V"].includes(command);
         if (!quiet) await scheduleWorker(root, control);
       }
     } else if (managedRequired) throw new Error("managed runtime is not initialized");

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/launchers.mjs

@@ -4,7 +4,8 @@ import path from "node:path";
 import { ENTRY_KINDS } from "./entry.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
-const MODULES = ["entry.mjs", "state.mjs", "generation-files.mjs", "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs"];
+const MODULES = ["entry.mjs", "command-prefix.mjs", "state.mjs", "generation-files.mjs",
+  "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs"];
 async function durableFile(file, bytes, mode = 0o600) {
   const handle = await open(file, "wx", mode);
   try { await handle.writeFile(bytes); await handle.sync(); }
@@ -15,6 +16,7 @@ export const stablePaths = root => ({
   cli: path.join(root, "bin", "acc.mjs"), runner: path.join(root, "bin", "acc-hook.mjs"),
   bootstrap: path.join(root, "bin", "acc-bootstrap.mjs"),
   channel: path.join(root, "bin", "acc-claude-channel.mjs"),
+  antigravityRelay: path.join(root, "bin", "acc-antigravity-relay.mjs"),
 });
 
 /** Publish immutable launcher modules, then atomically replace each tiny entry.

package/node_modules/@agents-can-communicate/cli/src/session-owner.mjs

@@ -15,6 +15,23 @@ const unresolved = command => new AccError(EXIT.USAGE,
   + "session IDs and a shared checkout do not establish CLI ownership.",
   { command, reasonCode: "caller_identity_unresolved" });
 
+async function observationOwner(options, context) {
+  if (options.session === undefined) return null;
+  const existing = await context.service.locateSession(options.session);
+  if (existing === null) {
+    throw new AccError(EXIT.CONFLICT,
+      "the selected session is absent from this workspace; use --cwd from the ACC hook header "
+      + "or the directory where your manual session attached. Do not attach a replacement to recover context.",
+      { reasonCode: "caller_workspace_mismatch", sessionId: options.session,
+        workspaceId: context.descriptor.id });
+  }
+  if (options.generation !== undefined && existing.record.generation !== options.generation) {
+    throw new AccError(EXIT.CONFLICT, "cannot observe as a replaced session generation",
+      { reasonCode: "caller_generation_mismatch", sessionId: options.session });
+  }
+  return existing.record;
+}
+
 /**
  * Accept caller-supplied credentials; never discover credentials from peers.
  *
@@ -30,22 +47,26 @@ export async function resolveOwner({ command, options, context, env = {} }) {
   const explicit = options.session !== undefined && options.generation !== undefined;
   const configured = typeof env.ACC_SESSION === "string" && typeof env.ACC_GENERATION === "string";
   if (!explicit && !configured) {
-    if (soft) return options;
+    if (soft) {
+      await observationOwner(options, context);
+      return options;
+    }
     throw unresolved(command);
   }
 
   const owner = explicit ? options : { session: env.ACC_SESSION, generation: env.ACC_GENERATION };
   if (options.session !== undefined && options.session !== owner.session) {
     // A public observation scope is allowed; it does not request credentials.
-    if (soft) return options;
+    if (soft) {
+      await observationOwner(options, context);
+      return options;
+    }
     throw unresolved(command);
   }
   // A supplied generation must reach the core unchanged so stale calls fail.
   const resolved = { ...options, session: owner.session,
     generation: options.generation ?? owner.generation };
-  if (command === "status" && options.participant === undefined) {
-    const { participants } = await context.service.collectStatus({});
-    resolved.participant = participants.find(item => item.sessionId === owner.session)?.participantId;
-  }
+  const observed = soft ? await observationOwner(resolved, context) : null;
+  if (command === "status" && options.participant === undefined) resolved.participant = observed.participantId;
   return resolved;
 }

package/node_modules/@agents-can-communicate/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/delivery-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/src/native-attempt.mjs

@@ -41,3 +41,34 @@ export async function bindNative({ adapter, event, hookBinding, clientVersion, p
   }
   return result;
 }
+
+const HINT_MAX_BYTES = 512;
+const HINT_MAX_MS = 250;
+
+/**
+ * One line an adapter asks the agent to act on, when the agent itself can fix
+ * a degraded native binding - Antigravity's relay is started from the agent's
+ * own shell, and nothing else can start it. Bounded and fail-open: a slow or
+ * failing adapter costs the turn nothing, and anything but one short line is
+ * dropped rather than trusted into model context.
+ */
+export async function nativeActivationHintFor({ adapter, event, nativeBinding, binding, context,
+  paths, deadline }) {
+  if (typeof adapter?.nativeActivationHint !== "function" || nativeBinding?.state !== "degraded") return null;
+  const budget = Math.min(HINT_MAX_MS, deadline - Date.now() - HINT_MAX_MS);
+  if (budget <= 0) return null;
+  let timer = null;
+  try {
+    const line = await Promise.race([
+      Promise.resolve(adapter.nativeActivationHint({ event, nativeBinding, runtimeDir: paths.root,
+        clientPid: binding?.clientPid, env: context.env })),
+      new Promise(resolve => { timer = setTimeout(resolve, budget, null); }),
+    ]);
+    return typeof line === "string" && line !== "" && !/[\r\n]/.test(line)
+      && Buffer.byteLength(line, "utf8") <= HINT_MAX_BYTES ? line : null;
+  } catch {
+    return null;
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+  }
+}

package/node_modules/@agents-can-communicate/hook-runner/src/owner-context.mjs

@@ -1,8 +1,11 @@
 import { assertPortableId } from "@agents-can-communicate/protocol";
 
-export const ownerHeader = binding => "ACC CLI (append): --session "
+const shellQuote = value => `'${value.replaceAll("'", "'\\''")}'`;
+
+export const ownerHeader = (binding, cwd, workspaceRef) => "ACC CLI (append): --session "
   + assertPortableId(binding.accSessionId, "sessionId") + " --generation "
-  + assertPortableId(binding.generation, "generation");
+  + assertPortableId(binding.generation, "generation") + " --cwd " + shellQuote(cwd)
+  + (workspaceRef === undefined ? "" : " --workspace " + shellQuote(workspaceRef));
 
 export function ownerOnlyOutcome(inject, owner, budgetBytes) {
   if (Buffer.byteLength(owner, "utf8") > budgetBytes) {
@@ -20,7 +23,7 @@ export async function appendToolOwner(result, { event, binding, context, adapter
   const current = await context.service.locateSession(binding.accSessionId, context.descriptor.id);
   if (current?.record.state !== "open" || current.record.generation !== binding.generation) return result;
 
-  const owner = ownerHeader(binding);
+  const owner = ownerHeader(binding, context.workspaceCwd, context.workspaceRef);
   const injected = adapter.injectToolOwnerOutcome({ owner, tool: event.tool });
   if (injected === null) return result;
   const fitted = ownerOnlyOutcome(() => injected, owner,
@@ -28,3 +31,13 @@ export async function appendToolOwner(result, { event, binding, context, adapter
   return { ...result, stdout: fitted.stdout,
     stderr: [result.stderr, fitted.stderr].filter(Boolean).join("\n") };
 }
+
+// SessionStart can also be a context reset. Return the binding just resumed by
+// the hook; never require the model to remember it or attach another session.
+export function appendStartOwner(result, { event, context, adapter }) {
+  if (event.kind !== "sessionStart" || result.accSessionId === undefined
+    || typeof adapter.injectStartOwnerOutcome !== "function") return result;
+  return { ...result, ...ownerOnlyOutcome(text => adapter.injectStartOwnerOutcome(text),
+    ownerHeader(result, context.workspaceCwd, context.workspaceRef),
+    context.descriptor.policy?.contextBudgetBytes ?? 6_000) };
+}

package/node_modules/@agents-can-communicate/hook-runner/src/runner.mjs

@@ -9,15 +9,15 @@ import { clearNativeAttempt, clearSessionBinding, effectiveCapabilities, loadSes
 import { createCoordinationService } from "@agents-can-communicate/core";
 import { AccError, createId } from "@agents-can-communicate/protocol";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
-import { clearPin, createGitProbe, discoverWorkspace, platformDataHome, runtimePaths, writePin }
+import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runtimePaths, writePin }
   from "@agents-can-communicate/cli";
 
 import { resolveClientPid } from "./client-pid.mjs";
 import { probeClientVersion as defaultProbeClientVersion } from "./client-version.mjs";
-import { bindNative, nativeDiagnosticDeadline } from "./native-attempt.mjs";
+import { bindNative, nativeActivationHintFor, nativeDiagnosticDeadline } from "./native-attempt.mjs";
 import { readProcessTable as defaultReadProcessTable } from "./process-table.mjs";
 import { withSessionLifecycle } from "./session-lifecycle.mjs";
-import { appendToolOwner, ownerHeader, ownerOnlyOutcome } from "./owner-context.mjs";
+import { appendStartOwner, appendToolOwner, ownerHeader, ownerOnlyOutcome } from "./owner-context.mjs";
 
 // Kept cohesive above 300 lines because every handler shares one fail-open
 // hook boundary, binding lifecycle, and client-specific outcome contract.
@@ -211,12 +211,13 @@ async function runtimeFacts(fromUrl) {
 // unreachable from there.
 const managerRootFor = dataHome => path.join(dataHome, "acc", "runtime");
 
-async function openContext({ cwd, dataHome, runtime, env, deadline }) {
+async function openContext({ event, adapterId, dataHome, runtime, env, deadline }) {
   assertHookBudget(deadline);
-  const descriptor = await discoverWorkspace({ cwd, env: env ?? {},
+  const resolvedDataHome = dataHome ?? platformDataHome({ env: env ?? {} });
+  const { descriptor, workspaceCwd, workspaceRef } = await resolveHookWorkspace({ adapterId, event,
+    dataHome: resolvedDataHome, env: env ?? {}, clock: runtime.clock, deadlineAt: deadline,
     gitProbe: createGitProbe({ deadlineAt: deadline }) });
   assertHookBudget(deadline);
-  const resolvedDataHome = dataHome ?? platformDataHome({ env: env ?? {} });
   const paths = runtimePaths({
     dataHome: resolvedDataHome,
     workspaceId: descriptor.id,
@@ -224,13 +225,17 @@ async function openContext({ cwd, dataHome, runtime, env, deadline }) {
   });
   const store = await openFilesystemStore({ root: paths.root, clock: runtime.clock,
     ids: runtime.ids, workspaceId: descriptor.id, deadlineAt: deadline });
-  return { descriptor, paths, dataHome: resolvedDataHome, env: env ?? {}, realpath: runtime.realpath ?? realpath,
+  return { descriptor, paths, workspaceCwd, workspaceRef,
+    dataHome: resolvedDataHome, env: env ?? {}, realpath: runtime.realpath ?? realpath,
     service: createCoordinationService({ store, clock: runtime.clock, ids: runtime.ids }) };
 }
 
 // What this turn is shown and which complete groups it may commit as
 // offered. Runs after the heartbeat and the bounded native retry.
-async function projectTurn({ binding, context, adapter, adapterId }) {
+// `render` is how the projected text reaches this client: before a turn it is
+// the adapter's context envelope, at the end of one it is a continuation.
+async function projectTurn({ binding, context, adapter, adapterId,
+  render = text => adapter.injectOutcome?.(text), activationHint = null }) {
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
     cursor: null, scope: "delta" });
 
@@ -253,8 +258,14 @@ async function projectTurn({ binding, context, adapter, adapterId }) {
   // Only this hook's payload selected the binding. Supply its own pair as
   // trusted context, outside peer bodies, rather than exporting inheritable
   // credentials or teaching the CLI to guess from a public roster.
-  const owner = ownerHeader(binding);
   const totalBudget = context.descriptor.policy?.contextBudgetBytes ?? 6_000;
+  // An adapter's one-line ask rides with the owner line, which every projected
+  // turn carries - and only when both fit in half the budget, so peer bodies
+  // always keep the rest.
+  const header = ownerHeader(binding, context.workspaceCwd, context.workspaceRef);
+  const owner = activationHint === null
+    || byteLength(header) + 1 + byteLength(activationHint) > totalBudget / 2
+    ? header : `${header}\n${activationHint}`;
   // A peer can join after this prompt has begun. The current turn must already
   // have its own arguments when it needs inbox/reply, without reattaching or
   // waiting for another user prompt. Solo emits identity, not a peer notice.
@@ -330,7 +341,7 @@ async function projectTurn({ binding, context, adapter, adapterId }) {
   // The entry point owns the transport boundary. This handler only prepares
   // offer inputs; recording them here would claim delivery before stdout's
   // callback proves that the bytes crossed.
-  const outcome = { stdout: "", ...adapter.injectOutcome?.(projected) };
+  const outcome = { stdout: "", ...render(projected) };
   const writableOffers = outcome.stdout === "" ? [] : offerInputs;
   return { ...outcome,
     stderr: [outcome.stderr, ownerWarning, degradation].filter(Boolean).join("\n"),
@@ -483,7 +494,9 @@ const HANDLERS = {
       const started = await HANDLERS.sessionStart(input);
       const fresh = await loadSessionBinding({ runtimeDir: paths.root,
         harnessSessionId: event.sessionId });
-      const turn = await projectTurn({ ...input, binding: fresh });
+      const activationHint = await nativeActivationHintFor({ adapter, event,
+        nativeBinding: started.nativeBinding, binding: fresh, context, paths, deadline });
+      const turn = await projectTurn({ ...input, binding: fresh, activationHint });
       return { ...turn, nativeBinding: started.nativeBinding };
     }
     const current = await context.service.locateSession(binding.accSessionId);
@@ -497,7 +510,9 @@ const HANDLERS = {
       const started = await HANDLERS.sessionStart(input);
       const fresh = await loadSessionBinding({ runtimeDir: paths.root,
         harnessSessionId: event.sessionId });
-      const turn = await projectTurn({ ...input, binding: fresh });
+      const activationHint = await nativeActivationHintFor({ adapter, event,
+        nativeBinding: started.nativeBinding, binding: fresh, context, paths, deadline });
+      const turn = await projectTurn({ ...input, binding: fresh, activationHint });
       return { ...turn, nativeBinding: started.nativeBinding };
     }
     // A turn is the clearest sign a session is alive. Never a reason to fail:
@@ -509,10 +524,38 @@ const HANDLERS = {
     const nativeBinding = await bindNative({ adapter, event, hookBinding: binding,
       clientVersion: binding.clientVersion, platform: binding.platform, context, paths,
       deadline });
-    const turn = await projectTurn(input);
+    const activationHint = await nativeActivationHintFor({ adapter, event, nativeBinding,
+      binding, context, paths, deadline });
+    const turn = await projectTurn({ ...input, activationHint });
     return nativeBinding === undefined ? turn : { ...turn, nativeBinding };
   },
 
+  /**
+   * The end of a turn, for a client that can hold one open.
+   *
+   * A peer message that arrives while the model is producing its last answer
+   * has no next invocation to ride on, and would otherwise wait for the next
+   * user prompt - which can be hours. A client whose end-of-turn hook can
+   * continue the turn (`continueTurnOutcome`) gets that message now instead.
+   *
+   * Only for peer bodies the projector actually offers. Continuing a turn costs
+   * the operator a model invocation, so an owner header, an attention count or
+   * a degradation notice is never a reason to. The adapter owns the shape and
+   * the ceiling, and reads its own counter from the payload handed back to it;
+   * when it declines, it prints nothing, no offer is recorded, and the body
+   * stays queued for the next invocation. Every failure ends the turn normally.
+   */
+  async turnEnd(input) {
+    const { binding, context, adapter, payload } = input;
+    if (typeof adapter.continueTurnOutcome !== "function" || binding === null) return {};
+    const current = await context.service.locateSession(binding.accSessionId);
+    if (current === null || current.record.state !== "open"
+      || current.record.generation !== binding.generation) return {};
+    const turn = await projectTurn({ ...input,
+      render: text => adapter.continueTurnOutcome({ reason: text, payload }) });
+    return (turn.offerInputs ?? []).length === 0 ? {} : turn;
+  },
+
   async beforeTool({ binding, context, event, adapter }) {
     if (binding === null) return { decision: "allow" };
     if (event.targets.length === 0) {
@@ -580,6 +623,13 @@ const HANDLERS = {
  * only thing this function refuses to do is fail closed.
  */
 export async function runHook({ adapterId, payload, adapters, dataHome, env,
+  // The arguments the client's hook command carried, after the adapter id.
+  // Most clients name the event inside the payload and their adapters ignore
+  // this; Antigravity CLI sends no `hook_event_name` at all, and two of its
+  // four events hand over byte-identical envelopes - so for that client the
+  // registered command's own argument is the only thing that knows which hook
+  // ran. Passed to every adapter, read by the ones that need it.
+  args = [],
   runtime = defaultRuntime(), budgetMs = DEFAULT_BUDGET_MS,
   readProcessTable = defaultReadProcessTable,
   probeClientVersion = defaultProbeClientVersion,
@@ -592,8 +642,8 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     const adapter = adapters?.[adapterId];
     if (adapter === undefined) throw new Error(`no adapter named ${adapterId}`);
 
-    const event = await adapter.normalizeHook(payload);
-    const context = await openContext({ cwd: event.cwd, dataHome, runtime, env, deadline });
+    const event = await adapter.normalizeHook(payload, { args });
+    const context = await openContext({ event, adapterId, dataHome, runtime, env, deadline });
     const handler = HANDLERS[event.kind];
     const lifecycle = ["sessionStart", "sessionEnd", "beforeTurn"].includes(event.kind);
     const invoke = async () => {
@@ -608,10 +658,13 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
       const binding = await loadSessionBinding({ runtimeDir: context.paths.root,
         harnessSessionId: event.sessionId });
       assertHookBudget(deadline);
+      // The raw payload goes to a handler only to be handed back to the adapter
+      // that produced it; nothing in core reads it.
       const result = handler === undefined ? {} : await handler({ event, context, adapter, adapterId,
-        binding, paths: context.paths,
+        binding, paths: context.paths, payload,
         readProcessTable, probeClientVersion, platform, deadline });
-      return appendToolOwner(result, { event, binding, context, adapter });
+      return appendToolOwner(appendStartOwner(result, { event, context, adapter }),
+        { event, binding, context, adapter });
     };
     const work = lifecycle
       ? withSessionLifecycle({ root: context.paths.root, sessionId: event.sessionId,

package/node_modules/@agents-can-communicate/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/installer/src/detect.mjs

@@ -159,6 +159,10 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
       try {
         const detected = await adapter.detect({ ...context, clientVersion: entry.version,
           platform, nativeDelivery: entry.nativeDelivery });
+        // An adapter that knows it cannot be installed right now says so here,
+        // rather than by throwing out of install and taking every other client
+        // on the machine down with it.
+        if (detected.blocked) entry.blocked = detected.blocked;
         if (detected.outgoingDelivery) entry.outgoingDelivery = detected.outgoingDelivery;
         if (detected.nativeSetup) entry.nativeSetup = detected.nativeSetup;
         entry.diagnostics = [...(detected.diagnostics ?? [])];

package/node_modules/@agents-can-communicate/installer/src/plan.mjs

@@ -78,6 +78,16 @@ export function planInstallation({ adapters, detected, context, action = "instal
           + `if it is, wire it with --adapter ${entry.adapterId}` });
       continue;
     }
+    // An adapter can refuse itself for a reason that is nobody's fault and that
+    // no file on disk shows: Antigravity CLI cannot be wired until somebody
+    // picks between a machine-wide and a per-workspace hook registration. It is
+    // skipped by name so the rest of the run proceeds - but never when ACC has
+    // a record for it, because that record is the only account of what was
+    // written and an unremovable install is the worse failure.
+    if (entry.blocked !== undefined && recordedById.get(entry.adapterId) === undefined) {
+      skipped.push({ adapterId: entry.adapterId, reason: entry.blocked.reason });
+      continue;
+    }
     // The version doing the installing is whichever `acc` came first on PATH,
     // and the shim it writes pins that copy's node and runner. So a second ACC
     // on the machine quietly replaces every client's wiring with its own, older

package/node_modules/@agents-can-communicate/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/protocol",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/storage-filesystem/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/storage-filesystem",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 6,
   "type": "module",
@@ -70,6 +70,7 @@
     "LICENSE"
   ],
   "dependencies": {
+    "@agents-can-communicate/adapter-antigravity": "*",
     "@agents-can-communicate/adapter-claude-code": "*",
     "@agents-can-communicate/adapter-codex": "*",
     "@agents-can-communicate/adapter-gemini-cli": "*",
@@ -86,6 +87,7 @@
     "@agents-can-communicate/storage-filesystem": "*"
   },
   "bundleDependencies": [
+    "@agents-can-communicate/adapter-antigravity",
     "@agents-can-communicate/adapter-claude-code",
     "@agents-can-communicate/adapter-codex",
     "@agents-can-communicate/adapter-gemini-cli",