@cotal-ai/connector-core 0.58.0 → 0.60.0

package/dist/agent.js

@@ -1,7 +1,9 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { execFile } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { hostname } from "node:os";
 import { normalizeMentions, RUN_LAUNCH_DEADLINE_MS, subjectMatches, isConcreteChannel, assertValidChannel, channelInAllow, resolvePeer as resolvePeerInRoster, CotalEndpoint, BASELINE_LIFECYCLE_ENDPOINT, assertLifecycleToken, EpEnvelopeError, isPublishPermissionDenied, unansweredRequest, renderLifecycleBlocked, partsToText, } from "@cotal-ai/core";
+import { attributionSafe } from "./framing.js";
 import { invokeUserManager } from "./manager-call.js";
 /** Client-side floor for a spawn action's submit + follow. The manager acceptance carries the exact
  *  connector-selected readiness budget, and core extends the follow through that budget plus
@@ -80,7 +82,12 @@ const OVERFLOW_EVICTION_CAP = 4 * MAX_INBOX;
 const MAX_AHEAD = 256;
 const CLASSIFICATION_CAP = 4096;
 const FOCUS_EXCLUSION_CAP = 4096;
+/** #662: history reads one channel's recall makes while an id-less copy keeps arriving mid-read. */
+const IDLESS_READS = 3;
 const PROTECTED_DISPOSITION_CAP = 4096;
+/** How many unanswered directed messages, and how many asked questions, one session remembers for
+ *  reply correlation. */
+const MAX_CORRELATIONS = 1024;
 /** Repeated async NATS status errors can arrive once per ordered-consumer retry. They describe one
  * fault, not one hundred useful facts; keep the first visible and summarize at most twice a minute. */
 const ENDPOINT_ERROR_LOG_WINDOW_MS = 30_000;
@@ -89,7 +96,21 @@ const ENDPOINT_ERROR_LOG_WINDOW_MS = 30_000;
  *  poll is the intake's whole latency: a fresh turn waits at most one interval plus one wake.
  *  Deadlines are minutes-scale; fifteen seconds of intake lag is invisible to a run. */
 const TURN_POLL_MS = 15_000;
-import { randomUUID } from "node:crypto";
+/** Largest epoch-ms a `Date` can hold; past it `toISOString()` throws. */
+const MAX_DATE_MS = 8.64e15;
+/** A `turn-pending` row as the manager contract declares it, with a deadline a `Date` can format. */
+function isPendingTurn(t) {
+    const r = t;
+    return typeof r === "object" && r !== null && typeof r.goalId === "string" && typeof r.payload === "string" &&
+        Number.isSafeInteger(r.acceptedAt) && r.acceptedAt >= 0 &&
+        Number.isSafeInteger(r.deadlineAt) && r.deadlineAt >= 1 && r.deadlineAt <= MAX_DATE_MS;
+}
+import { createHash, randomUUID } from "node:crypto";
+/** #662: what an id-less channel delivery shares with its stream copy. Both are the same published
+ *  bytes, read through the same authentication, so their content is all that links them. */
+function idlessDigest(m) {
+    return createHash("sha256").update(JSON.stringify(m)).digest("base64url");
+}
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
@@ -145,6 +166,22 @@ function renderEscalation(p) {
     return `\nThis turn is a checkpoint escalated to you at step ${String(p.step)}: ${String(c.prompt)}${by}${wanted}`
         + `\nAnswer with: cotal run answer ${String(p.run)} ${String(p.step)} --value '<json>'`;
 }
