fix: exempt chat:edited/deleted/reaction-remove markers from conversational treatment

changelog.d/nonconversational-markers.fixed.md

@@ -0,0 +1 @@
+- **Edit/delete/reaction-remove markers now preserve explicit-send suppression, like reaction markers** (#157). `isConversationalInjection` exempted only `chat:reaction`, so the RFC-001 marker tags `chat:edited`, `chat:deleted` and `chat:reaction-remove` (now delivered as synthetic incoming messages by e.g. zulip_mcp) cleared explicit-send suppression — an edit notice arriving right after a `send_message` re-opened auto-routing for the same round's prose. The four tags live in a shared `NON_CONVERSATIONAL_TAGS` set (`src/mcpl/tags.ts`). All four marker tags also leave ChannelRegistry's default publish channel and `context.incoming`'s message/thread anchor unchanged. An edit the agent sees first still counts as the message it replaced: it clears explicit-send suppression, can move the turn's speech channel at a tool boundary, and, for a channel message the coalescer delivers when it accepts it, moves the default publish channel and `context.incoming` as that message would. The host knows that case when RFC-006 coalescing delivers a version of a subject whose producer marked its first occurrence `initial` and of which no version may have been shown to the agent yet, whether the version is a plain occurrence that replaced an unread one, a deferred notice's render, or a plain occurrence that replaced a pending notice; an edit of such an edit is the agent's first view too. A doubt counts as shown, so the host errs toward a marker: a message counts as shown once a compile of any agent that can read it has begun to assemble it (a compile that throws gives that back, unless a tool boundary or another compile has moved the agent's position since) or a tool boundary of one may have injected it (residents sharing a message slot can all read it), and so does any message stored before one that was, since the host keeps one position per agent. `channel_publish`'s description now says that an omitted `channelId` goes to a conversation agent's own channel when it is bound to one, and otherwise to the channel of the most recent incoming message the host received on any channel, whether or not the agent has been shown it, apart from markers, and that a message pushed to the agent never sets it.

src/agent.ts

@@ -932,11 +932,27 @@ export class Agent {
   /** Counts marks: a compile writes its watermark back only if no mark was
    *  made while it ran (a tool boundary's, or another compile's). */
   private watermarkMarks = 0;
+  /**
+   * The newest stored message a compile or a tool boundary may have put in
+   * front of the agent, per branch. It moves where the consumed watermark
+   * does, and sooner: when a committing compile takes its value, before it
+   * awaits, and at every tool boundary that injects, whether or not the
+   * stream says it carries injected messages. So nothing above it can have
+   * been shown. A compile that throws assembled nothing, and gives its move
+   * back where it can (unshowFailedCompile). A scalar counts a prefix, so a
+   * message stored below it without having been shown counts as shown, which
+   * errs toward a marker.
+   */
+  private shownWatermark: { branch: string; sequence: number } | null = null;
 
   getConsumedWatermark(): { branch: string; sequence: number } | null {
     return this.consumedWatermark;
   }
 
+  getShownWatermark(): { branch: string; sequence: number } | null {
+    return this.shownWatermark;
+  }
+
   /** Mark everything currently stored as consumed (the agent's creation, at
    *  boot or later, and a tool boundary that injected messages into the live
    *  stream). */
@@ -945,6 +961,32 @@ export class Agent {
     // stubs): without a watermark nothing is ever treated as unread.
     this.consumedWatermark = this.pendingWatermark();
     this.watermarkMarks++;
+    this.shownWatermark = this.consumedWatermark;
+  }
+
+  /** Mark everything currently stored as possibly shown (a tool boundary
+   *  that injected messages, whatever its stream says it carries). Without
+   *  a watermark everything counts as shown, as markContextConsumed counts
+   *  it read. */
+  markContextShown(): void {
+    this.shownWatermark = this.pendingWatermark();
+  }
+
+  /** A committing compile that threw assembled nothing, so its own move of
+   *  the shown watermark goes back, unless a boundary or another compile has
+   *  moved the watermark since. It goes back to the watermark as the compile
+   *  found it, which can be another compile's claim that has failed as well.
+   *  Of two overlapping committing compiles, if the first to start throws
+   *  first, it gives nothing back (the second's claim is current), and if
+   *  the second then throws, it restores the first's failed claim. Messages
+   *  up to that claim then count as shown, although no request held those
+   *  above the watermark the first compile found, which errs toward a marker
+   *  until the next compile or boundary moves the watermark. */
+  private unshowFailedCompile(
+    watermark: { branch: string; sequence: number } | null,
+    before: { branch: string; sequence: number } | null,
+  ): void {
+    if (watermark && this.shownWatermark === watermark) this.shownWatermark = before;
   }
 
   /**
@@ -992,8 +1034,16 @@ export class Agent {
     // fails assembled nothing, so the watermark moves only on success.
     const watermark = this.pendingWatermark();
     const marksBefore = this.watermarkMarks;
+    const shownBefore = this.shownWatermark;
+    if (watermark) this.shownWatermark = watermark;
     const compile = () => this.contextManager.compile(this.compileBudget(budget));
-    const result = budget ? await compile() : await this.compileAtLiveBudget(compile);
+    let result: CompileResult;
+    try {
+      result = budget ? await compile() : await this.compileAtLiveBudget(compile);
+    } catch (error) {
+      this.unshowFailedCompile(watermark, shownBefore);
+      throw error;
+    }
     if (watermark) this.applyCompileWatermark(watermark, marksBefore);
     return result;
   }
@@ -1034,8 +1084,18 @@ export class Agent {
     // any compile before it selects.
     const watermark = opts?.dryRun ? null : this.pendingWatermark();
     const marksBefore = this.watermarkMarks;
+    // Shown from the compile's start: what it assembles is in front of the
+    // agent before the consumed watermark moves, once it returns.
+    const shownBefore = this.shownWatermark;
+    if (watermark) this.shownWatermark = watermark;
     const compile = () => this.contextManager.compile(this.compileBudget(budget), injections, opts as never);
-    const result = budget || opts?.dryRun ? await compile() : await this.compileAtLiveBudget(compile);
+    let result: CompileResult;
+    try {
+      result = budget || opts?.dryRun ? await compile() : await this.compileAtLiveBudget(compile);
+    } catch (error) {
+      this.unshowFailedCompile(watermark, shownBefore);
+      throw error;
+    }
     if (watermark) this.applyCompileWatermark(watermark, marksBefore);
     return result;
   }