agents-can-communicate 0.1.17 → 0.2.0

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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, readFile, rename, rm, rmdir, writeFile }
+  from "node:fs/promises";
 import path from "node:path";
 
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
@@ -109,7 +110,7 @@ async function saveOwnership({ dataHome, record }) {
  * runtime, and leaves the bundle inside the client exactly where it was.
  */
 export async function recordInstall({ dataHome, adapterId, version, accVersion = null,
-  artifacts }) {
+  artifacts, createdDirectories = [] }) {
   const stamped = await Promise.all(artifacts.map(async artifact => ({
     path: artifact.path,
     kind: artifact.kind ?? "file",
@@ -118,14 +119,99 @@ export async function recordInstall({ dataHome, adapterId, version, accVersion =
     sha256: artifact.kind === "merge" ? null : await fingerprintFor(artifact),
   })));
   const record = await loadOwnership({ dataHome });
+  const previous = record.installs.find(install => install.adapterId === adapterId);
+  const directories = [...new Set([
+    ...(previous?.createdDirectories ?? []), ...createdDirectories,
+  ])].sort((left, right) => left.split(path.sep).length - right.split(path.sep).length
+    || left.localeCompare(right));
   await saveOwnership({ dataHome, record: { schemaVersion: SCHEMA_VERSION,
     installs: [...record.installs.filter(install => install.adapterId !== adapterId),
-      { adapterId, version, accVersion, artifacts: stamped }] } });
+      { adapterId, version, accVersion, artifacts: stamped,
+        ...(directories.length === 0 ? {} : { createdDirectories: directories }) }] } });
 }
 
 const installFor = (record, adapterId) =>
   record.installs.find(install => install.adapterId === adapterId) ?? null;
 