+/**
+ * A thin, mesh-native agent: a {@link CotalEndpoint} plus a buffered inbox and
+ * name-based peer resolution. This is the shared core behind the MCP server
+ * (and, later, the lifecycle hooks) — it owns the NATS connection and presence.
+ *
+ * Connecting is resilient: {@link start} kicks off a background retry loop so the
+ * MCP server is responsive immediately even if the mesh isn't up yet.
+ *
+ * Emits `"incoming"` (InboxItem) when a message is buffered or an unacked durable copy
+ * redelivers, so a push layer can apply its normal delivery policy again; `"mention-wake"`
+ * (InboxItem) when a `focus`-mode agent is @-mentioned on a channel — the body was
+ * acked-and-dropped (not buffered), so this
+ * only asks the push layer to *wake* the agent to pull it; `"wake"` (no payload) to ask that
+ * layer to wake the session now (the Stop→idle flush of held messages); `"error"` (Error) for
+ * endpoint faults.
+ */
 export class MeshAgent extends EventEmitter {
     ep;
     config;
@@ -225,6 +262,15 @@ export class MeshAgent extends EventEmitter {
     pullTrouble;
     turnPollBusy = false;
     _contextId;
+    /** The per-call correlation a {@link withCorrelation} scope binds for the sends inside it. */
+    correlation = new AsyncLocalStorage();
+    /** By message id, oldest first: the live DMs and anycasts peers sent us that no DM back has
+     *  answered yet (bounded). `pending` marks one a DM in flight is answering; `text` is the start of
+     *  its body, to name it when a DM must say which one it answers. */
+    unanswered = new Map();
+    /** By `contextId`, the questions this seat asked inside a {@link withCorrelation} scope, and whom
+     *  they went to (bounded). See {@link answersQuestion}. */
+    asked = new Map();
     /** Chat-stream frontier captured when this agent entered `focus` — recall surfaces ambient
      *  published after it ("since you entered focus"). Undefined unless in focus. */
     focusSince;
@@ -238,6 +284,22 @@ export class MeshAgent extends EventEmitter {
     recvKeySecret = randomUUID().replace(/-/g, "");
     recvKeySeq = 0;
     focusExcludedIds = new Map();
+    /** #662: id-less channel deliveries settled this focus episode, per content digest. Live ingest has
+     *  no stream sequence, so content is all an id-less delivery shares with its stream copy, and
+     *  identical copies may each have had a different disposition. So recall binds each settled copy
+     *  to a stream sequence and hands back only the copies no settled copy is bound to. Replaced, never
+     *  cleared, per episode, so a hold from an earlier episode cannot un-count a later one. */
+    focusIdless = new Map();
+    /** Unbound copies plus bound sequences in {@link focusIdless}, bounded like the exclusion list. */
+    focusIdlessEntries = 0;
+    /** Bumped as each channel's recall read starts: a copy settled before a read that the read could
+     *  not bind is behind the focus frontier or out of retention, and no later read will see it. */
+    idlessEpoch = 0;
+    /** Recall runs one at a time, so an older read can never settle over a newer one (#662). */
+    recallLock = Promise.resolve();
+    /** Bumped each time the transport goes down, so a settled copy's frontier read can tell whether
+     *  the connection stayed up from the copy's arrival to the answer (#662). */
+    transportDrops = 0;
     focusRecallUnsafeChannels = new Set();
     _stopping = false;
     /** Presence writes go out IN CALL ORDER (#636, #2055). setStatus is two awaited puts and every
@@ -307,6 +369,8 @@ export class MeshAgent extends EventEmitter {
             if (this._transportConnected === e.connected)
                 return;
             this._transportConnected = e.connected;
+            if (!e.connected)
+                this.transportDrops++;
             this.emit("transport", e);
         });
         // The endpoint's (re)binds are the single source of truth for connectedness: this fires on
@@ -484,6 +548,83 @@ export class MeshAgent extends EventEmitter {
         const clean = contextId?.trim();
         this._contextId = clean ? clean : undefined;
     }
+    /** Run `fn` with a per-call correlation for the sends it makes. A `replyTo` names the message a
+     *  DM answers unless the DM names one itself, and `contextId` is then that message's
+     *  conversation, copied from the message when the scope omits it. Without a `replyTo`,
+     *  `contextId` is the caller's own conversation: a send, a question DM or an anycast carries it
+     *  ahead of the agent-wide one from {@link setContextId}, and {@link answersQuestion} recognizes
+     *  a DM back that copies it. A connector that serves several host sessions from one seat uses it,
+     *  because one agent-wide context id cannot tell two concurrent sessions apart. */
+    withCorrelation(correlation, fn) {
+        const contextId = correlation.contextId?.trim() || undefined;
+        const replyTo = correlation.replyTo?.trim() || undefined;
+        const peerId = correlation.peerId?.trim() || undefined;
+        return this.correlation.run({ contextId, replyTo, peerId }, fn);
+    }
+    /** Whether `item` is a live DM answering a question this seat asked inside a
+     *  {@link withCorrelation} scope: it copies that question's `contextId`, and its authenticated
+     *  sender is the peer the question went to, or has the role an anycast question went to. A
+     *  `contextId` is a string any peer can set, so the copy alone proves nothing. */
+    answersQuestion(item) {
+        if (item.kind !== "dm" || item.historical || !item.contextId)
+            return false;
+        const q = this.asked.get(item.contextId);
+        return !!q && (q.peerId === item.fromId || (!!q.role && q.role === item.fromRole));
+    }
+    /** The correlation a send carries, and the question it asks (a `contextId` the caller's scope
+     *  owns, which {@link recordQuestion} remembers). `answered` is the message a DM answers: a reply
+     *  copies its `contextId`, which belongs to the asker, and names it in `replyTo` (SPEC §5). */
+    stamp(answered) {
+        const c = this.correlation.getStore();
+        // A DM's own `replyTo` naming another message wins over the scope's, as in answering().
+        if (c?.replyTo && (!answered || answered.id === c.replyTo))
+            return { stamp: { replyTo: c.replyTo, contextId: c.contextId ?? answered?.contextId ?? this._contextId } };
+        if (answered?.contextId)
+            return { stamp: { replyTo: answered.id, contextId: answered.contextId } };
+        // A scope's `contextId` is the caller's own only when the scope names no message it answers.
+        const own = c?.replyTo ? undefined : c?.contextId;
+        return { stamp: { replyTo: answered?.id, contextId: own ?? this._contextId }, own };
+    }
+    /** Remember a question this seat asked, so {@link answersQuestion} can recognize its answer. */
+    recordQuestion(contextId, to) {
+        if (!contextId)
+            return;
+        this.asked.delete(contextId);
+        this.asked.set(contextId, to);
+        if (this.asked.size > MAX_CORRELATIONS)
+            this.asked.delete(this.asked.keys().next().value);
+    }
+    /** The unanswered message a DM to `peerId` answers. `replyTo` names it, and must be a message
+     *  from that peer that is still waiting for an answer. Otherwise the scope's `replyTo` names it if
+     *  it is that peer's, else it is the oldest one from that peer no other DM in flight is answering.
+     *  The oldest is taken only while all of that peer's waiting messages, including those a DM in
+     *  flight is answering, share one conversation (`contextId`): across several, a guess could put
+     *  the answer in the wrong conversation, so the DM is refused with the list to choose from. A
+     *  caller with its own `contextId` answers only in the conversation its scope names. */
+    answering(peerId, replyTo) {
+        if (replyTo) {
+            const e = this.unanswered.get(replyTo);
+            if (!e || e.fromId !== peerId)
+                throw new Error(`replyTo "${attributionSafe(replyTo)}" is not a message from this peer that is waiting for an answer`);
+            return { id: replyTo, contextId: e.contextId };
+        }
+        const c = this.correlation.getStore();
+        if (c?.replyTo) {
+            const e = this.unanswered.get(c.replyTo);
+            return e && e.fromId === peerId ? { id: c.replyTo, contextId: e.contextId } : undefined;
+        }
+        if (c?.contextId && c.peerId !== peerId)
+            return undefined;
+        // One a DM in flight is answering still waits until that DM is published, so it still counts.
+        const waiting = [...this.unanswered].filter(([, e]) => e.fromId === peerId);
+        if (new Set(waiting.map(([, e]) => e.contextId)).size > 1) {
+            const list = waiting.map(([id, e]) => `  • replyTo: ${attributionSafe(id)} — "${attributionSafe(e.text ?? "")}"`);
+            throw new Error(`this peer has messages from more than one conversation waiting for an answer. Re-send with ` +
+                `"replyTo" set to the id of the one this answers:\n${list.join("\n")}`);
+        }
+        const first = waiting.find(([, e]) => !e.pending);
+        return first && { id: first[0], contextId: first[1].contextId };
+    }
     /** Begin connecting with background retry. Resolves after the first completed mesh join. */
     start(retryMs = 3000) {
         return this.connectLoop(retryMs);
@@ -637,6 +778,12 @@ export class MeshAgent extends EventEmitter {
         if (!meta)
             throw new Error(`message ${m.id} delivered without MessageMeta — its class is unauthenticated`);
         const item = this.toInboxItem(m, meta.kind, meta.historical);
+        if ((item.kind === "dm" || item.kind === "anycast") && !item.historical && item.id !== "" && !this.answersQuestion(item)) {
+            // A DM back to this peer answers it (see dm()). An answer to our own question needs none.
+            this.unanswered.set(item.id, { fromId: item.fromId, contextId: item.contextId, text: item.text.slice(0, 80) });
+            if (this.unanswered.size > MAX_CORRELATIONS)
+                this.unanswered.delete(this.unanswered.keys().next().value);
+        }
         // Per-channel override is the FINAL word for a channel message (DMs/anycast are never channel-
         // scoped, so they bypass this entirely and always buffer). Evaluated BEFORE the global mode:
         //  - `muted` → hard drop, incl. @mention (a mention rides the channel; you can't keep it if you
@@ -650,6 +797,14 @@ export class MeshAgent extends EventEmitter {
         // tag is payload-forgeable).
         if (item.kind === "channel") {
             const cm = this.channelModes.get(item.channel ?? "");
+            // #662: an id-less delivery is counted, not excluded, since recall can only match it by content.
+            // Content cannot tell a late copy of one recall handed back from a new identical message, so
+            // every copy takes its own disposition, and a late copy surfaces again rather than a new one
+            // losing its lane (#624: an empty id asserts no identity).
+            const digest = item.id === "" && (this.enteringFocus || this._attention === "focus") ? idlessDigest(m) : undefined;
+            const tally = digest === undefined ? undefined : this.reserveIdless(digest, item.channel ?? "");
+            const copy = tally ? this.settleIdless(tally) : undefined;
+            const idless = copy && { digest: digest, copy };
             // chatFrontier() is asynchronous. Channel traffic retained while entering focus must not also
             // appear in post-watermark recall if it lands after the server captured the frontier.
             if (this.enteringFocus)
@@ -677,6 +832,10 @@ export class MeshAgent extends EventEmitter {
             if (cm !== "quiet" && !snapshottedPullOnly && this._attention === "focus") {
                 this.protectDisposition(item.id, "drop");
                 delivery.ack();
+                // #662: recall cannot pick this copy out from an identical one with another disposition, so
+                // its body is held here, pull-only, and recall hands back only copies nothing is bound to.
+                if (item.id === "")
+                    this.buffer(item, () => { }, true, idless);
                 if (item.mentionsMe)
                     this.emit("mention-wake", item);
                 return;
@@ -686,16 +845,24 @@ export class MeshAgent extends EventEmitter {
             // on a real mesh as 119 injected digests / 0 assistant turns and an emergency compaction before
             // the seat's first real order could run. It stays recallable (cotal_inbox, recall), and a
             // historical @mention stays automatic: directed catch-up is the reader's call, not noise.
-            const pullOnly = snapshottedPullOnly || (!item.mentionsMe && (item.historical || this.classificationUnsafe));
+            // A reply on a channel is pull-only too when the host answers every turn on the channel
+            // (config.channelRepliesPullOnly): that answer replies to the message that started the turn,
+            // so a turn on a peer's reply is a turn on its automatic output, and two such seats on one
+            // channel would answer each other without end (#2395).
+            const automaticReply = this.config.channelRepliesPullOnly === true && !!item.replyTo;
+            const pullOnly = snapshottedPullOnly || (!item.mentionsMe && (item.historical || automaticReply || this.classificationUnsafe));
             if (pullOnly)
                 this.excludeFromFocus(item);
-            this.buffer(item, delivery.ack, pullOnly);
+            this.buffer(item, delivery.ack, pullOnly, idless);
             return;
         }
         this.buffer(item, delivery.ack, false);
     }
-    buffer(item, ack, pullOnly) {
-        this.inbox.push({ item, ack, pullOnly, receivedAt: Date.now() });
+    buffer(item, ack, pullOnly, idless) {
+        const pending = { item, ack, pullOnly, receivedAt: Date.now() };
+        if (idless)
+            pending.idless = { tally: this.focusIdless, ...idless };
+        this.inbox.push(pending);
         if (this.inbox.length > MAX_INBOX) {
             // Prefer sacrificing pull-only backlog so it cannot crowd out DMs/mentions. Overflow remains
             // bounded local loss: evicted items are acked without being marked handled.
@@ -722,6 +889,9 @@ export class MeshAgent extends EventEmitter {
                 const [evicted] = this.inbox.splice(index, 1);
                 const sacrificingDirected = evicted.item.kind !== "channel";
                 this.rememberEvicted(evicted);
+                // #662: a held id-less message is no longer settled here, so recall may hand it back.
+                if (evicted.idless?.tally === this.focusIdless)
+                    this.unsettleIdless(evicted.idless.digest, evicted.idless.copy);
                 // ...but NOT an id that is mid-delivery. Overflow prefers the oldest, which is exactly what a
                 // surfaced batch is made of, so without this an arrival can ack a message a host is still
                 // trying to hand to its runtime. Evicting bounds memory; acking is what makes it
@@ -791,6 +961,8 @@ export class MeshAgent extends EventEmitter {
     excludeFromFocus(item) {
         if ((!this.enteringFocus && this._attention !== "focus") || item.kind !== "channel" || !item.channel)
             return;
+        if (item.id === "")
+            return; // #662: an id-less delivery is counted in focusIdless instead
         if (!this.focusExcludedIds.has(item.id) && this.focusExcludedIds.size >= FOCUS_EXCLUSION_CAP) {
             const oldest = this.focusExcludedIds.entries().next().value;
             if (oldest) {
@@ -800,6 +972,125 @@ export class MeshAgent extends EventEmitter {
         }
         this.focusExcludedIds.set(item.id, item.channel);
     }
+    /** #662: the tally for one more settled or handed-back copy of an id-less message; the caller adds
+     *  the copy. At the bound, the channel's recall is reported incomplete rather than risk handing
+     *  back a copy it no longer counts. */
+    reserveIdless(digest, channel) {
+        if (this.focusIdlessEntries >= FOCUS_EXCLUSION_CAP) {
+            this.focusRecallUnsafeChannels.add(channel);
+            return undefined;
+        }
+        let tally = this.focusIdless.get(digest);
+        if (!tally)
+            this.focusIdless.set(digest, (tally = { channel, unbound: [], bound: new Set() }));
+        this.focusIdlessEntries++;
+        return tally;
+    }
+    /** #662: add one settled copy, bounded by the chat frontier read after it arrived. If that read
+     *  fails, or answers only after the transport dropped, nothing bounds the copy, so the channel's
+     *  recall is reported incomplete instead. */
+    settleIdless(tally) {
+        const episode = this.focusIdless;
+        const drops = this.transportDrops;
+        const unbounded = () => {
+            if (episode === this.focusIdless)
+                this.focusRecallUnsafeChannels.add(tally.channel);
+        };
+        const copy = { epoch: this.idlessEpoch, ready: Promise.resolve() };
+        copy.ready = this.ep.chatFrontier().then((frontier) => {
+            if (drops === this.transportDrops)
+                copy.frontier = frontier;
+            else
+                unbounded();
+        }, unbounded);
+        tally.unbound.push(copy);
+        return copy;
+    }
+    /** #662: forget a tally with nothing left in it, so the map is bounded by the entries it counts. */
+    dropEmptyIdless(digest, tally) {
+        if (!tally.unbound.length && !tally.bound.size)
+            this.focusIdless.delete(digest);
+    }
+    /** #662: one buffered copy of an id-less message left the inbox unhandled. Only that copy is
+     *  un-counted, or the sequence it was bound to freed: an identical copy may have been muted. A copy
+     *  no read has bound yet stays in arrival order, marked, so the read binds it to its own stream
+     *  copy rather than letting an earlier identical copy take that one. */
+    unsettleIdless(digest, copy) {
+        const tally = this.focusIdless.get(digest);
+        if (!tally)
+            return;
+        if (tally.unbound.includes(copy)) {
+            copy.evicted = true;
+            return;
+        }
+        if (copy.seq === undefined || !tally.bound.delete(copy.seq))
+            return;
+        this.focusIdlessEntries--;
+        this.dropEmptyIdless(digest, tally);
+    }
+    /** #662: after a complete read of `channel` that started at `epoch`, a copy settled before it that
+     *  it could not bind will not be in a later read either, so it is dropped. The read is the
+     *  channel's whole retained window, so a bound sequence it lacks aged out. */
+    settleIdlessRead(channel, epoch, retained) {
+        for (const [digest, tally] of this.focusIdless) {
+            if (tally.channel !== channel)
+                continue;
+            const before = tally.unbound.length + tally.bound.size;
+            tally.unbound = tally.unbound.filter((c) => c.epoch >= epoch);
+            for (const seq of tally.bound)
+                if (!retained.has(seq))
+                    tally.bound.delete(seq);
+            this.focusIdlessEntries -= before - tally.unbound.length - tally.bound.size;
+            this.dropEmptyIdless(digest, tally);
+        }
+    }
+    /** #662: the frontier reads of every copy of `channel` settled so far have answered. */
+    async idlessReady(tallies, channel) {
+        const reads = [];
+        for (const tally of tallies.values())
+            if (tally.channel === channel)
+                for (const c of tally.unbound)
+                    reads.push(c.ready);
+        await Promise.all(reads);
+    }
+    /** #662: bind the copies settled before the read that started at `epoch` to its unbound stream
+     *  copies `free` (ascending). Identical copies share a sender subject, so they arrive in stream
+     *  order, and a frontier, read after its copy arrived, bounds that copy and every copy before it.
+     *  Frontier reads can answer out of order, so their sizes say nothing about arrival order. So the
+     *  copies bind in arrival order, latest first, each to the latest free stream copy at or below the
+     *  lowest frontier from it on, and a stream copy none of them takes (a reconnect gap) stays free.
+     *  An evicted copy takes its own stream copy and leaves it free, so recall hands that one back. */
+    bindIdless(tally, epoch, free) {
+        let bound = Infinity;
+        for (let i = tally.unbound.length - 1; i >= 0; i--) {
+            const copy = tally.unbound[i];
+            if (copy.frontier === undefined)
+                continue;
+            bound = Math.min(bound, copy.frontier);
+            if (copy.epoch >= epoch)
+                continue;
+            let at = free.length - 1;
+            while (at >= 0 && free[at] > bound)
+                at--;
+            if (at < 0)
+                continue;
+            const [seq] = free.splice(at, 1);
+            tally.unbound.splice(i, 1);
+            if (copy.evicted) {
+                this.focusIdlessEntries--;
+                continue;
+            }
+            copy.seq = seq;
+            tally.bound.add(seq);
+        }
+    }
+    /** #662: a copy settled after the read that started at `epoch` began may or may not be in it, so it
+     *  binds nothing there, and an unbound stream copy at `seq` it could be is neither free nor bound. */
+    idlessUnsure(tally, epoch, seq) {
+        if (!tally || tally.bound.has(seq))
+            return false;
+        return tally.unbound.some((c) => c.epoch >= epoch && c.frontier !== undefined && c.frontier >= seq);
+    }
     protectDisposition(id, disposition) {
         if (id === "")
             return; // #624: an empty id is never a dedup key, so it is never recorded as one
@@ -1187,6 +1478,8 @@ export class MeshAgent extends EventEmitter {
             if (mode === "focus") {
                 await this.requireConnected();
                 this.focusExcludedIds.clear();
+                this.focusIdless = new Map();
+                this.focusIdlessEntries = 0;
                 this.focusRecallUnsafeChannels.clear();
                 this.enteringFocus = this._attention !== "focus";
                 try {
@@ -1195,6 +1488,8 @@ export class MeshAgent extends EventEmitter {
                 catch (error) {
                     this.enteringFocus = false;
                     this.focusExcludedIds.clear();
+                    this.focusIdless = new Map();
+                    this.focusIdlessEntries = 0;
                     this.focusRecallUnsafeChannels.clear();
                     throw error;
                 }
@@ -1205,6 +1500,8 @@ export class MeshAgent extends EventEmitter {
                 this.enteringFocus = false;
                 this.focusSince = undefined;
                 this.focusExcludedIds.clear();
+                this.focusIdless = new Map();
+                this.focusIdlessEntries = 0;
                 this.focusRecallUnsafeChannels.clear();
                 this.resetRecallWalk();
             }
@@ -1223,8 +1520,15 @@ export class MeshAgent extends EventEmitter {
      *  the per-channel window — and wildcard subscriptions (`team.>`), which recall cannot read back
      *  per concrete sub-channel (#977: a wildcard join is not itself a channel ingest can consult a
      *  replay policy for) and so cannot vouch for either (never-silent throughout). Empty unless in
-     *  focus. */
-    async recallAmbient() {
+     *  focus. Calls run one at a time (#662). `underway` names recalled items that already went out in
+     *  part: an exclusion that lands after that does not hide one, since recall would then move past
+     *  the rest of it (#613). */
+    async recallAmbient(underway = new Set()) {
+        const run = this.recallLock.then(() => this.recallAmbientOnce(underway));
+        this.recallLock = run.catch(() => { });
+        return run;
+    }
+    async recallAmbientOnce(underway) {
         if (this._attention !== "focus" || this.focusSince === undefined)
             return { items: [], droppedChannels: [] };
         const items = [];
@@ -1238,12 +1542,91 @@ export class MeshAgent extends EventEmitter {
                 droppedChannels.push(channel);
                 continue;
             }
-            const { messages, dropped } = await this.ep.recallChannel(channel, this.focusSince);
-            for (const m of messages) {
-                if (!this.focusExcludedIds.has(m.id))
-                    items.push(this.toInboxItem(m, "channel", true));
+            const tallies = this.focusIdless;
+            let epoch = 0;
+            let read;
+            // #662: a copy settled while a read runs may or may not be in it, so the read is retried with
+            // that copy settled first, a bounded number of times.
+            for (let attempt = 1; attempt <= IDLESS_READS; attempt++) {
+                epoch = ++this.idlessEpoch;
+                // The read starts after every copy settled before it knows its frontier, so a copy it
+                // cannot bind is behind the focus start or out of retention.
+                await this.idlessReady(tallies, channel);
+                read = await this.ep.recallChannel(channel, this.focusSince);
+                if (read.unanswered)
+                    break;
+                await this.idlessReady(tallies, channel); // copies settled during the read
+                const unsure = read.messages.some((m, i) => m.id === "" && this.idlessUnsure(tallies.get(idlessDigest(m)), epoch, read.seqs[i]));
+                if (!unsure)
+                    break;
+            }
+            const { messages, seqs, dropped, unanswered } = read;
+            // A read that did not answer says nothing about what the channel retains, so nothing settles.
+            if (unanswered) {
+                droppedChannels.push(channel);
+                continue;
             }
-            if (dropped)
+            if (this.focusRecallUnsafeChannels.has(channel)) {
+                droppedChannels.push(channel);
+                continue;
+            }
+            // #662: each copy settled before the read is bound to one retained stream copy at or below its
+            // frontier. A copy no settled copy is bound to was never received (a reconnect gap) or was
+            // evicted; it is handed back into the inbox, which acks each by receive key, since the recall
+            // mark cannot order identical copies.
+            const retained = new Set();
+            const digests = [];
+            const free = new Map();
+            for (const [i, m] of messages.entries()) {
+                if (m.id !== "" || tallies !== this.focusIdless)
+                    continue;
+                retained.add(seqs[i]);
+                const digest = (digests[i] = idlessDigest(m));
+                if (tallies.get(digest)?.bound.has(seqs[i]))
+                    continue;
+                const list = free.get(digest);
+                if (list)
+                    list.push(seqs[i]);
+                else
+                    free.set(digest, [seqs[i]]);
+            }
+            for (const [digest, list] of free) {
+                const tally = tallies.get(digest);
+                if (tally)
+                    this.bindIdless(tally, epoch, list);
+            }
+            let incomplete = dropped;
+            for (const [i, m] of messages.entries()) {
+                if (m.id !== "") {
+                    if (underway.has(m.id) || !this.focusExcludedIds.has(m.id))
+                        items.push(this.toInboxItem(m, "channel", true));
+                    continue;
+                }
+                if (tallies !== this.focusIdless)
+                    continue; // focus was left or re-entered during the read
+                const seq = seqs[i];
+                const digest = digests[i];
+                const tally = tallies.get(digest);
+                if (tally?.bound.has(seq))
+                    continue;
+                // Still unsure after the last read: neither claimed nor handed back, and reported.
+                if (this.idlessUnsure(tally, epoch, seq)) {
+                    incomplete = true;
+                    continue;
+                }
+                // A full inbox leaves it in the stream for a later call, rather than evict something else.
+                const fresh = this.inbox.length < MAX_INBOX ? this.reserveIdless(digest, channel) : undefined;
+                if (!fresh) {
+                    incomplete = true;
+                    continue;
+                }
+                const copy = { epoch, frontier: seq, ready: Promise.resolve(), seq };
+                fresh.bound.add(seq);
+                this.buffer(this.toInboxItem(m, "channel", true), () => { }, true, { digest, copy });
+            }
+            if (tallies === this.focusIdless)
+                this.settleIdlessRead(channel, epoch, retained);
+            if (incomplete)
                 droppedChannels.push(channel);
         }
         items.sort((a, b) => a.ts - b.ts);
@@ -1255,7 +1638,7 @@ export class MeshAgent extends EventEmitter {
         const clean = normalizeMentions(mentions);
         if (clean)
             await this.assertKnownMentions(clean);
-        return this.ep.multicast(text, { channel, mentions: clean, contextId: this._contextId });
+        return this.ep.multicast(text, { channel, mentions: clean, ...this.stamp().stamp });
     }
     /**
      * What a caller can TELL about a send target BEFORE the publish: whether the name
@@ -1315,7 +1698,9 @@ export class MeshAgent extends EventEmitter {
     }
     async anycast(role, text) {
         await this.requireConnected();
-        return this.ep.anycast(role, text, { contextId: this._contextId });
+        const { stamp, own } = this.stamp();
+        this.recordQuestion(own, { role });
+        return this.ep.anycast(role, text, stamp);
     }
     /** Resolve a peer by instance id (exact) or display name. Deterministic and fail-loud: returns
      *  one peer, `undefined` if none match, or throws `AmbiguousPeerError` on a same-name collision —
@@ -1323,7 +1708,7 @@ export class MeshAgent extends EventEmitter {
     resolvePeer(target) {
         return resolvePeerInRoster(this.ep.getRoster(), target, { selfId: this.id });
     }
-    async dm(target, text) {
+    async dm(target, text, opts = {}) {
         await this.requireConnected();
         // #1229: a miss is only a real "no peer" while the view is current. Under `unpopulated`
         // the roster may be a reconnect refill in progress, so wait once for the snapshot and
@@ -1347,10 +1732,25 @@ export class MeshAgent extends EventEmitter {
         // The only status we can truthfully attribute is the roster snapshot taken right before the
         // publish: recipient state can change the instant after, and the ack never tells us either way.
         const recipientStatusAtSend = peer.status;
-        const { msg, ack } = await this.ep.unicastAttributed(peer.card.id, text, {
-            contextId: this._contextId,
-        });
-        return { msg, peer, ack, recipientStatusAtSend };
+        // A DM back to a peer answers the message `replyTo` names, or the oldest one it sent us that no
+        // DM has answered yet (see answering()). It counts as answered only once the DM is published,
+        // so a failed send leaves it to the retry.
+        const answered = this.answering(peer.card.id, opts.replyTo?.trim() || undefined);
+        const entry = answered && this.unanswered.get(answered.id);
+        const { stamp, own } = this.stamp(answered);
+        this.recordQuestion(own, { peerId: peer.card.id });
+        if (entry)
+            entry.pending = true;
+        try {
+            const { msg, ack } = await this.ep.unicastAttributed(peer.card.id, text, stamp);
+            if (answered)
+                this.unanswered.delete(answered.id);
+            return { msg, peer, ack, recipientStatusAtSend };
+        }
+        finally {
+            if (entry)
+                entry.pending = false;
+        }
     }
     // ---- supervision ---------------------------------------------------------
     /** Ask the manager to spawn a new teammate into this space (its `spawn` action).
@@ -1590,8 +1990,20 @@ export class MeshAgent extends EventEmitter {
                 this.notePullTrouble(r.error ?? "refused with no message");
                 return;
             }
-            this.pullTrouble = undefined;
-            const turns = r.data?.turns ?? [];
+            const rows = r.data?.turns;
+            // A reply with no turns array is no snapshot: reconciling on it would drop every accepted
+            // turn, including one already shown. Keep what the seat holds until a well-formed pull.
+            if (!Array.isArray(rows)) {
+                this.notePullTrouble("turn-pending returned no turns array");
+                return;
+            }
+            // A responder off the contract must not reach the formatter: one row with no numeric
+            // deadline made peekPendingTurns throw on every frame.
+            const turns = rows.filter(isPendingTurn);
+            if (turns.length < rows.length)
+                this.notePullTrouble(`turn-pending returned ${rows.length - turns.length} malformed turn(s), dropped`);
+            else
+                this.pullTrouble = undefined;
             const live = new Set(turns.map((t) => t.goalId));
             for (const id of [...this.activeTurns.keys()])
                 if (!live.has(id))
@@ -1903,6 +2315,11 @@ export class MeshAgent extends EventEmitter {
     async setCondition(condition) {
         await this.inOrder(() => this.ep.setCondition(condition));
     }
+    /** Relay harness-reported work progress (a turn event) as presence `activeAt`. The next heartbeat
+     *  carries it, so an observer can tell a turn that stopped advancing from one that is progressing. */
+    noteActivity(at) {
+        this.ep.noteActivity(at);
+    }
     /** The working→idle boundary: yield `done` for every SURFACED turn (its payload was in the
      *  context of the turn that just ended; ending without an explicit yield IS the done signal),
      *  then re-poll immediately so a queued turn wakes the seat without waiting out the cadence.