agents-can-communicate 0.10.4 → 0.11.1

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

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import path from 'node:path';
+import {configureTomlIndicator,indicatorCommand,compareVersionOrder,versionOrder} from '@agents-can-communicate/adapter-sdk';
+import {grokIndicator} from './indicator.mjs';
+
+export const grokIndicatorPaths = context => {
+ const root=context.grokHome??path.join(context.home,'.grok');
+ return {file:path.join(root,'config.toml'),marker:path.join(context.dataHome??root,'acc','adapter-grok','indicator.json'),
+  shim:path.join(root,'hooks','acc-indicator.mjs')};
+};
+export async function configureGrokIndicator(context,enabled) {
+ const paths=grokIndicatorPaths(context);
+
+ if(enabled&&!supportsGrokIndicator(context))return [];
+ return configureTomlIndicator({...paths,table:['ui','status_line'],enabled,set:async()=>({type:'command',command:enabled?await indicatorCommand({context,adapterId:'grok',...paths,shell:'portable'}):''}),defaults:{refresh_interval:1}});
+}
+
+export const preflightGrokIndicator = context => configureTomlIndicator({...grokIndicatorPaths(context),table:['ui','status_line'],enabled:false,dryRun:true});
+
+function supportsGrokIndicator(context) {
+ return typeof context.clientVersion === "string"
+  && compareVersionOrder(versionOrder(context.clientVersion), versionOrder(grokIndicator.minimumVersion)) >= 0;
+}
+
+export function planGrokIndicator(context) {
+ const paths = grokIndicatorPaths(context);
+ if (context.indicator === "on" ? !supportsGrokIndicator(context) : !existsSync(paths.marker)) return [];
+ return [{path: paths.file, kind: "merge"},
+  ...(context.indicator === "on" && context.hostPlatform === "win32" ? [{path: paths.shim, kind: "tree"}] : [])];
+}

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

@@ -0,0 +1,23 @@
+import {indicatorGlyph,footerText} from '@agents-can-communicate/adapter-sdk';
+
+export const grokIndicator = {
+ minimumVersion:'1.0.46', reload:'start a new Grok session',
+ nativeSessionId: payload=>payload.session_id,
+ renderText:indicatorGlyph,
+ composeText({payload={},indicator,previous='',settings={}}) {
+  const cwd=footerText(payload.workspace?.current_dir??payload.cwd).split(/[\\/]/).filter(Boolean).at(-1);
+  const percent=payload.context_window?.used_percentage;
+  const cost=payload.cost?.total_cost_usd;
+  const started=payload.turn?.started_at_ms;
+  const elapsed=Number.isFinite(started)?Date.now()-started:NaN;
+  const slots={cwd,model:footerText(payload.model?.display_name??payload.model?.id),
+   context:Number.isFinite(percent)?`${Math.round(percent)}% ctx`:'',
+   cost:Number.isFinite(cost)&&cost>=0.005?`$${cost.toFixed(2)}`:'',
+   'turn-timer':Number.isFinite(elapsed)&&elapsed>=1000?`${Math.floor(elapsed/1000)}s`:'',
+   'session-name':footerText(payload.session_name)};
+  const items=Array.isArray(settings.items)?settings.items:['cwd','model','context'];
+  const base=previous.trimEnd() || items.map(id=>slots[id]).filter(Boolean).join(' │ ');
+  const [first,...rest]=base.split(/\r?\n/);
+  return [[indicator,first].filter(Boolean).join(' │ '),...rest].join('\n');
+ },
+};

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

@@ -1,3 +1,4 @@
+import {configureGrokIndicator, planGrokIndicator} from "./indicator-install.mjs";
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -64,9 +65,10 @@ const withShim = (wiring, shim, windowsNode = null) => ({
     }))])),
 });
 
