agents-can-communicate 0.10.4 → 0.11.0

package/node_modules/@agents-can-communicate/core/src/claims.mjs

@@ -1,6 +1,7 @@
-import { AccError, EXIT, SCHEMA_VERSION, assertMatchableResource, createId,
-  normaliseResource, validateRecord } from "@agents-can-communicate/protocol";
+import { AccError, EXIT, SCHEMA_VERSION, createId, validateRecord }
+  from "@agents-can-communicate/protocol";
 
+import { claimResources, releaseSelectors, selectReleaseClaims } from "./claim-selectors.mjs";
 import { ensureMaterialised } from "./materialisation.mjs";
 import { classifySessionPresence } from "./sessions.mjs";
 
@@ -33,10 +34,11 @@ const isLive = (claim, now) => Date.parse(claim.expiresAt) > Date.parse(now);
 export function createClaimService(ports, sessions) {
   const { store, clock, ids, pidIsAlive } = ports;
 
-  async function requireOwner(input, action, tx) {
+  async function requireOwner(input, action, tx, allowEphemeral = false) {
     const current = tx === undefined
       ? (await sessions.locateSession(input.sessionId, input.workspaceId))?.record
-      : tx.get("session", input.sessionId);
+      : tx.get("session", input.sessionId)
+        ?? (allowEphemeral ? await store.ephemeral.get("session", input.sessionId) : null);
     if (current == null || current.state !== "open") {
       throw new AccError(EXIT.CONFLICT, `cannot ${action} from a session that is not open`,
         { sessionId: input.sessionId });
@@ -65,63 +67,66 @@ export function createClaimService(ports, sessions) {
     });
   }
 
-  async function acquireClaim(input) {
+  async function acquire(input, resources, batch) {
     const session = await requireOwner(input, "claim");
-    // One name for one file, decided here rather than at each surface, so a
-    // claim taken over MCP and one taken from the CLI mean the same thing - and
-    // a shape that could never match is refused rather than stored.
-    assertMatchableResource(input.resource, message => {
-      throw new AccError(EXIT.USAGE, message, { resource: input.resource });
-    });
-    const resource = normaliseResource(input.resource);
+    resources = claimResources(resources);
     const workspaceId = session.workspaceId;
     await ensureMaterialised(ports, { workspaceId, descriptor: input.descriptor,
       reason: "durable_object" });
-    const now = clock.now();
-    const expiresAt = new Date(Date.parse(now) + (input.leaseSeconds ?? 1800) * 1000)
-      .toISOString();
-    // Only to name the owner of a conflicting claim in the error.
-    const snapshot = await store.snapshot(workspaceId, { kinds: ["session"] });
-
-    let record = null;
-    await store.transaction(async tx => {
+    return store.transaction(async tx => {
       await requireOwner(input, "claim", tx);
-      const live = tx.list("claim", claim => isLive(claim, now));
-      // This session's own claim on this resource, live or lapsed. Looking only
-      // among the live ones left the expired record behind and made a fresh one
-      // beside it, so taking a resource back after a lease ran out reported
-      // success while the workspace still held a dead claim saying otherwise -
-      // and the owner went on being told its claim had run out.
-      const mine = tx.list("claim", claim => claim.ownerSessionId === session.sessionId
-        && claim.resource === resource).at(0);
-      const blocking = live.find(claim => overlaps(claim.resource, resource)
-        && claim.ownerSessionId !== session.sessionId
-        && (claim.mode === "exclusive" || input.mode === "exclusive"));
-      if (blocking !== undefined) throw conflictWith(blocking, session, now, snapshot.sessions);
-
-      const claimId = mine?.claimId ?? createId("claim");
-      record = validateRecord("claim", {
-        schemaVersion: SCHEMA_VERSION,
-        claimId,
-        workspaceId,
-        ownerSessionId: session.sessionId,
-        resource,
-        mode: input.mode ?? "exclusive",
-        enforcement: input.enforcement ?? "advisory",
-        reason: input.reason,
-        // A lapsed claim taken again is a new period of holding it, not a
-        // continuation of one that ended.
-        acquiredAt: mine !== undefined && isLive(mine, now) ? mine.acquiredAt : now,
-        expiresAt,
-        generation: ids.next("generation"),
+      const now = clock.now();
+      const expiresAt = new Date(Date.parse(now) + (input.leaseSeconds ?? 1800) * 1000)
+        .toISOString();
+      const existing = tx.list("claim");
+      const live = existing.filter(claim => isLive(claim, now));
+      const mode = input.mode ?? "exclusive";
+      const conflicts = resources.flatMap(resource => live
+        .filter(claim => overlaps(claim.resource, resource)
+          && claim.ownerSessionId !== session.sessionId
+          && (claim.mode === "exclusive" || mode === "exclusive"))
+        .map(claim => ({ requestedResource: resource,
+          ...conflictWith(claim, session, now, tx.list("session")).details })));
+      if (conflicts.length > 0) {
+        if (!batch) {
+          const { requestedResource, ...details } = conflicts[0];
+          throw new AccError(EXIT.CONFLICT, "the resource is already claimed", details);
+        }
+        const message = "batch claim conflicts:\n" + conflicts.map(conflict =>
+          `${conflict.requestedResource} overlaps ${conflict.resource}, held by ${conflict.ownerSessionId}`)
+          .join("\n");
+        throw new AccError(EXIT.CONFLICT, message, { conflicts });
+      }
+      // Validate every record before staging a write, including renewals.
+      const records = resources.map(resource => {
+        const mine = existing.find(claim => claim.ownerSessionId === session.sessionId
+          && claim.resource === resource);
+        const claimId = mine?.claimId ?? createId("claim");
+        return { mine, record: validateRecord("claim", {
+          schemaVersion: SCHEMA_VERSION,
+          claimId,
+          workspaceId,
+          ownerSessionId: session.sessionId,
+          resource,
+          mode,
+          enforcement: input.enforcement ?? "advisory",
+          reason: input.reason,
+          // Reuse a lapsed record, but start a new period of holding it.
+          acquiredAt: mine !== undefined && isLive(mine, now) ? mine.acquiredAt : now,
+          expiresAt,
+          generation: ids.next("generation"),
+        }) };
       });
-      tx.put("claim", claimId, record, tx.generationOf("claim", claimId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"), workspaceId,
-        actorSessionId: session.sessionId, type: mine === undefined ? "claim.acquired"
-          : "claim.renewed", occurredAt: now,
-        payload: { claimId, resource, mode: record.mode } });
+      for (const { mine, record } of records) {
+        const { claimId, resource } = record;
+        tx.put("claim", claimId, record, tx.generationOf("claim", claimId));
+        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"), workspaceId,
+          actorSessionId: session.sessionId, type: mine === undefined ? "claim.acquired"
+            : "claim.renewed", occurredAt: now,
+          payload: { claimId, resource, mode: record.mode } });
+      }
+      return records.map(item => item.record);
     }, { kinds: ["session", "claim"] });
-    return record;
   }
 
   async function renewClaim(input) {
@@ -146,40 +151,42 @@ export function createClaimService(ports, sessions) {
     return record;
   }
 
-  async function removeClaim(input, { authority, reason }) {
+  async function removeClaims(input, selectors, { authority = null, reason = null } = {}) {
     const session = await requireOwner(input, "release");
-    const now = clock.now();
-    await store.transaction(async tx => {
-      await requireOwner(input, "release", tx);
-      const existing = tx.get("claim", input.claimId);
-      if (existing === null) {
-        throw new AccError(EXIT.CONFLICT, "the claim does not exist", { claimId: input.claimId });
+    return store.transaction(async tx => {
+      await requireOwner(input, "release", tx, true);
+      const now = clock.now();
+      const selected = selectReleaseClaims(tx, selectors, session.sessionId);
+      for (const existing of selected) {
+        const owned = existing.ownerSessionId === session.sessionId;
+        if (!owned && authority !== "human" && authority !== "policy") {
+          throw new AccError(EXIT.CONFLICT,
+            "force release requires human or policy authority",
+            { claimId: existing.claimId, authority });
+        }
       }
-      const owned = existing.ownerSessionId === session.sessionId;
-      // Force release is an authority decision, not a peer decision. A
-      // coordinator lease does not extend outside its own workstream.
-      if (!owned && authority !== "human" && authority !== "policy") {
-        throw new AccError(EXIT.CONFLICT,
-          "force release requires human or policy authority",
-          { claimId: input.claimId, authority: authority ?? null });
+      for (const existing of selected) {
+        const owned = existing.ownerSessionId === session.sessionId;
+        // Remove the live record; per-resource events retain its history.
+        tx.remove("claim", existing.claimId, tx.generationOf("claim", existing.claimId));
+        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+          workspaceId: existing.workspaceId, actorSessionId: session.sessionId,
+          type: owned ? "claim.released" : "claim.force_released", occurredAt: now,
+          payload: { claimId: existing.claimId, authority,
+            reason, replacedGeneration: existing.generation } });
       }
-      // The claim record is removed rather than tombstoned: a released claim is
-      // not a claim, and every consumer of a snapshot would otherwise have to
-      // re-derive liveness. The event log keeps the history.
-      tx.remove("claim", input.claimId, tx.generationOf("claim", input.claimId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: existing.workspaceId, actorSessionId: session.sessionId,
-        type: owned ? "claim.released" : "claim.force_released", occurredAt: now,
-        payload: { claimId: input.claimId, authority: authority ?? null,
-          reason: reason ?? null, replacedGeneration: existing.generation } });
+      return selected;
     }, { kinds: ["session", "claim"] });
   }
 
   return {
-    acquireClaim,
+    acquireClaim: async input => (await acquire(input, [input.resource], false))[0],
+    acquireClaims: input => acquire(input, input.resources, true),
     renewClaim,
-    releaseClaim: input => removeClaim(input, { authority: null, reason: null }),
-    forceReleaseClaim: input => removeClaim(input,
-      { authority: input.authority, reason: input.reason }),
+    releaseClaims: async input => removeClaims(input, releaseSelectors(input)),
+    releaseClaim: async input => { await removeClaims(input, { claimIds: [input.claimId] }); },
+    forceReleaseClaim: async input => { await removeClaims(input, { claimIds: [input.claimId] },
+      { authority: input.authority, reason: input.reason });
+    },
   };
 }

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

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

package/node_modules/@agents-can-communicate/delivery-router/src/router.mjs

@@ -1,12 +1,10 @@
-import { NATIVE_REASON_CODES, evaluateVersionContract, isLaunchOption }
+import { NATIVE_REASON_CODES, evaluateVersionContract, isLaunchOption, OFFER_ERRORS, storeOfferObservation }
   from "@agents-can-communicate/adapter-sdk";
 
 import { lastNativeReason } from "./native-reason.mjs";
 import { refreshExpiredBinding } from "./refresh-binding.mjs";
 
-const SAFE_ERRORS = new Set(["ambiguous_recipient_sessions", "delivery_disabled",
-  "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected", "transport_permission_denied",
-  "unsupported_client_version"]);
+const SAFE_ERRORS = new Set(OFFER_ERRORS);
 const NAMED_LIVE_TRANSPORTS = new Set(["claude-inbox", "codex-app-server"]);
 
 const adaptersById = adapters => adapters instanceof Map
@@ -50,6 +48,14 @@ function safeTransport(value, opaqueEndpointRef) {
 export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
   readNativeReason = input => lastNativeReason({ runtimeDir: service.store?.root, ...input }) }) {
   const registry = adaptersById(adapters);
+  const observeOffer = (binding, reasonCode = null) => {
+    // Capture time and order now, but never await optional diagnostic I/O on
+    // the delivery path. The SDK bounds its own lifetime for short-lived CLIs.
+    void storeOfferObservation({
+      runtimeDir: service.store?.root, workspaceId: service.store?.workspaceId,
+      sessionId: binding.sessionId, generation: binding.generation, at: clock.now(),
+      state: reasonCode === null ? "active" : "degraded", reasonCode }).catch(() => {});
+  };
 
   // A session that bound no live transport may have said why: the reason its
   // own last native attempt recorded, from the closed vocabulary only, and the
@@ -82,6 +88,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       targetGeneration: binding.generation,
       transport: safeTransport(transport, binding.opaqueEndpointRef), adapterId: binding.adapterId,
       clientVersion: binding.clientVersion, safeErrorCode }).catch(() => null);
+    observeOffer(binding, safeErrorCode);
   }
 
   async function offerTo(message, participantId, now) {
@@ -135,7 +142,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       if (!refreshed.refreshed) {
         if (refreshed.errorCode === "transport_permission_denied") {
           await recordFailure(binding, message, participantId, "live-adapter", refreshed.errorCode);
-        }
+        } else observeOffer(binding, refreshed.errorCode);
         return durable(participantId, refreshed.errorCode);
       }
       const current = (await service.listDeliveryBindings({
@@ -216,6 +223,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
     // shown and leave it out of the very turn the wake started. The receipt
     // stays queued; the hook records the offer once its stdout carried the body.
     if (adapter.nativeDelivery?.offerKind === "wake") {
+      observeOffer(binding, response.pendingApproval === true ? "inbound_approval_required" : null);
       // The client took the wake but holds it for its user's approval.
       return { recipientParticipantId: participantId, outcome: "woken", transport,
         ...(response.pendingApproval === true ? { pendingApproval: true } : {}) };
@@ -229,6 +237,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       await recordFailure(binding, message, participantId, transport, "transport_error");
       return durable(participantId, "transport_error");
     }
+    observeOffer(binding);
     return { recipientParticipantId: participantId, outcome: "offered", transport };
   }
 

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

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

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

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

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

@@ -39,6 +39,7 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
         const createdDirectories = await missingArtifactParents({ home: context.home,
           artifacts: operation.artifacts });
         const installContext = { ...context,
+          indicator: operation.indicator,
           clientVersion: operation.clientVersion, platform: operation.platform,
           requestedLivePolicy: operation.livePolicy ?? "off",
           livePolicy: operation.configuredLivePolicy ?? operation.effectiveLivePolicy ?? "off" };
@@ -71,10 +72,12 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           version: operation.clientVersion ?? null, accVersion,
           artifacts: operation.artifacts, createdDirectories,
           deliveryPolicy: operation.livePolicy, deliveryDecision: operation.deliveryDecision,
+          indicator: operation.indicator,
           nativeActivation: native });
         results.operations.push({ ...operation, applied: true,
           needsAction: outcome.needsAction ?? [],
           changes: outcome.changes ?? [], diagnostics: [
+            ...(operation.indicatorDiagnostic === undefined ? [] : [operation.indicatorDiagnostic]),
             ...(operation.deliveryDiagnostic === undefined
               ? [] : [operation.deliveryDiagnostic]),
             ...(outcome.diagnostics ?? []),

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

@@ -121,7 +121,7 @@ async function saveOwnership({ dataHome, record }) {
  */
 export async function recordInstall({ dataHome, adapterId, version, accVersion = null,
   artifacts, createdDirectories = [], deliveryPolicy, deliveryDecision,
-  nativeActivation = null }) {
+  nativeActivation = null, indicator }) {
   const stamped = await Promise.all(artifacts.map(async artifact => ({
     path: artifact.path,
     kind: artifact.kind ?? "file",
@@ -141,6 +141,7 @@ export async function recordInstall({ dataHome, adapterId, version, accVersion =
       { adapterId, version, accVersion, artifacts: stamped,
         ...(directories.length === 0 ? {} : { createdDirectories: directories }),
         ...(deliveryPolicy === undefined ? {} : { deliveryPolicy }),
+        ...(indicator === undefined ? {} : { indicator }),
         ...(retainedDeliveryDecision === undefined ? {} : {
           deliveryDecision: retainedDeliveryDecision,
         }),

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

@@ -14,7 +14,7 @@ import { LIVE_POLICIES, describeActivation, describeDeactivation, planActivation
  */
 export function planInstallation({ adapters, detected, context, action = "install",
   recorded = [], accVersion = null, allowDowngrade = false, requested = [],
-  deliveryByAdapter = {}, deliveryDecisionByAdapter = {}, allowServiceSetup = false }) {
+  deliveryByAdapter = {}, deliveryDecisionByAdapter = {}, allowServiceSetup = false, indicator }) {
   if (!["install", "uninstall"].includes(action)) {
     throw new AccError(EXIT.USAGE, `unknown installation action: ${action}`, { action });
   }
@@ -157,7 +157,13 @@ export function planInstallation({ adapters, detected, context, action = "instal
       : null;
     const deliverySummary = action === "install"
       ? describeInstallDelivery(entry, delivery, effectiveLivePolicy) : null;
-    const installContext = { ...context, requestedLivePolicy: delivery,
+    const indicatorPreference = indicator ?? recordedById.get(entry.adapterId)?.indicator ?? "off";
+    const indicatorDiagnostic = indicatorPreference !== "on" ? null : !adapter.statusIndicator
+      ? `${adapter.displayName} indicator: not supported in this client's native status line`
+      : entry.version == null || isOlder(entry.version, adapter.statusIndicator.minimumVersion)
+        ? `${adapter.displayName} indicator requires client ${adapter.statusIndicator.minimumVersion} or later`
+        : `${adapter.displayName} indicator: enabled; ${adapter.statusIndicator.reload}`;
+    const installContext = { ...context, indicator: indicatorPreference, requestedLivePolicy: delivery,
       livePolicy: configuredLivePolicy, clientVersion: entry.version, platform: entry.platform };
     const nativeServiceSetup = action === "install" && allowServiceSetup && delivery !== "off"
       && deliveryDecision.completeSetup === true ? entry.nativeServiceSetup : undefined;
@@ -192,6 +198,8 @@ export function planInstallation({ adapters, detected, context, action = "instal
       clientPresent: entry.present === true,
       alreadyInstalled: entry.installed === true,
       livePolicy: delivery,
+      indicator: indicatorPreference,
+      ...(indicatorDiagnostic === null ? {} : { indicatorDiagnostic }),
       effectiveLivePolicy,
       ...(action === "install" ? { deliveryDecision } : {}),
       ...(retainedActivation ? { configuredLivePolicy, retainedNativeActivation: retainedActivation } : {}),
@@ -205,6 +213,7 @@ export function planInstallation({ adapters, detected, context, action = "instal
       // 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: [
+        ...(indicatorDiagnostic === null ? [] : [indicatorDiagnostic]),
         ...(entry.present ? [] : [`${adapter.displayName ?? adapter.id} is no longer on `
           + "this machine; removing what ACC recorded writing"]),
         ...(deliverySummary === null ? [] : [deliverySummary]),

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

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

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

@@ -0,0 +1,56 @@
+import { AccError, EXIT, assertMatchableResource, assertPortableId,
+  assertResourceUri, normaliseResource } from "@agents-can-communicate/protocol";
+
+const invalid = message => { throw new AccError(EXIT.USAGE, message); };
+
+function resourceSelector(resource) {
+  assertMatchableResource(resource, invalid);
+  return assertResourceUri(normaliseResource(resource), "resource");
+}
+
+function claimIdSelector(claimId, field) {
+  try { return assertPortableId(claimId, field); }
+  catch (error) {
+    if (!(error instanceof AccError)) throw error;
+    invalid(`${field} must be a portable identifier`);
+  }
+}
+
+// URI normalization and identifier validation must precede resolving a session:
+// an invalid selector must not create presence or a persistent session binding.
+export function validateClaimSelectors(name, args) {
+  if (name !== "acc_claim" && name !== "acc_release") return args;
+  const result = { ...args };
+  if (args.resource !== undefined) result.resource = resourceSelector(args.resource);
+  if (args.resources !== undefined) {
+    result.resources = args.resources.map(resourceSelector);
+    if (new Set(result.resources).size !== result.resources.length) {
+      invalid("arguments.resources contains duplicate selectors after normalization");
+    }
+  }
+  if (args.claimId !== undefined) claimIdSelector(args.claimId, "arguments.claimId");
+  args.claimIds?.forEach((id, index) => claimIdSelector(id, `arguments.claimIds[${index}]`));
+  return result;
+}
+
+export async function claimTool(service, owner, args) {
+  if (args.action === "renew") return service.renewClaim({ ...owner,
+    claimId: args.claimId, leaseSeconds: args.leaseSeconds });
+  const input = { ...owner, mode: args.mode ?? "exclusive", enforcement: "advisory",
+    reason: args.reason ?? "unspecified", leaseSeconds: args.leaseSeconds };
+  if (args.resources !== undefined) {
+    return { claims: await service.acquireClaims({ ...input, resources: args.resources }) };
+  }
+  return service.acquireClaim({ ...input, resource: args.resource });
+}
+
+export async function releaseTool(service, owner, args) {
+  if (args.claimId !== undefined) {
+    await service.releaseClaim({ ...owner, claimId: args.claimId });
+    return { released: args.claimId };
+  }
+  const selected = args.resource !== undefined ? { resources: [args.resource] } : args;
+  const claims = await service.releaseClaims({ ...owner, ...selected });
+  const released = claims.map(claim => claim.claimId);
+  return { released: args.resource !== undefined ? released[0] : released };
+}

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

@@ -43,6 +43,12 @@ function validateSchema(schema, value, path) {
     }
   } else if (schema.type === "array") {
     if (!Array.isArray(value)) fail(path, "must be an array");
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+      fail(path, `must contain at least ${schema.minItems} item(s)`);
+    }
+    if (schema.uniqueItems === true && new Set(value).size !== value.length) {
+      fail(path, "must contain unique items");
+    }
     if (schema.items !== undefined) {
       value.forEach((item, index) => validateSchema(schema.items, item, `${path}[${index}]`));
     }
@@ -53,6 +59,9 @@ function validateSchema(schema, value, path) {
   } else if (schema.type === "integer" && !Number.isInteger(value)) {
     fail(path, "must be an integer");
   }
+  if (schema.minLength !== undefined && value.length < schema.minLength) {
+    fail(path, `must contain at least ${schema.minLength} character(s)`);
+  }
 
   if (schema.minimum !== undefined && value < schema.minimum) {
     fail(path, `must be at least ${schema.minimum}`);

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

@@ -5,6 +5,7 @@ import { clearSessionBinding, loadSessionBinding, storeSessionBinding }
 
 import { readResource } from "./resources.mjs";
 import { validateToolInput } from "./input-validator.mjs";
+import { claimTool, releaseTool, validateClaimSelectors } from "./claim-tools.mjs";
 import { PUBLIC_TOOLS, RESOURCES } from "./tools.mjs";
 import { createProtocol } from "./protocol.mjs";
 
@@ -133,14 +134,9 @@ async function callTool(name, args, context) {
       return service.setIntent({ ...owner, summary: args.summary, mode: args.mode,
         state: args.state, resourceHints: args.resourceHints ?? [] });
     case "acc_claim":
-      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 });
+      return claimTool(service, owner, args);
     case "acc_release":
-      await service.releaseClaim({ ...owner, claimId: args.claimId });
-      return { released: args.claimId };
+      return releaseTool(service, owner, args);
     case "acc_message": {
       const kind = args.kind ?? "note";
       const toParticipantIds = args.to ?? [];
@@ -219,13 +215,16 @@ async function handle(message, context) {
           throw new AccError(EXIT.USAGE, `unknown tool: ${params.name}`, { name: params.name });
         }
         validateToolInput(tool.inputSchema, args);
-        const value = await callTool(params.name, args, context);
+        const value = await callTool(params.name, validateClaimSelectors(params.name, args), context);
         return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
           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.
+        const batchConflict = params.name === "acc_claim"
+          && params.arguments?.resources !== undefined && error.details?.conflicts !== undefined;
         return { isError: true,
+          ...(batchConflict ? { structuredContent: { code: error.code, details: error.details } } : {}),
           content: [{ type: "text", text: `${params.name}: ${error.message}` }] };
       }
     }

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

@@ -19,6 +19,10 @@ const object = (properties, required = []) => ({
 
 const string = description => ({ type: "string", description });
 const stringList = description => ({ type: "array", items: { type: "string" }, description });
+const selector = description => ({ ...string(description), minLength: 1 });
+const selectors = description => ({ type: "array", items: { type: "string", minLength: 1 },
+  minItems: 1, uniqueItems: true, description });
+const releaseFields = ["claimId", "claimIds", "resource", "resources", "all"];
 
 export const PUBLIC_TOOLS = Object.freeze([
   {
@@ -68,31 +72,45 @@ export const PUBLIC_TOOLS = Object.freeze([
   },
   {
     name: "acc_claim",
-    description: `Acquire or renew a claim on a resource URI. Claims are `
+    description: `Acquire one resource or atomically acquire a nonempty resources array; renew by claimId. `
+      + `resource returns a Claim; resources returns {claims: [...]}, including one-item arrays. `
+      + `A conflicting batch acquires nothing and lists every conflicting holder in structuredContent.details.conflicts. Claims are `
       + `workspace-wide and advisory here: this client has no write guard, so a claim `
       + `informs peers rather than preventing an edit. ${MUTATION_POLL}`,
     inputSchema: { ...object({
-      resource: string("Resource URI, for example file:packages/core/**."),
+      resource: selector("One resource URI, exclusive with resources; for example file:packages/core/**."),
+      resources: selectors("Resource URIs for one atomic acquisition; unique after normalization and exclusive with resource."),
       action: { type: "string", enum: ["acquire", "renew"] },
       mode: { type: "string", enum: ["shared", "exclusive"] },
       reason: string("Why the resource is being claimed."),
       leaseSeconds: { type: "integer", minimum: 1,
         description: "Lease length; the claim expires without renewal." },
-      claimId: string("Required for renew."),
+      claimId: selector("Required for renew; renew accepts one claimId only."),
     }, ["action"]), oneOf: [
       { properties: { action: { const: "acquire" } }, required: ["resource"],
-        not: { required: ["claimId"] } },
+        not: { anyOf: ["resources", "claimId"].map(field => ({ required: [field] })) } },
+      { properties: { action: { const: "acquire" } }, required: ["resources"],
+        not: { anyOf: ["resource", "claimId"].map(field => ({ required: [field] })) } },
       { properties: { action: { const: "renew" } }, required: ["claimId"],
-        not: { anyOf: ["resource", "mode", "reason"]
+        not: { anyOf: ["resource", "resources", "mode", "reason"]
           .map(field => ({ required: [field] })) } },
     ] },
   },
   {
     name: "acc_release",
-    description: `Release a claim this session owns. ${MUTATION_POLL}`,
-    inputSchema: object({
-      claimId: string("The claim to release."),
-    }, ["claimId"]),
+    description: `Release only claims this session owns, with exactly one of claimId, claimIds, resource, `
+      + `resources, or all: true. Arrays release atomically. Scalar selectors return {released: id}; `
+      + `arrays and all return {released: [ids]}, including an empty all result. `
+      + `all keeps this session's presence and intent open. ${MUTATION_POLL}`,
+    inputSchema: { ...object({
+      claimId: selector("One claim to release."),
+      claimIds: selectors("Claim IDs to release atomically."),
+      resource: selector("One exact resource URI this session holds."),
+      resources: selectors("Exact resource URIs to release atomically; unique after normalization."),
+      all: { type: "boolean", const: true, description: "Release every claim owned by this session." },
+    }), oneOf: releaseFields.map(field => ({ required: [field],
+      not: { anyOf: releaseFields.filter(other => other !== field)
+        .map(other => ({ required: [other] })) } })) },
   },
   {
     name: "acc_message",

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

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

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

@@ -11,5 +11,6 @@ export { CONFIG_FILENAME, CONFIG_SCHEMA_VERSION, RUNTIME_KEYS, defaultProjectCon
   validateProjectConfig } from "./config.mjs";
 export { RECEIPT_STATES, advanceReceipt } from "./states.mjs";
 export { assertMatchableResource, normaliseResource } from "./resources.mjs";
+export { resourceUri as assertResourceUri } from "./fields.mjs";
 export { assertDecisionChange } from "./decision-changes.mjs";
 export { TRANSACTION_INDEXES, assertIndexTuple, indexKeysFor } from "./transaction-indexes.mjs";

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

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

package/node_modules/@agents-can-communicate/storage-filesystem/src/index.mjs

@@ -3,6 +3,6 @@ export { openFilesystemStore, storePaths, ZERO_CURSOR } from "./store.mjs";
 export { diagnoseFilesystemStore, repairFilesystemStore } from "./recovery.mjs";
 export { readStoreIdentity, requireStoreIdentity, STORE_VERSION } from "./identity.mjs";
 export { withWriterMutex } from "./writer-mutex.mjs";
-export { readSessionRecord } from "./session-read.mjs";
+export { readSessionRecord, readDeliveryBindingRecord } from "./session-read.mjs";
 export { openNoFollow } from "./portable-fs.mjs";
 export { migrateFilesystemStore } from "./store-migration.mjs";