@desplega.ai/agent-swarm 2.5.2 → 2.5.4

package/src/providers/claude-adapter.ts

@@ -17,6 +17,11 @@ import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { deriveDefaultRoute, routeCredentialStatus, routeUnsetEnv } from "@desplega/model-routing";
 import { type Span, trace } from "@opentelemetry/api";
+import {
+  contextBoundNoteMarkerPath,
+  contextStatePath,
+  recordContextState,
+} from "../hooks/context-bound-note";
 import {
   type RunStopHookSessionSummaryOpts,
   runStopHookSessionSummarySubprocess,
@@ -130,10 +135,17 @@ async function writeTaskFile(key: string | number, data: TaskFileData): Promise<
 }
 
 export async function cleanupTaskFile(key: string | number): Promise<void> {
-  try {
-    await unlink(getTaskFilePath(key));
-  } catch {
-    // File might already be deleted or never created
+  const taskFilePath = getTaskFilePath(key);
+  for (const path of [
+    taskFilePath,
+    contextStatePath(taskFilePath),
+    contextBoundNoteMarkerPath(taskFilePath),
+  ]) {
+    try {
+      await unlink(path);
+    } catch {
+      // File might already be deleted or never created
+    }
   }
 }
 
@@ -909,6 +921,8 @@ class ClaudeSession implements ProviderSession {
   private appliedReasoningEffort: ReasoningEffort | null;
   /** Last non-empty assistant text seen; surfaced as ProviderResult.output — same pattern as pi-mono/claude-managed. */
   private lastAssistantText = "";
+  /** Last value written to the context state file read by the context-bound note hook. */
+  private lastContextTokens: number | undefined;
   /** Per-session stream-json transcript used by the parent-owned session summarizer. */
   private transcript: string[];
   /** Keeps the session heartbeat fresh while Claude idles on background tasks. */
@@ -1263,6 +1277,17 @@ class ClaudeSession implements ProviderSession {
       if (normalized.contextWindowSize) this.contextWindowSize = normalized.contextWindowSize;
       if (normalized.cost) setCost(normalized.cost);
       if (normalized.assistantText) this.lastAssistantText = normalized.assistantText;
+      if (
+        normalized.requestContextTokens !== undefined &&
+        normalized.requestContextTokens !== this.lastContextTokens
+      ) {
+        this.lastContextTokens = normalized.requestContextTokens;
+        recordContextState(
+          getTaskFilePath(this.taskFileKey),
+          normalized.requestContextTokens,
+          this.model,
+        );
+      }
       this.transcript.push(...normalized.transcriptEntries);
       for (const event of normalized.events) this.emit(event);
 

package/src/providers/claude-managed-adapter.ts

@@ -56,6 +56,7 @@ import type {
   BetaManagedAgentsSessionEvent as SessionEvent,
 } from "@anthropic-ai/sdk/resources/beta/sessions";
 
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { checkToolLoop } from "../hooks/tool-loop-detection";
 import {
   CONTEXT_FORMULA,
@@ -268,6 +269,12 @@ class ClaudeManagedSession implements ProviderSession {
   private readonly taskId: string | null;
   private aborted = false;
   private settled = false;
+  /** Prompt size of the latest model request: input + cache read + cache write. */
+  private lastRequestContextTokens: number | undefined;
+  /** Fed the latest request's prompt size on each tool call; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
+  /** Tool calls the stream started and has not returned a result for. */
+  private readonly openToolCalls = new Set<string>();
 
   constructor(
     client: ManagedAgentsClient,
@@ -286,6 +293,14 @@ class ClaudeManagedSession implements ProviderSession {
     this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.resolveCompletion = resolve;
     });
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.cost.model,
+      // A message with no tool call left to return, or after idle or abort,
+      // would start another turn.
+      canDeliver: () => !this.settled && !this.aborted && this.openToolCalls.size > 0,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
 
     // Phase 5: adapter-side swarm hooks. Lower-latency cancellation poll,
     // tool-loop detection (the handler also calls `checkToolLoop` on
@@ -497,6 +512,11 @@ class ClaudeManagedSession implements ProviderSession {
       case "agent.tool_use": {
         const tu = event as BetaManagedAgentsAgentToolUseEvent;
         this.runToolLoopCheck(tu.name, tu.input);
+        // Only on tool calls: a message after the final reply would start another
+        // turn. The stream can send the call before its request ends, so this may
+        // read the previous request: at most one request late.
+        this.openToolCalls.add(tu.id);
+        void this.observeContextBound(this.lastRequestContextTokens);
         this.emit({
           type: "tool_start",
           toolCallId: tu.id,
@@ -509,6 +529,8 @@ class ClaudeManagedSession implements ProviderSession {
         const tu = event as BetaManagedAgentsAgentMCPToolUseEvent;
         const fqToolName = `${tu.mcp_server_name}:${tu.name}`;
         this.runToolLoopCheck(fqToolName, tu.input);
+        this.openToolCalls.add(tu.id);
+        void this.observeContextBound(this.lastRequestContextTokens);
         this.emit({
           type: "tool_start",
           toolCallId: tu.id,
@@ -519,6 +541,7 @@ class ClaudeManagedSession implements ProviderSession {
       }
       case "agent.tool_result": {
         const tr = event as BetaManagedAgentsAgentToolResultEvent;
+        this.openToolCalls.delete(tr.tool_use_id);
         this.emit({
           type: "tool_end",
           toolCallId: tr.tool_use_id,
@@ -533,6 +556,7 @@ class ClaudeManagedSession implements ProviderSession {
       }
       case "agent.mcp_tool_result": {
         const tr = event as BetaManagedAgentsAgentMCPToolResultEvent;
+        this.openToolCalls.delete(tr.mcp_tool_use_id);
         this.emit({
           type: "tool_end",
           toolCallId: tr.mcp_tool_use_id,
@@ -571,6 +595,8 @@ class ClaudeManagedSession implements ProviderSession {
       case "span.model_request_end": {
         const sp = event as BetaManagedAgentsSpanModelRequestEndEvent;
         const usage = sp.model_usage;
+        this.lastRequestContextTokens =
+          usage.input_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens;
         this.cost.inputTokens = (this.cost.inputTokens ?? 0) + usage.input_tokens;
         this.cost.outputTokens = (this.cost.outputTokens ?? 0) + usage.output_tokens;
         this.cost.cacheReadTokens =

package/src/providers/claude-sdk-session.ts

@@ -9,6 +9,7 @@ import {
   type SpawnedProcess,
   type SpawnOptions,
 } from "@anthropic-ai/claude-agent-sdk";
+import { recordContextState } from "../hooks/context-bound-note";
 import type { RunStopHookSessionSummaryOpts } from "../hooks/hook";
 import { getContextWindowSize } from "../utils/context-window";
 import {
@@ -316,6 +317,8 @@ class ClaudeSdkSession implements ProviderSession {
   private contextWindowSize: number;
   private transcript: string[];
   private lastAssistantText = "";
+  /** Last value written to the context state file read by the context-bound note hook. */
+  private lastContextTokens: number | undefined;
   private lastCost: CostData | undefined;
   private aborted = false;
   private abortReason = "cancelled";
@@ -434,6 +437,13 @@ class ClaudeSdkSession implements ProviderSession {
     if (normalized.contextWindowSize) this.contextWindowSize = normalized.contextWindowSize;
     if (normalized.cost) this.lastCost = normalized.cost;
     if (normalized.assistantText) this.lastAssistantText = normalized.assistantText;
+    if (
+      normalized.requestContextTokens !== undefined &&
+      normalized.requestContextTokens !== this.lastContextTokens
+    ) {
+      this.lastContextTokens = normalized.requestContextTokens;
+      recordContextState(this.options.taskFilePath, normalized.requestContextTokens, this.model);
+    }
     this.transcript.push(...normalized.transcriptEntries);
     for (const event of normalized.events) this.emit(event);
     trackErrorFromJson(json, this.errorTracker);

package/src/providers/claude-session-events.ts

@@ -60,6 +60,11 @@ export type NormalizedClaudeMessage = {
   contextWindowSize?: number;
   cost?: CostData;
   assistantText?: string;
+  /**
+   * Prompt size of the latest main-thread request: input + cache read + cache
+   * write tokens. Unset for subagent messages and messages without usage.
+   */
+  requestContextTokens?: number;
   isResult: boolean;
 };
 
@@ -150,6 +155,7 @@ export function normalizeClaudeMessage(
   let model: string | undefined;
   let contextWindowSize: number | undefined;
   let assistantText: string | undefined;
+  let requestContextTokens: number | undefined;
 
   if (json.type === "system" && json.subtype === "init" && json.session_id) {
     sessionId = json.session_id;
@@ -227,6 +233,12 @@ export function normalizeClaudeMessage(
         outputTokens: usage.output_tokens ?? 0,
         contextFormula: CONTEXT_FORMULA,
       });
+      if (!json.parent_tool_use_id) {
+        requestContextTokens =
+          (usage.input_tokens ?? 0) +
+          (usage.cache_read_input_tokens ?? 0) +
+          (usage.cache_creation_input_tokens ?? 0);
+      }
     }
   }
 
@@ -247,6 +259,7 @@ export function normalizeClaudeMessage(
     contextWindowSize,
     cost,
     assistantText,
+    requestContextTokens,
     isResult: json.type === "result",
   };
 }

package/src/providers/codex-adapter.ts

@@ -31,6 +31,7 @@
 import { existsSync as nodeExistsSync } from "node:fs";
 import { join } from "node:path";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { getApiKey } from "../utils/api-key";
 import {
   CONTEXT_FORMULA,
@@ -995,6 +996,8 @@ export class CodexSession implements ProviderSession {
    * summary path which materially relies on this ordering for testability.
    */
   private pendingResult: ProviderResult | null = null;
+  /** Fed each main-thread request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     thread: CodexThread,
@@ -1015,6 +1018,13 @@ export class CodexSession implements ProviderSession {
       skillsDir ?? process.env.CODEX_SKILLS_DIR ?? join(codexUserHome(), ".codex", "skills");
     this.summarizeDeps = summarizeDeps;
     this.logFileHandle = Bun.file(config.logFile).writer();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.resolvedModel,
+      // `turn/steer` only joins the active turn, so a late note never starts one.
+      canDeliver: () => this.acceptsSteering && !this.settled && !this.aborted,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
     // Mirrors the resolution `buildCodexConfig` already applied when
     // constructing `mergedConfig` — cheap, pure, and keeps the applied-level
     // feedback co-located with `settle()` rather than threading an extra
@@ -1425,6 +1435,8 @@ export class CodexSession implements ProviderSession {
         break;
       case "context.updated":
         this.emitContextUsage(event.usage, event.contextWindow ?? this.contextWindow);
+        // Codex input tokens already include the cached read and write subsets.
+        void this.observeContextBound(event.usage.input_tokens);
         break;
       case "error": {
         const { message } = this.formatTerminalError(event.message, event.codexErrorInfo);

package/src/providers/dsh-adapter.ts

@@ -37,7 +37,7 @@ import type {
 } from "./types";
 
 // npm's `latest` is older and lacks the JSON/stdin contract used here.
-export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-rc.2";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-rc.3";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()

package/src/providers/opencode-adapter.ts

@@ -21,6 +21,7 @@ import {
   providerKeyVars,
 } from "@desplega/model-catalog";
 import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
@@ -534,6 +535,8 @@ export class OpencodeSession implements ProviderSession {
   // Assistant text by message, in part order; the runner keeps the last emit.
   private textByMessage = new Map<string, string[]>();
   private transcript: string[] = [];
+  /** Fed each step's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     private readonly host: OpenCode.Interface,
@@ -547,6 +550,20 @@ export class OpencodeSession implements ProviderSession {
     this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.completionResolve = resolve;
     });
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(swarm.env ?? process.env),
+      model: () => this.model,
+      canDeliver: () => !this.completed && !this.aborted,
+      // A steer is promoted at the next step boundary mid-work; `resume: false`
+      // leaves an idle session idle. Same route as OpenCode's own Plan reminder.
+      inject: (note) =>
+        host.sessions.synthetic({
+          sessionID: _sessionId,
+          text: note,
+          delivery: "steer",
+          resume: false,
+        }),
+    });
   }
 
   get sessionId(): string {
@@ -685,6 +702,7 @@ export class OpencodeSession implements ProviderSession {
         // Per-step usage drives the dashboard's context gauge.
         const t = ev.data.tokens;
         const contextUsed = t.input + t.cache.read + t.cache.write + t.output;
+        void this.observeContextBound(t.input + t.cache.read + t.cache.write);
         const contextTotal = getContextWindowSize(this.model || "default");
         if (contextTotal > 0 && contextUsed > 0) {
           this.emit({

package/src/providers/pi-mono-adapter.ts

@@ -61,6 +61,7 @@ import { type TSchema, Type } from "typebox";
 import "./pi-codemode-runtime";
 // Registers the reprompt template in the code registry (the runner loads it too).
 import "../commands/templates";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { resolveTemplateAsync } from "../prompts/resolver";
 import { CORE_TOOLS } from "../tools/tool-config";
 import { classifyAwsSdkError } from "../utils/aws-error-classifier";
@@ -907,6 +908,17 @@ function safeLabel(value: unknown): string {
   return typeof value === "string" && /^[A-Za-z0-9_-]{1,32}$/.test(value) ? value : "other";
 }
 
+/** Prompt size of the request behind an assistant message: input + cache read + cache write. */
+function requestContextTokens(message: unknown): number | undefined {
+  const usage = (
+    message as { usage?: { input?: unknown; cacheRead?: unknown; cacheWrite?: unknown } }
+  )?.usage;
+  if (typeof usage?.input !== "number") return undefined;
+  const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
+  const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0;
+  return usage.input + cacheRead + cacheWrite;
+}
+
 function describeAssistantTurn(message: unknown): AssistantTurnShape {
   const msg = (message ?? {}) as {
     content?: unknown;
@@ -1008,6 +1020,14 @@ export class PiMonoSession implements ProviderSession {
   private abortRequested = false;
   /** Removes this session's own models.json once the session ends. */
   private disposeModels: () => Promise<void>;
+  /** Fed each assistant request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
+  /**
+   * From a tool-call reply until its turn ends. Pi reads steering after the
+   * turn's tool results; a steer queued later waits for the next reply, and
+   * when that is the final one it starts another turn.
+   */
+  private toolTurnOpen = false;
 
   constructor(
     agentSession: AgentSession,
@@ -1024,6 +1044,12 @@ export class PiMonoSession implements ProviderSession {
     this.logFileHandle = Bun.file(config.logFile).writer();
     this._sessionId = agentSession.sessionId;
     this.sessionStartedAt = Date.now();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.reportedModel(),
+      canDeliver: () => this.toolTurnOpen && !this.sessionEnded && !this.abortRequested,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
 
     // Emit session_init immediately
     const piVersion = readPkgVersion("@earendil-works/pi-coding-agent");
@@ -1098,6 +1124,12 @@ export class PiMonoSession implements ProviderSession {
           }
           // A successful assistant turn means any prior error has recovered.
           this.terminalError = null;
+          // Only on tool-call turns: a steer after the final reply would start
+          // another turn.
+          if (turn.hasToolCall) {
+            this.toolTurnOpen = true;
+            void this.observeContextBound(requestContextTokens(event.message));
+          }
           if (!turn.hasText && !turn.hasToolCall) {
             // Nothing else records these turns: no text and no tool call leaves
             // no trace in session logs. Block types only, never content.
@@ -1152,6 +1184,9 @@ export class PiMonoSession implements ProviderSession {
         }
         break;
       }
+      case "turn_end":
+        this.toolTurnOpen = false;
+        break;
       case "tool_execution_start": {
         const status = (event.args as { status?: unknown } | null)?.status;
         if (

package/src/runtime-providers/docker.ts

@@ -177,7 +177,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
       try {
         await dockerApi(target, "POST", `/containers/${created.Id}/start`);
       } catch (err) {
-        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true`).catch(() => {});
+        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true&v=true`).catch(
+          () => {},
+        );
         throw err;
       }
       return { kind: "docker", externalId: created.Id };
@@ -188,7 +190,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
 
   async terminate(target: RuntimeTargetConfig, handle: RuntimeHandle): Promise<void> {
     try {
-      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true`);
+      // v=true also removes the container's anonymous volumes (the worker image declares
+      // VOLUME /logs); named volumes are never removed by it.
+      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true&v=true`);
     } catch (err) {
       if (!(err instanceof DockerApiError) || err.statusCode !== 404) throw err;
     }

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -402,6 +402,36 @@ declare module "swarm-extension" {
     origin: TaskCreateOrigin;
     requestInfo?: RequestInfo;
   }
+  /** A pre.task.create hook blocked a task before it was created. */
+  export interface TaskBlockedEvent {
+    /** The extension that blocked, or whose model/agent rewrite was rejected. */
+    extension: {
+      id: string;
+      name: string;
+    };
+    /** The scrubbed block reason. */
+    reason: string;
+    origin: TaskCreateOrigin;
+    source?: AgentTask["source"];
+    requester: {
+      userId?: string;
+      agentId?: string;
+      slackUserId?: string;
+    };
+    context?: {
+      contextKey?: string;
+      scheduleId?: string;
+      workflowRunId?: string;
+      workflowRunStepId?: string;
+      parentTaskId?: string;
+      vcsRepo?: string;
+      vcsNumber?: number;
+      slackChannelId?: string;
+      slackThreadTs?: string;
+    };
+    /** The original task description, scrubbed and cut to 500 characters. */
+    description: string;
+  }
   export type TaskCreateModify = Partial<
     Pick<
       CreateTaskOptions,
@@ -704,6 +734,11 @@ declare module "swarm-extension" {
       modify: never;
       result: void;
     };
+    "post.task.blocked": {
+      event: TaskBlockedEvent;
+      modify: never;
+      result: void;
+    };
     "post.task.completed": {
       event: TaskCompletedEvent;
       modify: never;

package/src/tests/amp-adapter.test.ts

@@ -8,6 +8,7 @@ import {
   validateProviderCredentials,
 } from "../commands/provider-credentials";
 import { recomputeSessionCost } from "../http/session-cost-recompute";
+import { renderContextBoundNote } from "../prompts/context-bound-note";
 import { createProviderAdapter } from "../providers";
 import {
   AMP_PACKAGE,
@@ -31,6 +32,7 @@ import { getModelAwareCredentialVars } from "../utils/credentials";
 import { resolveHarnessProvider } from "../utils/harness-provider";
 import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
 import { ampPricingLookup } from "./amp-pricing-helpers";
+import { holdTemplateRender } from "./fixtures/held-template-render";
 
 const KEY = "sgamp_test_credential_value";
 
@@ -769,6 +771,101 @@ describe("amp session", () => {
   }, 20_000);
 });
 
+describe("amp context-bound note", () => {
+  // Each fake request is 4 input + 200 cache read + 1000 cache write = 1204 tokens.
+  async function toolResults(
+    mode: string,
+    env: Record<string, string>,
+    overrides: Partial<ProviderSessionConfig> = {},
+  ) {
+    const { config } = await fixture(mode, overrides, env);
+    const { events, result } = await runToCompletion(config);
+    const results = events.flatMap((e) => (e.type === "tool_end" ? [e.result] : []));
+    return { results, result };
+  }
+
+  test("queues the note into the first tool result at the threshold, then never again", async () => {
+    const { results, result } = await toolResults("steer-twice", {
+      CONTEXT_BOUND_NOTE_TOKENS: "1204",
+    });
+    expect(results).toEqual([`2\n\n${await renderContextBoundNote(1204)}`, "2"]);
+    // Carried inside the turn: no extra turn replays it.
+    expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    expect(result.cost?.numTurns).toBe(1);
+  });
+
+  test("a pinned model gets the window share; a mode names no model and gets none", async () => {
+    const pin = "anthropic/claude-sonnet-4-6";
+    const pinned = await toolResults(
+      "steer-twice",
+      { CONTEXT_BOUND_NOTE_TOKENS: "1204" },
+      { model: pin },
+    );
+    const note = await renderContextBoundNote(1204, pin);
+    expect(note).toContain("of the 1,000,000-token window)");
+    expect(pinned.results).toEqual([`2\n\n${note}`, "2"]);
+    const mode = await toolResults("steer-twice", { CONTEXT_BOUND_NOTE_TOKENS: "1204" });
+    expect(mode.results[0]).not.toContain("token window");
+  });
+
+  test("no-op below the threshold and when disabled at 0", async () => {
+    for (const threshold of ["1205", "0"]) {
+      const { results } = await toolResults("steer-twice", {
+        CONTEXT_BOUND_NOTE_TOKENS: threshold,
+      });
+      expect(results).toEqual(["2", "2"]);
+    }
+  });
+
+  test("fails open on missing or corrupt request usage", async () => {
+    for (const usage of ["missing", "corrupt"]) {
+      const { results, result } = await toolResults("steer", {
+        CONTEXT_BOUND_NOTE_TOKENS: "1",
+        AMP_TEST_REQUEST_USAGE: usage,
+      });
+      expect(results).toEqual(["2"]);
+      expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    }
+  });
+
+  test("a final reply with no tool call never queues it, so no new turn starts", async () => {
+    const { results, result } = await toolResults("steer-no-tool", {
+      CONTEXT_BOUND_NOTE_TOKENS: "1",
+    });
+    expect(results).toEqual([]);
+    expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    expect(result.cost?.numTurns).toBe(1);
+  });
+
+  test("a note rendered after the last tool result is dropped, not replayed as a new turn", async () => {
+    const held = holdTemplateRender();
+    try {
+      const { config } = await fixture(
+        "steer",
+        {},
+        {
+          CONTEXT_BOUND_NOTE_TOKENS: "1204",
+          AMP_TEST_POST_RESULT_DELAY_MS: "150",
+        },
+      );
+      const session = await new AmpAdapter().createSession(config);
+      const results: unknown[] = [];
+      session.onEvent((event) => {
+        if (event.type !== "tool_end") return;
+        results.push(event.result);
+        // Ready while the final reply is pending.
+        held.release();
+      });
+      const result = await session.waitForCompletion();
+      expect(results).toEqual(["2"]);
+      expect(result).toMatchObject({ isError: false, output: "DONE1" });
+      expect(result.cost?.numTurns).toBe(1);
+    } finally {
+      held.stop();
+    }
+  });
+});
+
 describe("amp live test", () => {
   const env = async (mode: string) => {
     const { config } = await fixture(mode);