agents-can-communicate 0.10.4 → 0.11.0

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.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/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;
+}

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

@@ -0,0 +1,99 @@
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+export const unsafe = (reason = "unrecognized TOML declaration") => {
+  throw new AccError(EXIT.CONFLICT, `cannot safely edit status-line TOML: ${reason}; `
+    + "repair ambiguous TOML before retrying", { reason });
+};
+// A bounded lexical scan, not a TOML value parser. Newlines inside strings,
+// arrays and inline tables cannot introduce a header or a managed marker.
+export function* statements(source) {
+  let start = 0, code = "", quote = null;
+  const stack = [];
+  for (let i = 0; i < source.length;) {
+    const char = source[i];
+    if (quote) {
+      if (quote[0] === '"' && char === "\\") {
+        code += source.slice(i, i + 2); i += 2; continue;
+      }
+      if (source.startsWith(quote, i)) {
+        let count = quote.length;
+        if (quote.length === 3) {
+          while (source[i + count] === quote[0]) count++;
+          if (count > 5) unsafe("unsupported string quote delimiter");
+        }
+        code += source.slice(i, i + count); i += count; quote = null; continue;
+      }
+      if (quote.length === 1 && /[\r\n]/.test(char)) unsafe("newline in single-line string");
+      code += char; i++; continue;
+    }
+    if (char === "#") {
+      while (i < source.length && source[i] !== "\n") i++;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = source.startsWith(char.repeat(3), i) ? char.repeat(3) : char;
+      code += quote; i += quote.length; continue;
+    }
+    if (char === "[" || char === "{") stack.push(char);
+    if (char === "]" || char === "}") {
+      if (stack.pop() !== (char === "]" ? "[" : "{")) unsafe("mismatched collection delimiter");
+    }
+    code += char; i++;
+    if (char === "\n" && stack.length === 0) {
+      yield { raw: source.slice(start, i), code: code.trim(), start, end: i };
+      start = i; code = "";
+    }
+  }
+  if (quote || stack.length) unsafe(quote ? "unclosed string" : "unclosed collection");
+  if (start < source.length) yield { raw: source.slice(start), code: code.trim(), start, end: source.length };
+}
+
+function decodeKey(key) {
+  if (key[0] === "'") return key.slice(1, -1);
+  if (key[0] !== '"') return key;
+  return key.slice(1, -1).replace(/\\(U[\da-fA-F]{8}|u[\da-fA-F]{4}|[btnfr"\\])|\\./g,
+    (match, escape) => {
+      if (!escape) unsafe("unsupported quoted-key escape");
+      if (/^[uU]/.test(escape)) {
+        const point = Number.parseInt(escape.slice(1), 16);
+        if (point > 0x10ffff || (point >= 0xd800 && point <= 0xdfff)) {
+          unsafe("invalid quoted-key Unicode escape");
+        }
+        return String.fromCodePoint(point);
+      }
+      return ({ b: "\b", t: "\t", n: "\n", f: "\f", r: "\r", '"': '"', "\\": "\\" })[escape];
+    });
+}
+
+function keyPath(code) {
+  const keys = [];
+  let rest = code.trimStart();
+  for (;;) {
+    const match = /^(?:[A-Za-z0-9_-]+|'[^'\r\n]*'|"(?:[^"\\\r\n]|\\[^\r\n])*")/.exec(rest);
+    if (!match) unsafe("unrecognized TOML key");
+    keys.push(decodeKey(match[0]));
+    rest = rest.slice(match[0].length).trimStart();
+    if (!rest.startsWith(".")) return { keys, rest };
+    rest = rest.slice(1).trimStart();
+  }
+}
+
+export function declaration(code) {
+  const header = code.startsWith("[");
+  const array = header && code.startsWith("[[");
+  const { keys, rest } = keyPath(header ? code.slice(array ? 2 : 1) : code);
+  if (header ? rest !== (array ? "]]" : "]") : !rest.startsWith("=")) unsafe();
+  return { keys, header, array, value: header ? null : rest.slice(1).trim() };
+}
+
+// Resolved declaration paths are only structural facts, never parsed user values.
+export function scanConfig(source) {
+  let table = [];
+  return [...statements(source)].map(item => {
+    if (!item.code) return { ...item, table: [...table], keys: [] };
+    const entry = declaration(item.code);
+    if (entry.header) table = entry.keys;
+    return { ...item, ...entry, table: [...table],
+      keys: entry.header ? entry.keys : [...table, ...entry.keys] };
+  });
+}

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

@@ -1,11 +1,12 @@
 {
   "name": "@agents-can-communicate/cli",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "private": true,
   "type": "module",
   "exports": {
     ".": "./src/index.mjs",
     "./hook-support": "./src/hook-support.mjs",
+    "./indicator": "./src/indicator-command.mjs",
     "./managed-entry": "./src/managed-runtime/entry.mjs",
     "./managed-worker": "./src/managed-runtime/worker.mjs"
   },

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

@@ -18,13 +18,15 @@ export const COMMANDS = Object.freeze({
   work: { required: [], optional: ["session", "generation", "summary", "mode",
     "state"], repeated: ["hint"], flags: ["clear"] },
   claim: { required: ["resource"],
-    optional: ["session", "generation", "mode", "enforcement", "reason", "lease"] },
+    optional: ["session", "generation", "mode", "enforcement", "reason", "lease"],
+    repeated: ["resource"] },
   // Neither is required on its own, because either one names the claim: an id
   // is precise, and a resource is what the caller typed to take it in the first
   // place. Requiring the id meant a round trip through `acc status --json` to
   // look up something the caller never chose.
   release: { required: [],
-    optional: ["claim", "resource", "session", "generation", "authority", "reason"] },
+    optional: ["session", "generation", "authority", "reason"],
+    repeated: ["claim", "resource"], flags: ["all"] },
   message: { required: ["subject", "body"],
     optional: ["session", "generation", "type", "obligation", "client-message-id"],
     repeated: ["to", "supersedes", "withdraws"] },
@@ -57,7 +59,7 @@ export const COMMANDS = Object.freeze({
   // `--downgrade` because an older acc first on PATH will otherwise rewire every
   // client to itself, and the only symptom is a guard behaving like the version
   // it came from.
-  install: { required: [], optional: ["home", "delivery"], repeated: ["adapter"],
+  install: { required: [], optional: ["home", "delivery", "indicator"], repeated: ["adapter"],
     flags: ["dry-run", "downgrade"] },
   // `--dry-run` on both, because the preview was computed for either action and
   // only `install` could ask for it. Removal is the side that reaches into a

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

@@ -0,0 +1,64 @@
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+import { positiveNumber } from "./args.mjs";
+import { canonicalClaim } from "./claim-spelling.mjs";
+
+const list = value => value === undefined ? undefined : Array.isArray(value) ? value : [value];
+const owner = options => ({ sessionId: options.session, generation: options.generation });
+
+export async function runClaimCommand({ options, context }) {
+  const resources = await Promise.all(list(options.resource)
+    .map(resource => canonicalClaim(resource, context.descriptor)));
+  const input = { ...owner(options), mode: options.mode ?? "exclusive",
+    enforcement: options.enforcement ?? "advisory", reason: options.reason ?? "unspecified",
+    leaseSeconds: options.lease ? positiveNumber(options.lease, "lease") : undefined,
+    descriptor: context.descriptor };
+  if (resources.length === 1) {
+    const claim = await context.service.acquireClaim({ ...input, resource: resources[0] });
+    return { data: claim, text: `claimed ${claim.resource}` };
+  }
+  const claims = await context.service.acquireClaims({ ...input, resources });
+  return { data: { claims }, text: `claimed ${claims.length} resources` };
+}
+
+// Single-item authority keeps its existing lookup and ambiguity rules.
+async function authorityClaim(resource, context) {
+  const { claims } = await context.service.collectStatus({});
+  const matching = claims.filter(claim => claim.resource === resource);
+  if (matching.length === 0) throw new AccError(EXIT.DATA, `no claim on ${resource} to release`,
+    { resource, held: claims.map(claim => claim.resource) });
+  if (matching.length > 1) throw new AccError(EXIT.DATA,
+    `${matching.length} claims on ${resource}; name the one you mean with --claim`,
+    { resource, claims: matching.map(claim => claim.claimId) });
+  return matching[0].claimId;
+}
+
+export async function runReleaseCommand({ options, context }) {
+  const selectors = [options.claim, options.resource, options.all].filter(value => value !== undefined);
+  if (selectors.length !== 1) throw new AccError(EXIT.USAGE,
+    "release needs exactly one of --claim, --resource, or --all");
+  const claimIds = list(options.claim);
+  const resources = options.resource === undefined ? undefined
+    : await Promise.all(list(options.resource).map(resource => canonicalClaim(resource, context.descriptor)));
+  const scalar = options.all !== true && (claimIds ?? resources).length === 1;
+  if (options.authority !== undefined) {
+    if (!scalar) throw new AccError(EXIT.USAGE, "force-release authority requires a single claim");
+    const claimId = claimIds?.[0] ?? await authorityClaim(resources[0], context);
+    await context.service.forceReleaseClaim({ ...owner(options), claimId,
+      authority: options.authority, reason: options.reason });
+    return { data: { claimId }, text: `released ${claimId}` };
+  }
+  if (scalar && claimIds !== undefined) {
+    const claimId = claimIds[0];
+    await context.service.releaseClaim({ ...owner(options), claimId });
+    return { data: { claimId }, text: `released ${claimId}` };
+  }
+  const released = await context.service.releaseClaims({ ...owner(options),
+    ...(options.all === true ? { all: true } : resources !== undefined ? { resources } : { claimIds }) });
+  if (scalar) {
+    const claimId = released[0].claimId;
+    return { data: { claimId }, text: `released ${claimId}` };
+  }
+  return { data: { claimIds: released.map(claim => claim.claimId) },
+    text: `released ${released.length} claims` };
+}