agents-can-communicate 0.1.18 → 0.3.0

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

@@ -1,6 +1,6 @@
-// The model-facing surface stays at six high-level operations. Granular
-// internal transitions remain available to adapters through the CLI and are
-// deliberately not advertised here.
+import { GENERIC_MESSAGE_KINDS } from "@agents-can-communicate/protocol";
+
+// The model-facing surface stays at a small set of high-level operations.
 //
 // Every description says that delivery is polled, because a tool description is
 // the only contract the model ever sees. MCP guarantees no lifecycle, no push,
@@ -20,12 +20,18 @@ const string = description => ({ type: "string", description });
 const stringList = description => ({ type: "array", items: { type: "string" }, description });
 
 export const PUBLIC_TOOLS = Object.freeze([
+  {
+    name: "acc_status",
+    description: `Read who is here, current intents and claims, and the workspace's real `
+      + `protection level. ${POLLED}`,
+    inputSchema: object({}),
+  },
   {
     name: "acc_sync",
     description: `Read coordination state for this workspace: roster, attention items, and `
       + `events since a cursor. Use scope "full" to answer questions about the whole `
-      + `workspace, including other participants' collapsed child sessions. Pending mail is `
-      + `also returned for compatibility; prefer acc_inbox for targeted reads. ${POLLED}`,
+      + `workspace, including other participants' collapsed child sessions. Use acc_inbox `
+      + `instead for addressed messages. ${POLLED}`,
     inputSchema: object({
       cursor: string("Resume from this cursor; omit to start from the beginning."),
       scope: { type: "string", enum: ["delta", "full"],
@@ -38,48 +44,62 @@ export const PUBLIC_TOOLS = Object.freeze([
     name: "acc_work",
     description: `Publish what this session is doing now as one concise Intent. Intent is `
       + `awareness, not authorisation: it never reserves a resource. ${POLLED}`,
-    inputSchema: object({
+    inputSchema: { ...object({
       summary: string("One line describing the current work."),
       mode: { type: "string",
         enum: ["observe", "explore", "edit", "review", "coordinate", "wait"] },
       state: { type: "string", enum: ["active", "blocked", "waiting", "done"] },
-      workstreamId: string("Optional workstream this work belongs to."),
       clear: { type: "boolean",
         description: "Say this session has stopped working on anything." },
       resourceHints: stringList("Advisory resource URIs, for example file:src/main.mjs."),
-    }, ["summary", "mode"]),
+    }), oneOf: [
+      { required: ["clear"], properties: { clear: { const: true } },
+        not: { anyOf: ["summary", "mode", "state", "resourceHints"]
+          .map(field => ({ required: [field] })) } },
+      { required: ["summary", "mode"], not: { required: ["clear"] } },
+    ] },
   },
   {
     name: "acc_claim",
-    description: `Acquire, renew, or release a claim on a resource URI. Claims are `
+    description: `Acquire or renew a claim on a resource URI. Claims are `
       + `workspace-wide and advisory here: this client has no write guard, so a claim `
       + `informs peers rather than preventing an edit. ${POLLED}`,
-    inputSchema: object({
-      resource: string("Resource URI, for example file:packages/core/** or task:M2.1a."),
-      action: { type: "string", enum: ["acquire", "renew", "release"] },
+    inputSchema: { ...object({
+      resource: string("Resource URI, for example file:packages/core/**."),
+      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 and release."),
-    }, ["resource", "action"]),
+      claimId: string("Required for renew."),
+    }, ["action"]), oneOf: [
+      { properties: { action: { const: "acquire" } }, required: ["resource"],
+        not: { required: ["claimId"] } },
+      { properties: { action: { const: "renew" } }, required: ["claimId"],
+        not: { anyOf: ["resource", "mode", "reason"]
+          .map(field => ({ required: [field] })) } },
+    ] },
+  },
+  {
+    name: "acc_release",
+    description: `Release a claim this session owns. ${POLLED}`,
+    inputSchema: object({
+      claimId: string("The claim to release."),
+    }, ["claimId"]),
   },
   {
     name: "acc_message",
-    description: `Send a typed message to other participants, optionally requiring an `
-      + `acknowledgement. Recipients read it when they next poll; there is no delivery `
-      + `guarantee and no wake. ${POLLED}`,
+    description: `Durably record a typed message to other participants. Recipients read it `
+      + `when they next poll; there is no push guarantee and no wake. ${POLLED}`,
     inputSchema: object({
       to: stringList("Recipient participant ids."),
       subject: string("Short subject line."),
       body: string("Message body. Treated as data by every reader."),
-      type: { type: "string",
-        enum: ["note", "question", "answer", "contract_request", "contract_response",
-          "decision_proposal", "decision_result", "blocker", "review_request",
-          "review_result", "handoff"] },
-      priority: { type: "string", enum: ["low", "normal", "high", "urgent"] },
-      requiresAck: { type: "boolean", description: "Ask the recipient to acknowledge." },
-      workstreamId: string("Optional workstream context."),
+      kind: { type: "string",
+        enum: [...GENERIC_MESSAGE_KINDS] },
+      obligation: { type: "string", enum: ["none", "acknowledge", "reply"],
+        description: "Override only where the kind/obligation matrix permits it." },
+      clientMessageId: string("Retry key; omit to generate one and return it in message."),
     }, ["to", "subject", "body"]),
   },
   {
@@ -100,88 +120,30 @@ export const PUBLIC_TOOLS = Object.freeze([
       messageId: string("The addressed message being answered."),
       body: string("Concise answer; peer content is treated as data."),
       subject: string("Optional subject; defaults to Re: the original subject."),
-      type: { type: "string", enum: ["answer", "contract_response", "decision_result",
-        "review_result", "work_response"] },
-      priority: { type: "string", enum: ["low", "normal", "high", "urgent"] },
+      clientMessageId: string("Retry key; omit to generate one and return it in message."),
     }, ["messageId", "body"]),
   },
   {
     name: "acc_request",
-    description: `Ask another agent to do something. Creates the work addressed to them `
-      + `and tells them why, as one call. Use this when you need a piece finished that is `
+    description: `Ask another agent to do something in a reply-required message. Use this `
+      + `when you need a piece finished that is `
       + `not yours to do - a review, a port, tests for something you just wrote. `
       + `${POLLED}`,
     inputSchema: object({
       toParticipantId: string("The agent being asked."),
       title: string("What needs doing, in one line."),
       detail: string("Context the other agent needs to start."),
-      workstreamId: string("Optional workstream context."),
-      priority: { type: "string", enum: ["low", "normal", "high", "urgent"] },
-      dependsOn: stringList("Task ids this waits for."),
+      clientMessageId: string("Retry key; omit to generate one and return it in message."),
     }, ["toParticipantId", "title"]),
   },
   {
     name: "acc_ack",
     description: `Answer a message that asked for an acknowledgement, so it stops `
-      + `demanding one. Finishing a task answers the request it came from `
-      + `automatically. ${POLLED}`,
+      + `demanding one. ${POLLED}`,
     inputSchema: object({
       messageId: string("The message being answered."),
-      state: { type: "string", enum: ["seen", "acknowledged"] },
     }, ["messageId"]),
   },
-  {
-    name: "acc_decide",
-    description: `Record what was settled, so the next session does not reopen it. `
-      + `Separate from a message because a decision outlives the conversation that `
-      + `produced it. \`authority\` is who settled it: \`workstream\` for an agreement `
-      + `between agents, \`policy\` for a rule that already existed, \`human\` only when a `
-      + `person actually said so - which needs \`humanConfirmed\`. ${POLLED}`,
-    inputSchema: object({
-      title: string("What was decided, in one line."),
-      outcome: string("What was settled, and enough of why to act on it."),
-      authority: { type: "string", enum: ["workstream", "policy", "human"],
-        description: "Default: workstream." },
-      humanConfirmed: { type: "boolean",
-        description: "A person said so. Required for human authority." },
-      workstreamId: string("Optional workstream context."),
-      supersedes: string("A decision this replaces."),
-      decidedBy: stringList("Participants who settled it. Defaults to you."),
-    }, ["title", "outcome"]),
-  },
-  {
-    name: "acc_workstream",
-    description: `Group related work so several agents can see it as one thing, or take `
-      + `on steering one that exists. Optional: a single request needs no workstream. `
-      + `An open workstream with no coordinator is reported to everyone until somebody `
-      + `takes it. ${POLLED}`,
-    inputSchema: object({
-      action: { type: "string", enum: ["create", "coordinate", "release"],
-        description: "Default: create." },
-      title: string("Short name. Creating one."),
-      objective: string("What finishing it would mean. Creating one."),
-      workstreamId: string("The workstream to coordinate or hand back."),
-    }, []),
-  },
-  {
-    name: "acc_task",
-    description: `Create or transition an optional task within a workstream. Tasks are for `
-      + `work that needs assignment, dependencies, or acceptance tracking; ordinary work `
-      + `needs only Intent. ${POLLED}`,
-    inputSchema: object({
-      action: { type: "string", enum: ["create", "claim", "transition", "decline"] },
-      workstreamId: string("Workstream the task belongs to."),
-      title: string("Task title, required when creating."),
-      detail: string("Context for whoever picks it up."),
-      assigneeParticipantId: string("Agent this is for. Only they can take it."),
-      taskId: string("Required for claim and transition."),
-      state: { type: "string", enum: ["pending", "in_progress", "review", "done", "blocked"] },
-      dependsOn: stringList("Task ids this task waits for."),
-      reason: string("Why, when declining."),
-      force: { type: "boolean",
-        description: "Take work held by a session that has gone quiet." },
-    }, ["action"]),
-  },
   {
     name: "acc_finish",
     description: `Record a handoff describing what was completed and what remains, and `
@@ -194,32 +156,27 @@ export const PUBLIC_TOOLS = Object.freeze([
       remaining: stringList("What is left."),
       blockers: stringList("What is in the way."),
       toParticipantId: string("Participant taking over, if any."),
+      clientMessageId: string("Retry key; omit to generate one and return it in message."),
     }, ["goal"]),
   },
 ]);
 
 export const RESOURCES = Object.freeze([
   { uri: "acc://snapshot", name: "Workspace snapshot", mimeType: "application/json",
-    description: "The whole coordination state: participants, intents, claims, tasks." },
+    description: "The whole coordination state: participants, intents, claims, and messages." },
   { uri: "acc://roster", name: "Participant roster", mimeType: "application/json",
     description: "Sessions with their harness and presence, including collapsed children." },
-  { uri: "acc://workstreams", name: "Workstreams", mimeType: "application/json",
-    description: "Open workstreams and their coordinator lease, if any." },
-  { uri: "acc://tasks", name: "Tasks", mimeType: "application/json",
-    description: "Tasks with state, assignee, and dependencies." },
   { uri: "acc://inbox", name: "Inbox", mimeType: "application/json",
     description: "Messages addressed to this participant, rendered as attributed data." },
 ]);
 
-// Declared, not assumed. MCP is a polling transport with no lifecycle contract,
-// so everything except polling stays false.
+// Declared, not assumed. Manual MCP tool polling is not next-turn injection,
+// live push, or a native reply route, so every adapter delivery mode is false.
 export const MCP_CAPABILITIES = Object.freeze({
   lifecycle: Object.freeze({ sessionStart: false, sessionResume: false, sessionEnd: false,
     childSessions: false }),
   context: Object.freeze({ startupInjection: false, beforeTurnInjection: false,
     safePointInjection: false }),
   guards: Object.freeze({ beforeRead: false, beforeWrite: false, beforeShell: false }),
-  delivery: Object.freeze({ polling: true, activeNotification: false,
-    wakeDormantSession: false }),
-  execution: Object.freeze({ launch: false, resume: false, terminate: false }),
+  delivery: Object.freeze({ nextTurn: false, livePush: false, replyRoute: false }),
 });

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

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

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

@@ -12,7 +12,7 @@ export const CONFIG_FILENAME = "acc.workspace.json";
 // the wrong place for them, and a config carrying them is either a mistake or
 // an attempt to hand a peer state it would otherwise have to earn.
 export const RUNTIME_KEYS = Object.freeze(["sessions", "participants", "messages",
-  "claims", "receipts", "intents", "events", "tokens", "credentials"]);
+  "claims", "receipts", "intents", "events", "deliveryBindings", "tokens", "credentials"]);
 
 const KNOWN_KEYS = Object.freeze(["schemaVersion", "workspaceId", "displayName",
   "roots", "policy", "requiredAdapters", "extensions"]);

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

@@ -0,0 +1,64 @@
+import { AccError, EXIT } from "./errors.mjs";
+
+export const VALID_OBLIGATIONS = Object.freeze({
+  note: Object.freeze(["none"]),
+  question: Object.freeze(["reply"]),
+  request: Object.freeze(["reply"]),
+  answer: Object.freeze(["none"]),
+  decision: Object.freeze(["none", "acknowledge"]),
+  handoff: Object.freeze(["none", "acknowledge"]),
+});
+
+export const MESSAGE_KINDS = Object.freeze(Object.keys(VALID_OBLIGATIONS));
+// The generic send surface cannot construct reply links or structured handoff
+// payloads. Those two complete shapes belong to reply and finish respectively.
+export const GENERIC_MESSAGE_KINDS = Object.freeze(
+  ["note", "question", "request", "decision"]);
+export const OBLIGATIONS = Object.freeze(["none", "acknowledge", "reply"]);
+
+const data = (message, details) => {
+  throw new AccError(EXIT.DATA, message, details);
+};
+
+export function assertMessageSemantics(message) {
+  const room = message.toParticipantIds.length === 0;
+  if (room && !["note", "decision", "handoff"].includes(message.kind)) {
+    data(`a room message cannot have kind ${message.kind}`, { kind: message.kind });
+  }
+  if (room && message.obligation !== "none") {
+    data("a room message must have obligation none", { obligation: message.obligation });
+  }
+
+  const valid = VALID_OBLIGATIONS[message.kind] ?? [];
+  if (!valid.includes(message.obligation)) {
+    data(`message obligation ${message.obligation} is invalid for ${message.kind}`,
+      { kind: message.kind, obligation: message.obligation });
+  }
+
+  const root = message.threadId === message.messageId;
+  if (message.kind === "answer" && message.inReplyTo === null) {
+    data("an answer requires inReplyTo", { messageId: message.messageId });
+  }
+  if (message.kind === "answer" && root) {
+    data("an answer cannot be a thread root", { messageId: message.messageId });
+  }
+  if (message.inReplyTo === null && !root) {
+    data("a thread root requires threadId to equal messageId",
+      { threadId: message.threadId, messageId: message.messageId });
+  }
+  if (message.inReplyTo !== null && root) {
+    data("a thread root must have inReplyTo null", { inReplyTo: message.inReplyTo });
+  }
+
+  if (message.kind === "handoff" && message.handoff === null) {
+    data("a handoff message requires a handoff payload", { messageId: message.messageId });
+  }
+  if (!room && message.kind === "handoff" && message.obligation !== "acknowledge") {
+    data("an addressed handoff requires acknowledgement",
+      { messageId: message.messageId, obligation: message.obligation });
+  }
+  if (message.kind !== "handoff" && message.handoff !== null) {
+    data(`a ${message.kind} message must have handoff null`, { kind: message.kind });
+  }
+  return message;
+}

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

@@ -74,6 +74,23 @@ export const listOf = inner => (value, field) => {
 export const nullable = inner => (value, field) =>
   (value === null ? null : inner(value, field));
 
+/**
+ * A field that may be absent entirely.
+ *
+ * For a fact that either happened or did not, absence is the honest encoding of
+ * "not yet" - and it is what a record written before the field existed already
+ * says. Every record carries a schemaVersion, but adding a required field to a
+ * kind that outlives an upgrade turns a stored record into an unreadable one:
+ * measured, one binding written by the previous build made `acc status` fail
+ * outright with "deliveryBinding requires retiredAt". A coordination tool must
+ * not refuse to read its own store because it was upgraded.
+ */
+export const optional = inner => {
+  const check = (value, field) => (value === undefined ? undefined : inner(value, field));
+  check.optional = true;
+  return check;
+};
+
 export const positiveInteger = (value, field) => {
   if (!Number.isSafeInteger(value) || value <= 0) {
     invalid(field, "must be a positive integer", value);

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

@@ -3,7 +3,10 @@ export { AccError, EXIT, isAccError } from "./errors.mjs";
 export { assertPortableId, createId } from "./ids.mjs";
 export { ENVELOPE_VERSION, failure, ok } from "./envelopes.mjs";
 export { RECORD_KINDS, SCHEMA_VERSION, validateRecord } from "./schema.mjs";
+export { GENERIC_MESSAGE_KINDS, MESSAGE_KINDS, OBLIGATIONS, VALID_OBLIGATIONS,
+  assertMessageSemantics }
+  from "./conversations.mjs";
 export { CONFIG_FILENAME, CONFIG_SCHEMA_VERSION, RUNTIME_KEYS, defaultProjectConfig,
   validateProjectConfig } from "./config.mjs";
-export { DELIVERY_STATES, TASK_STATES, advanceDelivery, transitionTask } from "./states.mjs";
+export { RECEIPT_STATES, advanceReceipt } from "./states.mjs";
 export { assertMatchableResource, normaliseResource } from "./resources.mjs";

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

@@ -1,8 +1,9 @@
+import { assertMessageSemantics, MESSAGE_KINDS, OBLIGATIONS } from "./conversations.mjs";
 import { AccError, EXIT } from "./errors.mjs";
-import { flag, id, invalid, listOf, nullable, oneOf, plainObject, positiveInteger,
+import { id, invalid, listOf, nullable, oneOf, optional, plainObject, positiveInteger,
   resourceUri, sequence, text, timestamp } from "./fields.mjs";
 
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 3;
 
 const line = text();
 const prose = text({ max: 4000, multiline: true });
@@ -14,10 +15,22 @@ const artifactKind = oneOf("file", "git", "url", "report", "image", "data");
 /** @typedef {{ cursor: string, events: AccEvent[] }} EventPage */
 /** @typedef {{ kind: string, priority: number, sourceId: string, summary: string }} AttentionItem */
 /** @typedef {{ workspace: object, participants: object[], sessions: object[],
- * intents: object[], workstreams: object[], tasks: object[], claims: object[] }} WorkspaceSnapshot */
+ * intents: object[], claims: object[], messages: object[], receipts: object[] }} WorkspaceSnapshot */
+
+function closedObject(value, field, fields) {
+  plainObject(value, field);
+  for (const key of Object.keys(value)) {
+    if (!Object.hasOwn(fields, key)) invalid(`${field}.${key}`, "is not a known field", value[key]);
+  }
+  for (const [key, check] of Object.entries(fields)) {
+    if (!Object.hasOwn(value, key)) {
+      throw new AccError(EXIT.DATA, `${field} requires ${key}`, { field, key });
+    }
+    check(value[key], `${field}.${key}`);
+  }
+  return value;
+}
 
-// Field names stay mappable to the A2A Agent Card, Task, Message, and Artifact
-// concepts (spec section 11) without importing any A2A transport.
 const artifactRef = (value, field) => {
   plainObject(value, field);
   const known = new Set(["kind", "uri", "description", "sha256"]);
@@ -33,120 +46,84 @@ const artifactRef = (value, field) => {
   return value;
 };
 
-// Every event ACC itself appends. Closed on purpose: `type` used to be free
-// text, so a record written by hand validated cleanly and `acc doctor` called
-// the store healthy. That is not theoretical - a session that could not run the
-// CLI wrote its own events, inventing `task.completed`, and the store reported
-// no problem.
+const handoffPayload = (value, field) => closedObject(value, field, {
+  status: oneOf("complete", "partial", "blocked"),
+  completed: listOf(line),
+  remaining: listOf(line),
+  blockers: listOf(line),
+  verification: listOf(artifactRef),
+});
+
 const EVENT_TYPES = Object.freeze([
   "workspace.materialised",
   "session.opened", "session.closed",
   "intent.published", "intent.cleared",
-  "workstream.created", "workstream.coordinator_acquired",
-  "workstream.coordinator_released",
-  "task.created", "task.claimed", "task.transitioned", "task.unblocked",
-  "task.declined", "task.released",
   "claim.acquired", "claim.released", "claim.renewed", "claim.force_released",
-  "message.sent", "decision.recorded", "handoff.created",
-  // Delivery transitions and request outcomes are templated from their state,
-  // so the set has to carry each one they can produce.
-  ...["recorded", "queued", "injected", "seen", "acknowledged", "failed"]
-    .map(state => `message.${state}`),
-  ...["accepted", "declined", "review", "done", "released"]
-    .map(outcome => `work.${outcome}`),
-  "work.requested",
+  "message.recorded", "message.offered", "message.retrieved", "message.acknowledged",
+  "message.offer_succeeded", "message.offer_failed",
 ]);
 
 const eventType = oneOf(...EVENT_TYPES);
 
-const RECORDS = Object.freeze({
+// nextTurn is the durable hook projection; the other four are what a native
+// transport proved for one session generation. A mode listed twice would let a
+// reader count capabilities it does not have.
+export const DELIVERY_MODES = Object.freeze(["nextTurn", "livePush", "idleWake", "busyQueue",
+  "replyRoute"]);
+const uniqueListOf = check => (value, field) => {
+  listOf(check)(value, field);
+  if (new Set(value).size !== value.length) invalid(field, "must not repeat entries", value);
+};
+const receiptState = oneOf("queued", "offered", "retrieved", "acknowledged");
+
+const DURABLE_RECORDS = Object.freeze({
   workspace: { workspaceId: id, displayName: line, source: oneOf("config", "git", "directory"),
     roots: listOf(line), createdAt: timestamp },
 
   participant: { participantId: id, workspaceId: id, displayName: line,
     kind: oneOf("agent", "human"), createdAt: timestamp },
 
-  // `enforcement` and `lifecycle` are what this session's harness can actually
-  // do, declared at attach. The harness name does not imply them: the same
-  // client guards or does not depending on its model and its approval mode, and
-  // a peer deciding whether to rely on a claim needs the answer, not the brand.
-  // A workspace spans every worktree of one repository, so the workspace id
-  // cannot say which checkout a session is sitting in. Recorded at attach from
-  // what discovery already resolved: without it nobody can tell which worktrees
-  // have an owner, and asking cannot answer for the agents that are not running
-  // - which are exactly the ones a clean-up is looking for.
   session: { sessionId: id, participantId: id, workspaceId: id, generation: id,
     harness: line, state: oneOf("open", "closed"), parentSessionId: nullable(id),
-    checkoutRoot: nullable(line), branch: nullable(line),
-    // The process behind this session, when it can be named. Null means nobody
-    // knows - no process table, or an ancestry that did not resolve - and is
-    // read as "judge this one by age alone", never as "dead".
-    pid: nullable(positiveInteger),
+    checkoutRoot: nullable(line), branch: nullable(line), pid: nullable(positiveInteger),
     enforcement: oneOf("guarded", "advisory"), lifecycle: oneOf("managed", "manual"),
     heartbeatCadenceMs: positiveInteger, startedAt: timestamp, heartbeatAt: timestamp },
 
   intent: { sessionId: id, workspaceId: id, summary,
     mode: oneOf("observe", "explore", "edit", "review", "coordinate", "wait"),
-    resourceHints: listOf(resourceUri), workstreamId: nullable(id),
+    resourceHints: listOf(resourceUri),
     state: oneOf("active", "blocked", "waiting", "done"), updatedAt: timestamp },
 
-  workstream: { workstreamId: id, workspaceId: id, title: line, objective: prose,
-    coordinatorSessionId: nullable(id),
-    state: oneOf("open", "paused", "complete", "cancelled"), createdAt: timestamp },
-
-  // Two assignees, deliberately. `assigneeParticipantId` is who the work is
-  // for and survives that agent restarting; `assigneeSessionId` is the exact
-  // session doing it right now and dies with the process. Asking one field to
-  // be both would either lose the request when a terminal closes or claim a
-  // dead session is still working.
-  task: { taskId: id, workstreamId: nullable(id), workspaceId: id, title: line,
-    state: oneOf("pending", "in_progress", "review", "done", "blocked"),
-    assigneeParticipantId: nullable(id), assigneeSessionId: nullable(id),
-    // Who asked. Without it nothing could tell the requester that their work
-    // was accepted, declined or finished - the task knew who it was for and
-    // had no idea who was waiting on it.
-    requestedByParticipantId: nullable(id),
-    dependsOn: listOf(id), acceptance: listOf(line), detail: nullable(prose),
-    createdAt: timestamp },
-
   claim: { claimId: id, workspaceId: id, ownerSessionId: id, resource: resourceUri,
     mode: oneOf("shared", "exclusive"), enforcement: oneOf("advisory", "guarded"),
     reason: line, acquiredAt: timestamp, expiresAt: timestamp, generation: id },
 
-  // `fromParticipantId` beside the session: a session ends, and the one fact
-  // that has to outlive it is who was speaking. Resolving the sender by looking
-  // its session up meant the record could never be retired, and an agent whose
-  // client had restarted stopped being told about its own unanswered question.
-  message: { messageId: id, workspaceId: id, fromSessionId: id,
-    fromParticipantId: id, toParticipantIds: listOf(id),
-    type: oneOf("note", "question", "answer", "contract_request", "contract_response",
-      "decision_proposal", "decision_result", "blocker", "review_request",
-      "review_result", "handoff", "work_request", "work_response"),
-    subject: line, body: prose, priority: oneOf("low", "normal", "high", "urgent"),
-    workstreamId: nullable(id), taskId: nullable(id), inReplyTo: nullable(id),
-    requiresAck: flag, artifacts: listOf(artifactRef), sentAt: timestamp },
+  message: { messageId: id, threadId: id, clientMessageId: id, workspaceId: id,
+    fromParticipantId: id, fromSessionId: id, toParticipantIds: listOf(id),
+    kind: oneOf(...MESSAGE_KINDS), obligation: oneOf(...OBLIGATIONS),
+    subject: line, body: prose, inReplyTo: nullable(id), artifacts: listOf(artifactRef),
+    handoff: nullable(handoffPayload), sentAt: timestamp },
 
   receipt: { messageId: id, workspaceId: id, recipientParticipantId: id,
-    state: oneOf("recorded", "queued", "injected", "seen", "acknowledged", "failed"),
-    updatedAt: timestamp },
-
-  decision: { decisionId: id, workspaceId: id, workstreamId: nullable(id), title: line,
-    outcome: prose, authority: oneOf("human", "workstream", "policy"),
-    decidedBy: listOf(id), evidence: listOf(artifactRef), supersedes: nullable(id),
-    decidedAt: timestamp },
-
-  artifact: { kind: artifactKind, uri: resourceUri, description: line },
-
-  handoff: { handoffId: id, workspaceId: id, fromSessionId: id, toParticipantId: nullable(id),
-    goal: line, status: oneOf("complete", "partial", "blocked"), completed: listOf(line),
-    remaining: listOf(line), blockers: listOf(line), claimsToRelease: listOf(resourceUri),
-    verification: listOf(artifactRef), artifacts: listOf(artifactRef), createdAt: timestamp },
+    state: receiptState, updatedAt: timestamp },
 
   event: { sequence, eventId: id, workspaceId: id, actorSessionId: id, type: eventType,
     occurredAt: timestamp, payload: plainObject },
 });
 
-export const RECORD_KINDS = Object.freeze(Object.keys(RECORDS));
+const RECORDS = Object.freeze({
+  ...DURABLE_RECORDS,
+  deliveryBinding: { sessionId: id, generation: id, adapterId: id, clientVersion: line,
+    availableModes: uniqueListOf(oneOf(...DELIVERY_MODES)),
+    livePolicy: oneOf("off", "actionable", "all"), opaqueEndpointRef: prose,
+    // The lease says how long the endpoint's owner has vouched for it; the
+    // retirement says the session gave it up. They were once the same field -
+    // clearing expired the lease - which made a renewal by a channel that had
+    // not yet noticed indistinguishable from a legitimate extension.
+    leaseUntil: timestamp, retiredAt: optional(nullable(timestamp)) },
+});
+
+export const RECORD_KINDS = Object.freeze(Object.keys(DURABLE_RECORDS));
 
 export function validateRecord(kind, value) {
   const fields = RECORDS[kind];
@@ -161,19 +138,16 @@ export function validateRecord(kind, value) {
   }
   for (const key of Object.keys(value)) {
     if (key === "schemaVersion" || key === "extensions") continue;
-    if (!Object.hasOwn(fields, key)) {
-      invalid(`${kind}.${key}`, "is not a known field", value[key]);
-    }
+    if (!Object.hasOwn(fields, key)) invalid(`${kind}.${key}`, "is not a known field", value[key]);
   }
   for (const [field, check] of Object.entries(fields)) {
     if (!Object.hasOwn(value, field)) {
+      if (check.optional === true) continue;
       throw new AccError(EXIT.DATA, `${kind} requires ${field}`, { kind, field });
     }
     check(value[field], field);
   }
-  // Forward-compatible metadata is tolerated only inside a named container, so
-  // an older reader can round-trip a newer writer's record without guessing
-  // which unknown top-level keys are safe.
   if (Object.hasOwn(value, "extensions")) plainObject(value.extensions, "extensions");
+  if (kind === "message") assertMessageSemantics(value);
   return value;
 }