+const inside = (home, candidate) => {
+  const relative = path.relative(home, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`)
+    && !path.isAbsolute(relative);
+};
+
+async function hasSymlinkAncestor(home, candidate) {
+  let current = candidate;
+  while (inside(home, current)) {
+    const stat = await lstat(current).catch(error => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (stat?.isSymbolicLink()) return true;
+    current = path.dirname(current);
+  }
+  return false;
+}
+
+/** Return planned artifact parents that do not yet exist under the client home. */
+export async function missingArtifactParents({ home, artifacts }) {
+  if (typeof home !== "string") return [];
+  const root = path.resolve(home);
+  const missing = new Set();
+  for (const artifact of artifacts) {
+    let directory = path.dirname(path.resolve(artifact.path));
+    while (inside(root, directory)) {
+      try {
+        await lstat(directory);
+        break;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        missing.add(directory);
+        directory = path.dirname(directory);
+      }
+    }
+  }
+  return [...missing].sort((left, right) =>
+    left.split(path.sep).length - right.split(path.sep).length || left.localeCompare(right));
+}
+
+/** Remove recorded parents deepest-first, but only while each remains an empty directory. */
+export async function removeEmptyOwnedDirectories({ home, directories = [] }) {
+  const result = { removed: [], kept: [], missing: [] };
+  const root = typeof home === "string" ? path.resolve(home) : null;
+  const ordered = [...new Set(directories)].sort((left, right) =>
+    right.split(path.sep).length - left.split(path.sep).length || left.localeCompare(right));
+  for (const directory of ordered) {
+    if (root === null || !inside(root, path.resolve(directory))) {
+      result.kept.push(directory);
+      continue;
+    }
+    let stat;
+    try {
+      stat = await lstat(directory);
+    } catch (error) {
+      if (error.code === "ENOENT") { result.missing.push(directory); continue; }
+      throw error;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+      || await hasSymlinkAncestor(root, path.dirname(directory))) {
+      result.kept.push(directory);
+      continue;
+    }
+    try {
+      await rmdir(directory);
+      result.removed.push(directory);
+    } catch (error) {
+      if (["ENOTEMPTY", "EEXIST"].includes(error.code)) {
+        result.kept.push(directory);
+        continue;
+      }
+      if (error.code === "ENOENT") { result.missing.push(directory); continue; }
+      throw error;
+    }
+  }
+  return result;
+}
+
 /** Compare what was written against what is there now. Read-only. */
 export async function verifyOwned({ dataHome, adapterId }) {
   const install = installFor(await loadOwnership({ dataHome }), adapterId);
@@ -141,17 +227,12 @@ export async function verifyOwned({ dataHome, adapterId }) {
   return result;
 }
 
-/**
- * Remove the files this adapter's install wrote, and only those.
- *
- * A modified file is kept and reported. A merge artifact is never deleted at
- * all: the user owns that file and ACC owns some entries inside it, which is the
- * adapter's own uninstall to unpick because it knows the format.
- */
-export async function removeOwned({ dataHome, adapterId }) {
+/** Remove owned artifacts while retaining the record as retry authority. */
+export async function removeOwnedArtifacts({ dataHome, adapterId }) {
   const record = await loadOwnership({ dataHome });
   const install = installFor(record, adapterId);
-  const result = { adapterId, removed: [], kept: [], missing: [], delegated: [] };
+  const result = { adapterId, removed: [], kept: [], missing: [], delegated: [],
+    createdDirectories: install?.createdDirectories ?? [] };
   if (install === null) return result;
 
   for (const artifact of install.artifacts) {
@@ -163,7 +244,22 @@ export async function removeOwned({ dataHome, adapterId }) {
     result.removed.push(artifact.path);
   }
 
+  return result;
+}
+
+/** Forget one install only after every adapter-owned cleanup step succeeded. */
+export async function finalizeRemoval({ dataHome, adapterId }) {
+  const record = await loadOwnership({ dataHome });
+  if (installFor(record, adapterId) === null) return false;
+
   await saveOwnership({ dataHome, record: { schemaVersion: SCHEMA_VERSION,
     installs: record.installs.filter(entry => entry.adapterId !== adapterId) } });
+  return true;
+}
+
+/** Remove and finalize for callers that perform no delegated adapter cleanup. */
+export async function removeOwned(options) {
+  const result = await removeOwnedArtifacts(options);
+  await finalizeRemoval(options);
   return result;
 }

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

@@ -8,10 +8,14 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  * it previews is a decoration, and the operator would find out only afterwards.
  */
 export function planInstallation({ adapters, detected, context, action = "install",
-  recorded = [], accVersion = null, allowDowngrade = false, requested = [] }) {
+  recorded = [], accVersion = null, allowDowngrade = false, requested = [],
+  delivery = "off" }) {
   if (!["install", "uninstall"].includes(action)) {
     throw new AccError(EXIT.USAGE, `unknown installation action: ${action}`, { action });
   }
+  if (!["off", "actionable", "all"].includes(delivery)) {
+    throw new AccError(EXIT.USAGE, `unknown delivery policy: ${delivery}`, { delivery });
+  }
   const byId = new Map(adapters.map(adapter => [adapter.id, adapter]));
   // What ACC recorded writing, by client. For an uninstall this is the
   // authority rather than detection: the record is the only account of what was
@@ -82,7 +86,16 @@ export function planInstallation({ adapters, detected, context, action = "instal
     // From the record when the client is gone, because that is what was written
     // and so what will be removed. Asking the adapter instead would describe an
     // install for a machine this one no longer is.
-    const artifacts = (record?.artifacts ?? adapter.planInstall(context))
+    const liveDeliverySupported = entry.capabilities?.delivery?.livePush === true;
+    const effectiveLivePolicy = liveDeliverySupported ? delivery : "off";
+    const deliveryDiagnostic = action === "install" && delivery !== "off"
+      && !liveDeliverySupported
+      ? entry.deliveryDiagnostic ?? adapter.deliveryFallback?.diagnostic
+        ?? `${adapter.displayName ?? adapter.id} has no certified live delivery for this client; durable fallback remains active`
+      : null;
+    const installContext = { ...context, requestedLivePolicy: delivery,
+      livePolicy: effectiveLivePolicy };
+    const artifacts = (record?.artifacts ?? adapter.planInstall(installContext))
       .map(artifact => ({ path: artifact.path, kind: artifact.kind ?? "file" }))
       .sort((a, b) => a.path.localeCompare(b.path));
 
@@ -96,12 +109,16 @@ export function planInstallation({ adapters, detected, context, action = "instal
       // to be inferred from a client version that is null.
       clientPresent: entry.present === true,
       alreadyInstalled: entry.installed === true,
+      livePolicy: delivery,
+      effectiveLivePolicy,
+      ...(deliveryDiagnostic === null ? {} : { deliveryDiagnostic }),
       artifacts,
       // Said in the operator's terms, not in paths: which files ACC creates
       // outright and which belong to the user and are only edited.
       summary: [
         ...(entry.present ? [] : [`${adapter.displayName ?? adapter.id} is no longer on `
           + "this machine; removing what ACC recorded writing"]),
+        ...(deliveryDiagnostic === null ? [] : [deliveryDiagnostic]),
         ...artifacts.filter(a => a.kind === "tree")
           .map(a => `${action === "install" ? "create" : "remove"} ${a.path}`),
         ...artifacts.filter(a => a.kind === "merge")

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

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

package/node_modules/@agents-can-communicate/mcp-server/src/input-validator.mjs

@@ -0,0 +1,79 @@
+class InputValidationError extends Error {}
+
+const fail = (path, message) => {
+  throw new InputValidationError(`${path} ${message}`);
+};
+
+const isObject = value => value !== null && typeof value === "object"
+  && !Array.isArray(value);
+
+function matches(schema, value, path) {
+  try {
+    validateSchema(schema, value, path);
+    return true;
+  } catch (error) {
+    if (!(error instanceof InputValidationError)) throw error;
+    return false;
+  }
+}
+
+function validateSchema(schema, value, path) {
+  if (schema.const !== undefined && !Object.is(value, schema.const)) {
+    fail(path, `must equal ${JSON.stringify(schema.const)}`);
+  }
+  if (schema.enum !== undefined && !schema.enum.some(item => Object.is(item, value))) {
+    fail(path, `must be one of ${schema.enum.map(item => JSON.stringify(item)).join(", ")}`);
+  }
+
+  const objectKeywords = schema.type === "object" || schema.properties !== undefined
+    || schema.required !== undefined || schema.additionalProperties !== undefined;
+  if (objectKeywords) {
+    if (!isObject(value)) fail(path, "must be an object");
+    const properties = schema.properties ?? {};
+    for (const key of schema.required ?? []) {
+      if (!Object.hasOwn(value, key)) fail(`${path}.${key}`, "is required");
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) {
+        if (!Object.hasOwn(properties, key)) fail(`${path}.${key}`, "is not a known field");
+      }
+    }
+    for (const [key, child] of Object.entries(properties)) {
+      if (Object.hasOwn(value, key)) validateSchema(child, value[key], `${path}.${key}`);
+    }
+  } else if (schema.type === "array") {
+    if (!Array.isArray(value)) fail(path, "must be an array");
+    if (schema.items !== undefined) {
+      value.forEach((item, index) => validateSchema(schema.items, item, `${path}[${index}]`));
+    }
+  } else if (schema.type === "string" && typeof value !== "string") {
+    fail(path, "must be a string");
+  } else if (schema.type === "boolean" && typeof value !== "boolean") {
+    fail(path, "must be a boolean");
+  } else if (schema.type === "integer" && !Number.isInteger(value)) {
+    fail(path, "must be an integer");
+  }
+
+  if (schema.minimum !== undefined && value < schema.minimum) {
+    fail(path, `must be at least ${schema.minimum}`);
+  }
+  if (schema.maximum !== undefined && value > schema.maximum) {
+    fail(path, `must be at most ${schema.maximum}`);
+  }
+  if (schema.anyOf !== undefined
+    && !schema.anyOf.some(branch => matches(branch, value, path))) {
+    fail(path, "must match an accepted shape");
+  }
+  if (schema.oneOf !== undefined
+    && schema.oneOf.filter(branch => matches(branch, value, path)).length !== 1) {
+    fail(path, "must match exactly one accepted shape");
+  }
+  if (schema.not !== undefined && matches(schema.not, value, path)) {
+    fail(path, "contains fields that cannot be combined");
+  }
+  return value;
+}
+
+export function validateToolInput(schema, value) {
+  return validateSchema(schema, value, "arguments");
+}

package/node_modules/@agents-can-communicate/mcp-server/src/resources.mjs

@@ -15,42 +15,37 @@ function escapeText(value) {
   return result;
 }
 
+function escapePeerValue(value) {
+  if (typeof value === "string") return escapeText(value);
+  if (Array.isArray(value)) return value.map(escapePeerValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value)
+      .map(([key, child]) => [key, escapePeerValue(child)]));
+  }
+  return value;
+}
+
 const attributedMessage = message => ({
-  messageId: message.messageId,
-  from: message.fromSessionId,
-  type: message.type,
-  priority: message.priority,
-  requiresAck: message.requiresAck,
-  sentAt: message.sentAt,
+  ...escapePeerValue(message),
   trust: "untrusted peer content",
-  subject: escapeText(message.subject),
-  body: escapeText(message.body),
 });
 
-export async function readResource(uri, { service, participantId, workspaceId }) {
-  const snapshot = await service.store.snapshot(workspaceId);
+export async function readResource(uri, { service, participantId, workspaceId, session }) {
   switch (uri) {
-    case "acc://snapshot":
-      return { ...snapshot,
-        messages: snapshot.messages.map(attributedMessage) };
+    case "acc://snapshot": {
+      const { snapshot } = await service.sync({ workspaceId, scope: "full" });
+      return { ...snapshot, messages: snapshot.messages.map(attributedMessage) };
+    }
     case "acc://roster":
       return (await service.sync({ workspaceId })).roster;
-    case "acc://workstreams":
-      return snapshot.workstreams;
-    case "acc://tasks":
-      return snapshot.tasks;
     case "acc://inbox": {
-      const mine = new Set(snapshot.receipts
-        .filter(receipt => receipt.recipientParticipantId === participantId)
-        .map(receipt => receipt.messageId));
-      // A participant sees what was addressed to it, plus what it sent, so a
-      // fresh reader can follow its own thread.
-      return snapshot.messages
-        .filter(message => mine.has(message.messageId)
-          || message.toParticipantIds.includes(participantId)
-          || snapshot.sessions.some(session => session.sessionId === message.fromSessionId
-            && session.participantId === participantId))
-        .map(attributedMessage);
+      if (session === undefined) {
+        throw new AccError(EXIT.DATA, "the inbox resource requires a resolved session",
+          { participantId });
+      }
+      const inbox = await service.readInbox({ workspaceId, sessionId: session.sessionId,
+        generation: session.generation });
+      return inbox.map(item => attributedMessage(item.message));
     }
     default:
       throw new AccError(EXIT.DATA, `unknown resource: ${uri}`, { uri });

package/node_modules/@agents-can-communicate/mcp-server/src/server.mjs

@@ -1,13 +1,18 @@
-import { AccError, EXIT } from "@agents-can-communicate/protocol";
+import { createRequire } from "node:module";
+
+import { AccError, EXIT, GENERIC_MESSAGE_KINDS, VALID_OBLIGATIONS }
+  from "@agents-can-communicate/protocol";
 import { clearSessionBinding, loadSessionBinding, storeSessionBinding }
   from "@agents-can-communicate/adapter-sdk";
 
 import { readResource } from "./resources.mjs";
+import { validateToolInput } from "./input-validator.mjs";
 import { MCP_CAPABILITIES, PUBLIC_TOOLS, RESOURCES } from "./tools.mjs";
 
 export const PROTOCOL_VERSION = "2026-07-28";
 export const SUPPORTED_VERSIONS = Object.freeze([PROTOCOL_VERSION]);
-const SERVER_INFO = Object.freeze({ name: "agents-can-communicate", version: "0.0.0" });
+const PACKAGE_VERSION = createRequire(import.meta.url)("../package.json").version;
+const SERVER_INFO = Object.freeze({ name: "agents-can-communicate", version: PACKAGE_VERSION });
 
 const META = "io.modelcontextprotocol";
 const HEARTBEAT_CADENCE_MS = 60_000;
@@ -71,12 +76,48 @@ async function resolveSession(context) {
   return session;
 }
 
+export async function recordAndOffer({ record, router, selectMessage = value => value }) {
+  const recorded = await record();
+  const message = selectMessage(recorded);
+  if (router === null || router === undefined
+    || !Array.isArray(message?.toParticipantIds) || message.toParticipantIds.length === 0) {
+    return { recorded, delivery: [] };
+  }
+  try {
+    return { recorded, delivery: await router.offer(message) };
+  } catch {
+    return { recorded, delivery: message.toParticipantIds.map(recipientParticipantId => ({
+      recipientParticipantId, outcome: "queued", transport: "durable",
+      errorCode: "transport_error",
+    })) };
+  }
+}
+
+const clientMessageId = (args, service) =>
+  args.clientMessageId ?? service.ids.next("client");
+
+function obligationFor(kind, explicit, addressed) {
+  if (!GENERIC_MESSAGE_KINDS.includes(kind)) {
+    const command = kind === "answer"
+      ? "acc_reply" : kind === "handoff" ? "acc_finish" : null;
+    throw new AccError(EXIT.USAGE, command === null
+      ? `unknown message kind: ${kind}` : `${kind} messages require ${command}`);
+  }
+  const obligation = explicit ?? VALID_OBLIGATIONS[kind][0];
+  if (!VALID_OBLIGATIONS[kind].includes(obligation)
+    || (!addressed && obligation !== "none")) {
+    throw new AccError(EXIT.USAGE,
+      `message obligation ${obligation} is invalid for ${kind}`);
+  }
+  return obligation;
+}
+
 /**
  * A poll is this client's turn.
  *
  * The hook runtime hands a session its pending messages when it builds a turn,
  * and marks them delivered. An MCP client has no turn and no hook, and no tool
- * ever handed it anything: it saw a `direct_request` line carrying a subject and
+ * ever handed it anything: it saw a `reply_required` line carrying a subject and
  * an id, and to read what a peer had actually said it had to ask for the whole
  * snapshot and search every message in the workspace for its own name.
  *
@@ -85,29 +126,10 @@ async function resolveSession(context) {
  * that had answered it.
  *
  * Returning them here is delivery, in the same sense and with the same honesty
- * as the turn: what is handed over is marked `injected`, and nothing else is.
+ * as the turn: what is handed over is marked `retrieved`, and nothing else is.
  * Acknowledgement stays a separate act, because being shown something is not
  * agreeing to it.
  */
-async function syncWithMail(service, owner, context, args) {
-  const sync = await service.sync({ ...owner, cursor: args.cursor ?? null,
-    scope: args.scope, limit: args.limit });
-  const messages = await service.pendingMessages({
-    workspaceId: context.workspaceId,
-    participantId: context.participantId,
-    exceptSessionId: owner.sessionId });
-  if (messages.length === 0) return sync;
-
-  for (const message of messages) {
-    // One failure must not swallow the rest: the client is holding the message
-    // either way, and a receipt that cannot be written is not a reason to hide
-    // what a peer said.
-    await service.markDelivery({ ...owner, messageId: message.messageId,
-      state: "injected" }).catch(() => null);
-  }
-  return { ...sync, messages };
-}
-
 async function callTool(name, args, context) {
   const session = await resolveSession(context);
   const owner = { sessionId: session.sessionId, generation: session.generation,
@@ -115,62 +137,66 @@ async function callTool(name, args, context) {
   const service = context.service;
 
   switch (name) {
+    case "acc_status":
+      return service.collectStatus({});
     case "acc_sync":
-      return syncWithMail(service, owner, context, args);
+      return service.sync({ ...owner, cursor: args.cursor ?? null,
+        scope: args.scope, limit: args.limit });
     case "acc_work":
-      if (args.clear === true) return service.clearIntent({ ...owner });
+      if (args.clear === true) {
+        await service.clearIntent({ ...owner });
+        return { cleared: true };
+      }
       return service.setIntent({ ...owner, summary: args.summary, mode: args.mode,
-        state: args.state, workstreamId: args.workstreamId ?? null,
-        resourceHints: args.resourceHints ?? [] });
+        state: args.state, resourceHints: args.resourceHints ?? [] });
     case "acc_claim":
-      if (args.action === "release") return service.releaseClaim({ ...owner,
-        claimId: args.claimId }) ?? { released: args.claimId };
       if (args.action === "renew") return service.renewClaim({ ...owner,
         claimId: args.claimId, leaseSeconds: args.leaseSeconds });
       return service.acquireClaim({ ...owner, resource: args.resource,
         mode: args.mode ?? "exclusive", enforcement: "advisory",
         reason: args.reason ?? "unspecified", leaseSeconds: args.leaseSeconds });
-    case "acc_message":
-      return service.sendMessage({ ...owner, toParticipantIds: args.to ?? [],
-        subject: args.subject, body: args.body, type: args.type ?? "note",
-        priority: args.priority, requiresAck: args.requiresAck === true,
-        workstreamId: args.workstreamId ?? null });
-    case "acc_task":
-      if (args.action === "claim") return service.claimTask({ ...owner,
-        taskId: args.taskId, force: args.force === true });
-      if (args.action === "decline") return service.declineTask({ ...owner,
-        taskId: args.taskId, reason: args.reason });
-      if (args.action === "transition") return service.transitionTask({ ...owner,
-        taskId: args.taskId, state: args.state });
-      return service.createTask({ ...owner, workstreamId: args.workstreamId,
-        title: args.title, detail: args.detail, taskId: args.taskId,
-        assigneeParticipantId: args.assigneeParticipantId,
-        dependsOn: args.dependsOn ?? [] });
-    case "acc_request":
-      return service.requestWork({ ...owner, toParticipantId: args.toParticipantId,
-        title: args.title, detail: args.detail, workstreamId: args.workstreamId,
-        priority: args.priority, dependsOn: args.dependsOn ?? [] });
+    case "acc_release":
+      await service.releaseClaim({ ...owner, claimId: args.claimId });
+      return { released: args.claimId };
+    case "acc_message": {
+      const kind = args.kind ?? "note";
+      const toParticipantIds = args.to ?? [];
+      const routed = await recordAndOffer({ router: context.deliveryRouter, record: () =>
+        service.sendMessage({ ...owner, clientMessageId: clientMessageId(args, service),
+        toParticipantIds, subject: args.subject, body: args.body, kind,
+        obligation: obligationFor(kind, args.obligation, toParticipantIds.length > 0) }) });
+      const message = routed.recorded;
+      return { message, delivery: routed.delivery };
+    }
+    case "acc_inbox":
+      return service.readInbox({ ...owner, messageId: args.messageId });
+    case "acc_reply": {
+      const routed = await recordAndOffer({ router: context.deliveryRouter,
+        selectMessage: value => value.reply,
+        record: () => service.replyToMessage({ ...owner, messageId: args.messageId,
+          body: args.body, subject: args.subject,
+          clientMessageId: clientMessageId(args, service) }) });
+      return { message: routed.recorded.reply, delivery: routed.delivery };
+    }
+    case "acc_request": {
+      const routed = await recordAndOffer({ router: context.deliveryRouter,
+        record: () => service.sendMessage({ ...owner,
+          clientMessageId: clientMessageId(args, service),
+          toParticipantIds: [args.toParticipantId], kind: "request", obligation: "reply",
+          subject: args.title, body: args.detail ?? args.title }) });
+      return { message: routed.recorded, delivery: routed.delivery };
+    }
     case "acc_ack":
-      return service.markDelivery({ ...owner, messageId: args.messageId,
-        state: args.state ?? "acknowledged" });
-    case "acc_decide":
-      return service.recordDecision({ ...owner, title: args.title, outcome: args.outcome,
-        authority: args.authority ?? "workstream", workstreamId: args.workstreamId ?? null,
-        decidedBy: args.decidedBy, supersedes: args.supersedes ?? null,
-        humanConfirmed: args.humanConfirmed === true });
-    case "acc_workstream":
-      if (args.action === "coordinate") {
-        return service.acquireCoordinator({ ...owner, workstreamId: args.workstreamId });
-      }
-      if (args.action === "release") {
-        return service.releaseCoordinator({ ...owner, workstreamId: args.workstreamId });
-      }
-      return service.createWorkstream({ ...owner, title: args.title,
-        objective: args.objective });
-    case "acc_finish":
-      return service.finishSession({ ...owner, goal: args.goal, status: args.status,
+      return service.acknowledgeMessage({ ...owner, messageId: args.messageId });
+    case "acc_finish": {
+      const routed = await recordAndOffer({ router: context.deliveryRouter,
+        selectMessage: value => value.message,
+        record: () => service.finishSession({ ...owner,
+        clientMessageId: clientMessageId(args, service), goal: args.goal, status: args.status,
         completed: args.completed ?? [], remaining: args.remaining ?? [],
-        blockers: args.blockers ?? [], toParticipantId: args.toParticipantId ?? null });
+        blockers: args.blockers ?? [], toParticipantId: args.toParticipantId }) });
+      return { message: routed.recorded.message, delivery: routed.delivery };
+    }
     default:
       throw new AccError(EXIT.USAGE, `unknown tool: ${name}`, { name });
   }
@@ -190,15 +216,27 @@ async function handle(message, context) {
     case "resources/list":
       return complete({ resources: [...RESOURCES] });
     case "resources/read": {
-      const value = await readResource(params.uri, context);
+      // Snapshot and roster are observation-only. Inbox is a delivery boundary:
+      // resolve this configured participant's durable session and let the core
+      // inbox service record that the returned bodies were retrieved.
+      const resourceContext = params.uri === "acc://inbox"
+        ? { ...context, session: await resolveSession(context) }
+        : context;
+      const value = await readResource(params.uri, resourceContext);
       return complete({ contents: [{ uri: params.uri, mimeType: "application/json",
         text: JSON.stringify(value, null, 2) }] });
     }
     case "tools/call": {
       try {
-        const value = await callTool(params.name, params.arguments ?? {}, context);
+        const args = params.arguments === undefined ? {} : params.arguments;
+        const tool = PUBLIC_TOOLS.find(candidate => candidate.name === params.name);
+        if (tool === undefined) {
+          throw new AccError(EXIT.USAGE, `unknown tool: ${params.name}`, { name: params.name });
+        }
+        validateToolInput(tool.inputSchema, args);
+        const value = await callTool(params.name, args, context);
         return complete({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
-          structuredContent: JSON.stringify(value) });
+          structuredContent: value });
       } catch (error) {
         // A failing operation is a tool result, not a transport failure: the
         // model must see it and be able to react.