-export async function installGrokHooks({ grokHome, home, runner, cli, node,
-  hostPlatform = process.platform }) {
+export async function installGrokHooks(context) {
+  const {grokHome, home, runner, cli, node, hostPlatform = process.platform} = context;
   const root = grokHome ?? grokHomeOf({ home, grokHome });
+  const indicatorChanges = await configureGrokIndicator(context, context.indicator === "on");
   const template = await readJson(path.join(bundle, "hooks", "hooks.json"), { hooks: {} });
   const shim = await writeHookShim({ dir: path.join(root, "hooks"), adapterId: "grok",
     runner, node, name: SHIM_NAME, platform: hostPlatform });
@@ -80,12 +82,13 @@ export async function installGrokHooks({ grokHome, home, runner, cli, node,
 
   await writeJson(hooksFile(root), withShim(template, shim,
     hostPlatform === "win32" ? node ?? process.execPath : null));
-  return { ok: true, changes: [hooksFile(root), shim, skills], diagnostics: [] };
+  return { ok: true, changes: [hooksFile(root), shim, skills, ...indicatorChanges], diagnostics: [] };
 }
 
-export async function uninstallGrokHooks({ grokHome, home, keep = [], hostPlatform }) {
+export async function uninstallGrokHooks(context) {
+  const {grokHome, home, keep = [], hostPlatform} = context;
   const root = grokHome ?? grokHomeOf({ home, grokHome });
-  const changes = [];
+  const changes = await configureGrokIndicator(context, false);
   for (const target of [hooksFile(root), shimPath(root, hostPlatform), skillPath(root)]) {
     if (await removeInstalledTree(target, keep)) changes.push(target);
   }
@@ -106,6 +109,7 @@ export async function detectGrok({ grokHome, home }) {
 export function planGrokInstall(context) {
   const root = grokHomeOf(context);
   return [
+    ...planGrokIndicator(context),
     { path: hooksFile(root), kind: "tree" },
     { path: shimPath(root, context.hostPlatform), kind: "tree" },
     { path: skillPath(root), kind: "tree" },

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-kimi",
-  "version": "0.10.4",
+  "version": "0.11.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -57,19 +57,43 @@ Do this once, not every turn. Update it only when the scope or mode materially
 changes. `--hint` is important: it lets ACC match your plan against a peer's
 claim. Intent is awareness, not permission.
 
-Before changing shared files, claim the smallest useful resource:
+Before changing shared files, claim the smallest useful resources in one operation:
 
 ```bash
-{{ACC}} claim --resource 'file:packages/core/**' --reason "porting the store"
+{{ACC}} claim --resource 'file:packages/core/**' \
+  --resource 'file:packages/protocol/**' --reason "porting the claim model"
 ```
 
-Exit 5 means a conflict. Do not work around it silently. Narrow your scope,
-contact the owner, or ask the human. Give a claim back explicitly when useful:
+Repeat `--resource` for an atomic batch, or supply it once for one claim.
+Shared mode, enforcement, reason, and lease apply to every resource. Duplicate resources after
+normalization are rejected. Exit 5 means a conflict: no claim is created or
+renewed. Batch `details.conflicts` names blocked resources and their holders.
+Narrow your scope, contact the owner, or ask the human. Repeating a successful
+claim command renews your existing claims on those resources.
+
+Release selected claims when useful:
 
 ```bash
-{{ACC}} release --resource 'file:packages/core/**'
+{{ACC}} release --resource 'file:packages/core/**' \
+  --resource 'file:packages/protocol/**'
 ```
 
+Choose exactly one selector family: repeated `--resource`, repeated `--claim`,
+or `--all`. Duplicate selectors after normalization are rejected. A missing or
+foreign explicit target fails without releasing any claims. Repeating an explicit release after its targets were removed is an error.
+Batch release accepts no force-release authority.
+
+To release all your claims while keeping your session and intent open:
+
+```bash
+{{ACC}} release --all
+```
+
+This selects only your session's current claims in its workspace. An empty set
+succeeds. Each retry selects the current set and can release newly acquired claims.
+Use `work --clear` to clear intent, `ack` to acknowledge a message, and `finish`
+to record a handoff and close your ACC presence.
+
 ## Communicate only when it changes another agent's work
 
 Send a message for a dependency, conflict, direct question, decision, or

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

@@ -1,3 +1,5 @@
+import { preflightKimiIndicator } from "./indicator-install.mjs";
+import { kimiIndicator } from "./indicator.mjs";
 import { defineAdapter, projectContext, projectContextResult }
   from "@agents-can-communicate/adapter-sdk";
 import certification from "../certification.json" with { type: "json" };
@@ -28,6 +30,7 @@ export const KIMI_CODE_VERSION = "0.36.1";
 export function createKimiAdapter() {
   return defineAdapter({
     id: "kimi",
+    statusIndicator: kimiIndicator,
     displayName: "Kimi Code",
     // The binary this client actually installs. Probed for a version to
     // decide whether the client is on this machine, so it has to be the
@@ -57,6 +60,7 @@ export function createKimiAdapter() {
     planInstall: context => planKimiInstall(forClient(context)),
     detect: context => detectKimi(forClient(context)),
     install: context => installKimiPlugin(forClient(context)),
+    preflightUninstall: context => preflightKimiIndicator(forClient(context)),
     uninstall: context => uninstallKimiPlugin(forClient(context)),
 
     doctor: async context => {

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

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import path from 'node:path';
+import {configureTomlIndicator,indicatorCommand,compareVersionOrder,versionOrder} from '@agents-can-communicate/adapter-sdk';
+import {kimiIndicator} from './indicator.mjs';
+
+export const kimiIndicatorPaths = context => ({
+ file:path.join(context.home,'tui.toml'),
+ marker:path.join(context.dataHome??context.home,'acc','adapter-kimi','indicator.json'),
+ shim:path.join(context.home,'acc','indicator.mjs'),
+});
+export async function configureKimiIndicator(context,enabled) {
+ const paths=kimiIndicatorPaths(context);
+
+ if(enabled&&!supportsKimiIndicator(context))return [];
+ return configureTomlIndicator({...paths,table:['status_line'],enabled,set:async()=>({command:enabled?await indicatorCommand({context,adapterId:'kimi',...paths,shell:'cmd'}):''})});
+}
+
+export const preflightKimiIndicator = context => configureTomlIndicator({...kimiIndicatorPaths(context),table:['status_line'],enabled:false,dryRun:true});
+
+function supportsKimiIndicator(context) {
+ return typeof context.clientVersion === "string"
+  && compareVersionOrder(versionOrder(context.clientVersion), versionOrder(kimiIndicator.minimumVersion)) >= 0;
+}
+
+export function planKimiIndicator(context) {
+ const paths = kimiIndicatorPaths(context);
+ if (context.indicator === "on" ? !supportsKimiIndicator(context) : !existsSync(paths.marker)) return [];
+ return [{path: paths.file, kind: "merge"},
+  ...(context.indicator === "on" && context.hostPlatform === "win32" ? [{path: paths.shim, kind: "tree"}] : [])];
+}

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

@@ -0,0 +1,17 @@
+import {indicatorGlyph,footerText,footerCwd} from '@agents-can-communicate/adapter-sdk';
+
+export const kimiIndicator = {
+ minimumVersion:'2.1.1', reload:'run /reload-tui', budgetMs:180, previousTimeoutMs:80,
+ nativeSessionId: payload=>payload.sessionId,
+ renderText:indicatorGlyph,
+ composeText({payload={},indicator,previous='',settings={}}) {
+  const mode=[payload.permissionMode==='auto'?'auto':payload.permissionMode==='yolo'?'yolo':'',
+   payload.planMode===true?'plan':''].filter(Boolean).join(' · ');
+  const slots={mode,model:footerText(payload.model),cwd:footerCwd(payload.cwd),git:footerText(payload.gitBranch)};
+  const items=Array.isArray(settings.items)?settings.items:['mode','model','cwd','git'];
+  const base=previous.trimEnd().split(/\r?\n/)[0] || items.map(id=>slots[id]).filter(Boolean).join(' · ');
+  // The client has no session until the first prompt. This is not an ACC failure.
+  if(payload.sessionId==='')return base;
+  return [indicator,base].filter(Boolean).join(' │ ');
+ },
+};

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

@@ -1,3 +1,4 @@
+import {configureKimiIndicator, planKimiIndicator} from "./indicator-install.mjs";
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 
@@ -125,8 +126,8 @@ const registerPlugin = (registry, root) => {
     plugins: [...plugins, { id: PLUGIN_NAME, root, source: "local", enabled: true }] };
 };
 
-export async function installKimiPlugin({ home, runner = defaultRunner(), node, cli,
-  hostPlatform = process.platform }) {
+export async function installKimiPlugin(context) {
+  const {home, runner = defaultRunner(), node, cli, hostPlatform = process.platform} = context;
   // A hook whose command does not exist fails silently, on every event, for as
   // long as it stays installed: the client reports nothing and ACC simply never
   // sees a session. Writing that entry and hoping is worse than refusing.
@@ -135,6 +136,7 @@ export async function installKimiPlugin({ home, runner = defaultRunner(), node,
   // plugin tree is laid down that nothing will then be able to remove.
   const registered = await readJson(registryPath(home), { version: 1, plugins: [] });
 
+  const indicatorChanges = await configureKimiIndicator(context, context.indicator === "on");
   const target = pluginPath(home);
   await rm(target, { recursive: true, force: true });
   await cp(bundle, target, { recursive: true });
@@ -161,13 +163,15 @@ export async function installKimiPlugin({ home, runner = defaultRunner(), node,
   await writeForeignJson(registry, registerPlugin(registered, target),
     { readFile, writeFile, mkdir });
 
-  return { ok: true, changes: [target, file, registry], diagnostics: [] };
+  return { ok: true, changes: [target, file, registry, ...indicatorChanges], diagnostics: context.indicator === "on"
+    ? ["Kimi custom status line retains model, mode, cwd and branch; native context stays below. Goal and task badges are unavailable in the status payload."] : [] };
 }
 
-export async function uninstallKimiPlugin({ home, keep = [] }) {
+export async function uninstallKimiPlugin(context) {
+  const {home, keep = []} = context;
   const file = configPath(home);
   const existing = await readText(file, null);
-  const changes = [];
+  const changes = await configureKimiIndicator(context, false);
   if (existing !== null) {
     const stripped = stripBlock(existing);
     if (stripped !== existing) changes.push(file);
@@ -218,8 +222,10 @@ export async function detectKimi({ home, runner = defaultRunner() }) {
  * The paths an install would write, without writing them. Same helpers as the
  * install, so a dry run cannot drift from what actually happens.
  */
-export function planKimiInstall({ home }) {
+export function planKimiInstall(context) {
+  const {home} = context;
   return [
+    ...planKimiIndicator(context),
     { path: pluginPath(home), kind: "tree" },
     { path: configPath(home), kind: "merge" },
     { path: registryPath(home), kind: "merge" },

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-sdk",
-  "version": "0.10.4",
+  "version": "0.11.1",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-sdk/src/hook-shim.mjs

@@ -58,6 +58,7 @@ const ownBinary = name => {
 };
 
 export const defaultRunner = () => ownBinary("acc-hook.mjs");
+export const defaultIndicator = () => ownBinary("acc-indicator.mjs");
 export const defaultAntigravityRelay = () => ownBinary("acc-antigravity-relay.mjs");
 
 export const runnerExists = async runner => {

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

@@ -11,7 +11,7 @@ export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_REASON_CODES,
   from "./native-delivery.mjs";
 export { EVENT_KINDS, NORMALIZED_EVENT_KEYS, normalizedEvent } from "./events.mjs";
 export { assertRunner, bakeSkillCommand, defaultAntigravityRelay, defaultCli, isShellWord,
-  defaultRunner, removeInstalledTree, runnerExists, shellQuote, writeCliShim, writeHookShim, writeNodeShim }
+  defaultRunner, defaultIndicator, removeInstalledTree, runnerExists, shellQuote, writeCliShim, writeHookShim, writeNodeShim }
   from "./hook-shim.mjs";
 export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, writeTomlBlock }
   from "./toml-block.mjs";
@@ -28,6 +28,7 @@ export { clearSessionBinding, listSessionBindings, loadSessionBinding,
   from "./session-binding.mjs";
 
 export { clearNativeAttempt, loadNativeAttempt, storeNativeAttempt } from "./native-attempt.mjs";
+export { OFFER_ERRORS, loadOfferObservation, storeOfferObservation } from "./offer-observation.mjs";
 export { channelSocketDirectory } from "./channel-directory.mjs";
 export { processIsZombie, readProcessArgs, readProcessTable, readWindowsProcess, splitWindowsCommandLine }
   from "./process-table.mjs";
@@ -37,3 +38,6 @@ export { windowsHookCommand } from "./windows-command.mjs";
 export { shortPath } from "./windows-command.mjs";
 export { mergeEnv } from "./executables.mjs";
 export { closedTo, isWindowsPlatform, openRegularNoFollow } from "./private-files.mjs";
+export { configureTomlIndicator, readTomlIndicatorSettings } from './toml-indicator.mjs';
+export { indicatorGlyph, footerText, footerCwd } from './indicator-text.mjs';
+export { indicatorCommand } from './indicator-command.mjs';

package/node_modules/@agents-can-communicate/adapter-sdk/src/indicator-command.mjs

@@ -0,0 +1,14 @@
+import {mkdir,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {defaultIndicator,shellQuote} from './hook-shim.mjs';
+import {windowsHookCommand} from './windows-command.mjs';
+
+export async function indicatorCommand({context,adapterId,marker,shim,shell}) {
+ const node=context.node??process.execPath,reader=context.indicatorRunner??defaultIndicator();
+ const args=['--adapter',adapterId,'--previous',marker];
+ if((context.hostPlatform??process.platform)!=='win32')return [node,reader,...args].map(shellQuote).join(' ');
+ // Bake paths as JS data, so no shell expands the marker path or its arguments.
+ await mkdir(path.dirname(shim),{recursive:true});
+ await writeFile(shim,`import {pathToFileURL} from 'node:url';\nprocess.argv = [process.execPath,${JSON.stringify(reader)},...${JSON.stringify(args)}];\nawait import(pathToFileURL(${JSON.stringify(reader)}).href);\n`);
+ return windowsHookCommand(shell,{node,shim,args:[]}).trimEnd();
+}

package/node_modules/@agents-can-communicate/adapter-sdk/src/indicator-text.mjs

@@ -0,0 +1,13 @@
+import {stripVTControlCharacters} from 'node:util';
+
+/** Status payload strings are data, never terminal control sequences. */
+export const footerText = value => typeof value==='string'
+  ? stripVTControlCharacters(value).replace(/[\p{Cc}\p{Cf}]/gu,' ').slice(0,160).trim() : '';
+export function footerCwd(value) {
+ const text=footerText(value), parts=text.split(/[\\/]/).filter(Boolean);
+ return parts.length>3?`…/${parts.slice(-3).join('/')}`:text;
+}
+export function indicatorGlyph(report) {
+ const rgb=report.health==='ready'?'44;122;57':report.health==='problem'?'150;108;30':'102;102;102';
+ return report.label.replace(/^ACC ([●!…])/u,(_,glyph)=>`ACC \x1b[22;1;38;2;${rgb}m${glyph}\x1b[22;39m`);
+}

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-attempt-writer.mjs

@@ -4,7 +4,7 @@ import path from "node:path";
 import { parentPort, workerData } from "node:worker_threads";
 
 import { assertPortableId } from "@agents-can-communicate/protocol";
-import { withWriterMutex } from "@agents-can-communicate/storage-filesystem";
+import { withWriterMutex } from "@agents-can-communicate/storage-filesystem/writer-mutex";
 import { loadNativeAttempt, nativeAttemptFrom } from "./native-attempt.mjs";
 
 const keyFor = harnessSessionId => createHash("sha256").update(String(harnessSessionId))

package/node_modules/@agents-can-communicate/adapter-sdk/src/offer-observation-order.mjs

@@ -0,0 +1,12 @@
+let last = 0n;
+
+// A tie-break for equal wall-clock milliseconds, captured in the caller before
+// worker scheduling. Node's hrtime uses the OS monotonic clock; increment locally
+// if its resolution produces a repeated tick. Wall time still orders other dates.
+export function captureOfferOrder() {
+  const tick = process.hrtime.bigint();
+  last = tick > last ? tick : last + 1n;
+  return last.toString();
+}
+
+export const validOfferOrder = value => typeof value === "string" && /^(0|[1-9]\d{0,19})$/.test(value);

package/node_modules/@agents-can-communicate/adapter-sdk/src/offer-observation-writer.mjs

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parentPort, workerData as input } from "node:worker_threads";
+import { readSessionRecord, withWriterMutex } from "@agents-can-communicate/storage-filesystem";
+import { loadOfferObservation, offerObservationPath, OFFER_ERRORS } from "./offer-observation.mjs";
+import { validOfferOrder } from "./offer-observation-order.mjs";
+
+async function write() {
+  const { runtimeDir: root, workspaceId, sessionId, generation, at, order, state, reasonCode, deadlineAt } = input;
+  const file = offerObservationPath(root, sessionId);
+  if (!validOfferOrder(order) || !Number.isFinite(Date.parse(at)) || !["active", "degraded"].includes(state)
+    || !(reasonCode === null || OFFER_ERRORS.includes(reasonCode))) return false;
+  const check = () => { if (Date.now() >= deadlineAt) throw new Error("observation deadline"); };
+  check();
+  return withWriterMutex({ locks: path.join(root, "offer-observation-locks", sessionId) },
+    { root, deadlineAt, clock: { now: () => new Date().toISOString() } }, async () => {
+      check();
+      const session = await readSessionRecord({ root, workspaceId, sessionId });
+      if (session?.state !== "open" || session.generation !== generation) return false;
+      const previous = await loadOfferObservation(input);
+      if (previous && (Date.parse(previous.at) > Date.parse(at)
+        || (Date.parse(previous.at) === Date.parse(at) && previous.order !== undefined
+          && BigInt(previous.order) >= BigInt(order)))) return false;
+      await mkdir(path.dirname(file), { recursive: true });
+      const temporary = `${file}.${randomUUID()}.tmp`;
+      try {
+        check();
+        await writeFile(temporary, JSON.stringify({ schemaVersion: 1, sessionId, generation,
+          at, order, state, reasonCode }) + "\n", { mode: 0o600 });
+        check();
+        await rename(temporary, file);
+        return true;
+      } finally { await rm(temporary, { force: true }).catch(() => {}); }
+    });
+}
+parentPort.postMessage(await write().catch(() => false));

package/node_modules/@agents-can-communicate/adapter-sdk/src/offer-observation.mjs

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { Worker } from "node:worker_threads";
+import { assertPortableId } from "@agents-can-communicate/protocol";
+import { captureOfferOrder, validOfferOrder } from "./offer-observation-order.mjs";
+
+export const OFFER_ERRORS = Object.freeze(["ambiguous_recipient_sessions", "delivery_disabled",
+  "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected",
+  "transport_permission_denied", "unsupported_client_version", "inbound_approval_required"]);
+
+export const offerObservationPath = (runtimeDir, sessionId) => {
+  assertPortableId(sessionId, "offer observation session id");
+  return path.join(runtimeDir, "offer-observations", `${sessionId}.json`);
+};
+
+export async function loadOfferObservation({ runtimeDir, sessionId, generation }) {
+  try {
+    const record = JSON.parse(await readFile(offerObservationPath(runtimeDir, sessionId), "utf8"));
+    if (record.schemaVersion !== 1 || record.sessionId !== sessionId || record.generation !== generation
+      || !Number.isFinite(Date.parse(record.at)) || !["active", "degraded"].includes(record.state)
+      || !(record.reasonCode === null || OFFER_ERRORS.includes(record.reasonCode))
+      || (record.order !== undefined && !validOfferOrder(record.order))) return null;
+    return { at: record.at, state: record.state, reasonCode: record.reasonCode,
+      ...(record.order === undefined ? {} : { order: record.order }) };
+  } catch { return null; }
+}
+
+/** Optional UI diagnostic, separate from delivery receipts and history. Failure
+ * to publish it cannot turn a recorded message into a failed send. */
+export async function storeOfferObservation(input) {
+  if (typeof input.runtimeDir !== "string" || typeof input.workspaceId !== "string") return false;
+  let worker, timer;
+  try {
+    worker = new Worker(new URL("./offer-observation-writer.mjs", import.meta.url), {
+      workerData: { ...input, order: captureOfferOrder(), deadlineAt: Date.now() + 1500 },
+    });
+    const done = new Promise(resolve => {
+      worker.once("message", value => resolve(value === true));
+      worker.once("error", () => resolve(false));
+      worker.once("exit", () => resolve(false));
+      timer = setTimeout(resolve, 1500, false);
+    });
+    worker.unref();
+    return await done;
+  } catch { return false; }
+  finally { clearTimeout(timer); }
+}

package/node_modules/@agents-can-communicate/adapter-sdk/src/process-table.mjs

@@ -12,33 +12,45 @@ const DEFAULT_TIMEOUT_MS = 1_000;
 const LINE = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/;
 // A pid, then the whole rest of the line: a command line has spaces anywhere.
 const ARGS_LINE = /^\s*(\d+)\s+(.+?)\s*$/;
-// Command lines are long; measured at 231 KB for 1,137 processes on a desktop
-// Mac, a quarter of execFile's default buffer.
+// One command line can reach ARG_MAX, 1 MiB on macOS and execFile's default
+// buffer; Windows reads several in one answer.
 const ARGS_BUFFER = 16 * 1024 * 1024;
 
 // Deep enough for a client that wraps its hook in a shell and a launcher.
 const WINDOWS_HOPS = 8;
 
-async function posixTable({ run, timeoutMs }) {
-  const options = { timeout: timeoutMs, killSignal: "SIGKILL", windowsHide: true };
-  const [tree, commandLines] = await Promise.all([
-    run("ps", ["-o", "pid=,ppid=,comm=", "-A"], options).then(({ stdout }) => stdout, () => null),
-    run("ps", ["-A", "-o", "pid=,args="], { ...options, maxBuffer: ARGS_BUFFER })
-      .then(({ stdout }) => stdout, () => ""),
-  ]);
-  if (typeof tree !== "string") return new Map();
-  const args = new Map();
-  for (const line of String(commandLines).split("\n")) {
-    const match = ARGS_LINE.exec(line);
-    if (match !== null) args.set(Number(match[1]), match[2]);
-  }
+// Deep enough for a client that wraps its hook in a shell and a launcher.
+const POSIX_HOPS = 8;
+
+/**
+ * The chain from `from` upward, one `ps -p` per process. Reading every
+ * process's command line took 830-1430 ms at load average 69 on a Mac with
+ * 1,900 processes (2026-10-12), past the hook's limit; one process took 7 ms.
+ * The limit bounds the whole walk. `until` ends it at the process the caller
+ * is looking for, so nothing above the client is read.
+ */
+async function posixChain({ from, run, timeoutMs, until }) {
+  const deadline = Date.now() + timeoutMs;
   const table = new Map();
-  for (const line of tree.split("\n")) {
-    const match = LINE.exec(line);
-    if (match === null) continue;
-    const pid = Number(match[1]);
-    table.set(pid, { ppid: Number(match[2]), comm: match[3],
-      ...(args.has(pid) ? { args: args.get(pid) } : {}) });
+  let next = Number(from);
+  for (let hop = 0; hop < POSIX_HOPS && next > 1 && !table.has(next); hop += 1) {
+    const timeout = deadline - Date.now();
+    if (timeout <= 0) break;
+    const options = { timeout, killSignal: "SIGKILL", windowsHide: true };
+    const pid = String(next);
+    const [tree, commandLine] = await Promise.all([
+      run("ps", ["-o", "pid=,ppid=,comm=", "-p", pid], options).then(({ stdout }) => String(stdout), () => ""),
+      run("ps", ["-o", "pid=,args=", "-p", pid], { ...options, maxBuffer: ARGS_BUFFER })
+        .then(({ stdout }) => String(stdout), () => ""),
+    ]);
+    const match = LINE.exec(tree.trim());
+    if (match === null || Number(match[1]) !== next) break;
+    const args = ARGS_LINE.exec(commandLine.trim());
+    const entry = { ppid: Number(match[2]), comm: match[3],
+      ...(args !== null && Number(args[1]) === next ? { args: args[2] } : {}) };
+    table.set(next, entry);
+    if (typeof until === "function" && until(entry)) break;
+    next = entry.ppid;
   }
   return table;
 }
@@ -154,15 +166,16 @@ async function windowsTable({ from, run, timeoutMs, env }) {
  * Processes on this machine, as pid -> parent, executable and, when it could be
  * read, command line.
  *
- * POSIX reads the whole table with `ps`. Windows reads the chain from `from`
- * upward - the only part a hook asks about - with a creation time for each hop.
- * A failed read is an empty map, never an error: an empty table resolves no
- * client, which is the "nobody knows" answer every caller already handles.
+ * Both platforms read the chain from `from` upward - the only part a hook asks
+ * about. POSIX asks `ps` one process at a time and stops early where `until`
+ * says; Windows reads up to eight hops in one query, with a creation time for
+ * each. A failed read is an empty map, never an error: an empty table resolves
+ * no client, which is the "nobody knows" answer every caller already handles.
  */
 export async function readProcessTable({ platform = process.platform, from = process.pid,
-  run = execFileAsync, timeoutMs = DEFAULT_TIMEOUT_MS, env = process.env } = {}) {
+  run = execFileAsync, timeoutMs = DEFAULT_TIMEOUT_MS, env = process.env, until } = {}) {
   if (platform === "win32") return windowsTable({ from, run, timeoutMs, env });
-  return posixTable({ run, timeoutMs });
+  return posixChain({ from, run, timeoutMs, until });
 }
 
 /**