agents-can-communicate 0.10.3 → 0.11.0

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

@@ -1,3 +1,5 @@
+import { preflightGrokIndicator } from "./indicator-install.mjs";
+import { grokIndicator } from "./indicator.mjs";
 import { defineAdapter, projectContext, projectContextResult }
   from "@agents-can-communicate/adapter-sdk";
 import certification from "../certification.json" with { type: "json" };
@@ -22,6 +24,7 @@ export const GROK_VERSION = "1.0.13";
 export function createGrokAdapter() {
   return defineAdapter({
     id: "grok",
+    statusIndicator: grokIndicator,
     displayName: "Grok",
     // Native Mach-O at ~/.grok/bin/grok. `ps -o comm=` on 1.0.13 reports `grok`.
     client: { command: "grok", certificationName: "grok", versionArgs: ["--version"] },
@@ -41,6 +44,7 @@ export function createGrokAdapter() {
     planInstall: context => planGrokInstall(forClient(context)),
     detect: context => detectGrok(forClient(context)),
     install: context => installGrokHooks(forClient(context)),
+    preflightUninstall: context => preflightGrokIndicator(forClient(context)),
     uninstall: context => uninstallGrokHooks(forClient(context)),
 
     doctor: async context => {

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.3",
+  "version": "0.11.0",
   "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.3",
+  "version": "0.11.0",
   "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-vocabulary.mjs

@@ -29,6 +29,8 @@ export const NATIVE_REASON_CODES = Object.freeze([
   "prerelease_not_captured", "below_minimum_version", "known_bad_version",
   "feature_probe_failed", "probe_timeout", "probe_version_mismatch", "protocol_mismatch",
   "native_endpoint_unavailable", "native_session_unavailable",
+  // A caller can be denied access to a healthy receiver's local transport.
+  "transport_permission_denied",
   "handshake_failed", "handshake_timeout", "handshake_version_mismatch",
   "session_generation_stale", "client_process_unknown", "unsupported_shell",
   // The current session's canonical workspace identity could not be verified.

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/toml-indicator.mjs

@@ -0,0 +1,141 @@
+import {mkdir,readFile,writeFile,rm} from 'node:fs/promises';
+import path from 'node:path';
+import {scanConfig,unsafe} from './toml-scan.mjs';
+
+const read = async file => readFile(file,'utf8').catch(e=>{if(e.code==='ENOENT')return null;throw e;});
+const equal = (a,b) => JSON.stringify(a)===JSON.stringify(b);
+const prefix = (a,b) => b.every((item,i)=>a[i]===item);
+
+// Only the status section's scalar values and string arrays are interpreted.
+// Other TOML is scanned lexically and retained byte for byte.
+function valueOf(source) {
+ let rest=source.trim();
+ function take() {
+  rest=rest.trimStart();
+  const quote=rest[0];
+  if(quote==='"'||quote==="'") {
+   const delimiter=rest.startsWith(quote.repeat(3))?quote.repeat(3):quote;
+   let i=delimiter.length, text='';
+   if(delimiter.length===3 && rest[i]==='\n')i++;
+   for(;i<rest.length;) {
+    if(rest.startsWith(delimiter,i)) {rest=rest.slice(i+delimiter.length);return text;}
+    if(quote==='"'&&rest[i]==='\\') {
+     const match=/^\\(U[\da-fA-F]{8}|u[\da-fA-F]{4}|[btnfr"\\])/.exec(rest.slice(i));
+     if(!match)unsafe('unsupported status string escape');
+     const escape=match[1];
+     text+=/^[uU]/.test(escape)?String.fromCodePoint(parseInt(escape.slice(1),16))
+      :({b:'\b',t:'\t',n:'\n',f:'\f',r:'\r','"':'"','\\':'\\'})[escape];
+     i+=match[0].length;
+    } else text+=rest[i++];
+   }
+   unsafe('unclosed status string');
+  }
+  if(rest[0]==='[') {
+   rest=rest.slice(1);const values=[];
+   while(!rest.trimStart().startsWith(']')) {
+    values.push(take());rest=rest.trimStart();
+    if(rest[0]!==',')break;
+    rest=rest.slice(1);
+   }
+   rest=rest.trimStart();if(rest[0]!==']')unsafe('invalid status array');
+   rest=rest.slice(1);return values;
+  }
+  const scalar=/^(true|false|[-+]?\d+(?:\.\d+)?)(?=\s|,|\]|$)/.exec(rest);
+  if(!scalar)unsafe('unsupported status value');
+  rest=rest.slice(scalar[0].length);
+  return scalar[0]==='true'?true:scalar[0]==='false'?false:Number(scalar[0]);
+ }
+ const result=take();if(rest.trim())unsafe('extra status value');return result;
+}
+
+function inspect(source,table) {
+ const nodes=scanConfig(source??''), entries={}, settings={};let header=null;
+ for(const node of nodes) {
+  if(!node.code)continue;
+  if(prefix(node.keys,table)&&node.keys.length>table.length+(node.header?0:1))unsafe('nested status declaration');
+  if(node.header&&equal(node.keys,table)) {
+   if(header||node.array)unsafe('duplicate status table');header=node;continue;
+  }
+  if(!node.header&&prefix(table,node.keys))unsafe('inline status table');
+  if(!node.header&&prefix(node.keys,table)&&node.keys.length===table.length+1) {
+   const key=node.keys.at(-1);
+   if(entries[key])unsafe('duplicate status key');
+   entries[key]=node;settings[key]=valueOf(node.value);
+  }
+ }
+ if(Object.keys(entries).length&&!header)unsafe('use an explicit status table instead of dotted keys');
+ return {nodes,entries,settings,header};
+}
+
+function edit(source,table,view,replacements) {
+ let next=source??'';const patches=[];const additions=[];
+ for(const [key,raw] of Object.entries(replacements)) {
+  const entry=view.entries[key];
+  if(entry)patches.push({start:entry.start,end:entry.end,text:raw??''});
+  else if(raw)additions.push(raw);
+ }
+ if(additions.length) {
+  const at=view.header?.end??next.length;
+  const separator=at>0&&next[at-1]!=='\n'?'\n':'';
+  patches.push({start:at,end:at,text:separator+(view.header?'':`[${table.join('.')}]\n`)+additions.join('')});
+ }
+ for(const patch of patches.sort((a,b)=>b.start-a.start))next=next.slice(0,patch.start)+patch.text+next.slice(patch.end);
+ return next;
+}
+
+/** Save only this command's ownership; later user edits win over refresh/removal. */
+export async function configureTomlIndicator({file,marker,table,enabled,set,defaults={},dryRun=false}) {
+ const source=await read(file),savedText=await read(marker);
+ const saved=savedText===null?null:JSON.parse(savedText);
+ if(!enabled&&!saved)return [];
+ if(saved&&(saved.schemaVersion!==1||!equal(saved.table,table)||typeof saved.installed?.command!=='string'
+  ||!Array.isArray(saved.owned)||typeof saved.installedSource!=='string'))unsafe('invalid indicator ownership');
+ const view=inspect(source,table);
+ if(dryRun)return [];
+ if(saved&&view.settings.command!==saved.installed.command) {
+  if(!enabled)await rm(marker,{force:true});
+  return [];
+ }
+ if(!enabled) {
+  let next;
+  if(source===saved.installedSource)next=saved.original;
+  else {
+   const replacements={};
+   for(const key of saved.owned)if(equal(view.settings[key],saved.installed[key]))replacements[key]=saved.raw[key]??null;
+   next=edit(source,table,view,replacements);
+   if(!saved.hadHeader) {
+    const after=inspect(next,table);
+    if(after.header&&Object.keys(after.entries).length===0)next=next.slice(0,after.header.start)+next.slice(after.header.end);
+   }
+  }
+  if(next===null)await rm(file,{force:true});else if(next!==source)await writeFile(file,next);
+  await rm(marker,{force:true});return [file];
+ }
+ const previous=saved?.previous??view.settings;
+ const values=typeof set==='function'?await set():set;
+ const installed={...view.settings,...Object.fromEntries(Object.entries(defaults).filter(([key])=>!Object.hasOwn(view.settings,key))),...values};
+ const owned=saved?saved.owned.filter(key=>equal(view.settings[key],saved.installed[key]))
+  :Object.keys(installed).filter(key=>!equal(installed[key],previous[key]));
+ const changes={};
+ for(const key of owned)if(!equal(view.settings[key],installed[key]))changes[key]=`${key} = ${JSON.stringify(installed[key])}\n`;
+ const next=edit(source,table,view,changes);
+ const record={schemaVersion:1,file,table,previous,installed,owned,
+  raw:saved?.raw??Object.fromEntries(Object.entries(view.entries).map(([key,node])=>[key,node.raw])),
+  original:saved?saved.original:source,hadHeader:saved?.hadHeader??Boolean(view.header),
+  installedSource:saved?.installedSource??next};
+ await mkdir(path.dirname(marker),{recursive:true});
+ await writeFile(marker,JSON.stringify(record)+'\n',{mode:0o600});
+ try {
+  if(next!==source){await mkdir(path.dirname(file),{recursive:true});await writeFile(file,next);}
+ } catch(error) {
+  if(savedText===null)await rm(marker,{force:true});else await writeFile(marker,savedText,{mode:0o600});
+  throw error;
+ }
+ return [file];
+}
+
+/** Read current display choices without reclaiming the previous shell program. */
+export async function readTomlIndicatorSettings(record) {
+ if(typeof record.file!=='string'||!Array.isArray(record.table))return record.previous??{};
+ return inspect(await read(record.file),record.table).settings;
+}