@cabane/companion 0.6.93 → 0.6.94

package/dist/runtime.js

@@ -2125,8 +2125,12 @@ var CabaneApi = class {
   // it), so it is passed down rather than inferred here. It gates the COST of
   // the aggregate, never the tenancy scoping, which the route applies
   // unconditionally.
-  getTurnContext(conversationId, messageId2, turnId, resumed) {
-    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "") + (resumed ? "&resumed=1" : "");
+  // `fresh` asks for the context a session that holds NOTHING needs: the read
+  // from the start of the conversation, the agent's own words included, and
+  // the first-turn material — what the adapter runs on when it refused to
+  // resume the stored session and is starting a fresh one.
+  getTurnContext(conversationId, messageId2, turnId, resumed, fresh) {
+    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "") + (resumed ? "&resumed=1" : "") + (fresh ? "&fresh=1" : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
   // CT1380: the local half of a resumed turn's seq floor (see
@@ -2135,6 +2139,18 @@ var CabaneApi = class {
   outboxMaxSeqForTurn(turnId) {
     return this.opts.outbox?.maxSeqForTurn(turnId) ?? 0;
   }
+  // Whether this turn's speech is still waiting in the outbox — the half of
+  // "did the span speak" the server cannot see: a first message absorbed by a
+  // transient failure before the crash is on disk here, spent and undelivered,
+  // and the resumed run must not commit its next note as first words again.
+  // A runtime notice queued under the turn is not speech.
+  outboxHasSpeechForTurn(turnId) {
+    const outbox = this.opts.outbox;
+    if (!outbox) return false;
+    return outbox.list().some(
+      (e) => e.turnId === turnId && e.kind === "message" && e.body?.kind !== "runtime_notice"
+    );
+  }
   // CT714: read a turn's recorded turn-control intent. An EXTERNAL adapter
   // (Codex / opencode) records `reply_to` / `skip_turn` into `turn_intents`
   // server-side (the URL MCP surface) rather than the dispatcher's in-memory
@@ -2260,6 +2276,23 @@ var CabaneApi = class {
   async durableActiveRunWrite(path, conversationId, agentId, body) {
     const outbox = this.opts.outbox;
     const key = activeRunOutboxKey(conversationId, agentId);
+    const turnId = body?.turnId;
+    if (outbox && typeof turnId === "string" && outbox.maxSeqForTurn(turnId) > 0) {
+      outbox.persist({
+        enqueuedAt: Date.now(),
+        turnId: key,
+        seq: ACTIVE_RUN_OUTBOX_SEQ,
+        method: "PATCH",
+        path,
+        body,
+        kind: "active-run"
+      });
+      this.opts.log?.warn(
+        { conversationId, agentId, turnId },
+        "companion: settle queued behind this turn's undelivered commits (drains in order)"
+      );
+      return;
+    }
     try {
       await this.request("PATCH", path, body, { retry: true });
       outbox?.remove(key, ACTIVE_RUN_OUTBOX_SEQ);
@@ -2301,16 +2334,11 @@ var CabaneApi = class {
   // (transport errors + 5xx), never a 4xx, so no `(turnId, kind)` row is
   // double-posted. The caller threads its turn abort signal so a cancel
   // mid-commit aborts the in-flight POST rather than letting it land.
-  // CT11: `kind` includes `'stopped'` for the terminal cancel marker — same
-  // wire shape as `progress`/`final`, distinguished only by `kind` so the chat
-  // drawer's turn-group renderer treats it as a closing row. CT1295: this
-  // companion no longer WRITES that kind — the server does, in the transaction
-  // that terminalizes the stopped turn — so the value survives here only as
-  // wire vocabulary the server also speaks. `seq` is the companion's per-turn
+  // Workzone: a commit is a message — the agent's first or last words — or the
+  // runtime's own line (`runtime_notice`). The words between tool calls go
+  // through `reportText`, the trail's door. `seq` is the companion's per-turn
   // monotonic counter, stamped on the row so the merged timeline orders the
-  // commit deterministically against the persisted tool/thinking rows. Both
-  // fields are optional on the wire — an older companion that didn't mint seq
-  // still validates (the server defaults to 0).
+  // commit deterministically against the persisted tool/thinking rows.
   postTurnMessage(workspaceId, conversationId, body, signal) {
     return this.durableCommit(
       "message",
@@ -2321,35 +2349,6 @@ var CabaneApi = class {
       signal
     );
   }
-  // CT1357: post ONE ordinary addressed message — not turn speech, no `turnId`
-  // — so `dispatch` is honoured and the target agent is woken. The turn-commit
-  // fork ignores `dispatch` (an act rides its own call now), which leaves this
-  // as the only way a companion can address a peer OUTSIDE a running turn.
-  //
-  // The prepare-failure handback is exactly that case and the reason this
-  // exists. It fires before the turn is ever admitted — the active-run PATCH
-  // that admits it comes after the prepare hook — so `turnAct` is not available:
-  // its route resolves the turn first and 404s when there is none. The failure
-  // notice's own commit is what admits the turn, and by then it has also settled
-  // it. An ordinary addressed post depends on no lease at all, which is what
-  // makes it the right shape here.
-  //
-  // Retried like any durable write, and therefore REQUIRING `idempotencyKey`:
-  // this is not outbox-queued (there is no `(turnId, seq)` for a non-turn row),
-  // so without a key a committed request whose response was lost — or a
-  // redelivered dispatch event — writes a second row and wakes the peer twice.
-  // The server dedupes on `(conversation_id, idempotency_key)`: the repeat
-  // returns the existing row and raises no second dispatch (CT239). Required,
-  // not optional, so a future caller cannot omit it and silently lose the
-  // guarantee.
-  postAddressedMessage(workspaceId, conversationId, body, signal) {
-    return this.request(
-      "POST",
-      `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
-      body,
-      signal ? { retry: true, signal } : { retry: true }
-    );
-  }
   // SJ477: report one tool-activity transition (start / done / error) for the
   // live activity cards. Transient — the server publishes an `agent_activity`
   // SSE and writes no row. Agent-PAT authed; the URL `:agentId` must match the
@@ -2379,6 +2378,20 @@ var CabaneApi = class {
       signal
     );
   }
+  // Workzone: report one text the agent wrote between tool calls — the trail's
+  // door. Durable like a thinking row (same outbox, same `(turnId, seq)`
+  // replay), and never a message: the server writes it to `message_activity`
+  // under the span and nothing lands, stamps or wakes on it.
+  reportText(workspaceId, conversationId, agentId, body, signal) {
+    return this.durableCommit(
+      "text",
+      `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/text`,
+      body,
+      body.turnId,
+      body.seq,
+      signal
+    );
+  }
   // SJ493: fetch the agent's self-view — identity + operating context. The
   // companion calls this on each dispatch to get its `systemPrompt` (composed
   // server-side from the bundled default + the agent's charter) rather than
@@ -3511,20 +3524,24 @@ var THINKING_TEXT_MAX_CHARS = 3900;
 var TurnPump = class {
   constructor(opts) {
     this.opts = opts;
+    this.hasSpoken = opts.spoke ?? false;
     this.sink = {
       onAssistantText: async (evt) => {
         if (opts.signal.aborted) return;
         const body = normalizeCommitText(evt.text);
         if (!body) return;
-        const kind = evt.final ? "final" : "progress";
         const seq = opts.nextSeq();
-        await opts.commit.commitMessage({ body, kind, seq });
+        if (!evt.final && this.hasSpoken) {
+          await opts.commit.reportText({ text: body, seq });
+          return;
+        }
+        await opts.commit.commitMessage({ body, kind: "message", seq });
+        this.hasSpoken = true;
         if (evt.final) {
           this.emittedFinal = true;
+          this.lastSeq = seq;
           this.finalReplyBody = body;
           this.emittedFinalSource = "runtime_text";
-        } else {
-          this.lastProgressBody = body;
         }
       },
       onToolActivity: async (evt) => {
@@ -3561,11 +3578,12 @@ var TurnPump = class {
     };
   }
   opts;
-  // `finalEmitted` gates the end-of-turn progress promotion;
-  // `lastProgressBody` is what we promote to `final` when a clean turn ended on
-  // a tool call with no closing text.
+  // A message has landed under this span — its first words. Every later
+  // non-terminal text is the trail. Seeded from the host on a resume.
+  hasSpoken;
+  // The last words landed, and their `seq` — what the settle declares.
   emittedFinal = false;
-  lastProgressBody = null;
+  lastSeq = null;
   // The turn's final reply text, captured for the dashboard feed / logging.
   finalReplyBody = null;
   emittedFinalSource = "none";
@@ -3576,31 +3594,20 @@ var TurnPump = class {
   // frozen committer test — drive. Each callback applies the choreography and
   // commits through the injected sink.
   sink;
-  // End-of-turn progress promotion. A clean turn that emitted interim text but
-  // no closing text promotes the agent's own last progress body (the drawer
-  // collapses the duplicate). If the agent emitted no words, emit no message:
-  // Cabane never attributes host-authored text to an agent, in any turn shape,
-  // for any reason. The host closes that wordless turn with a marker instead.
-  // Skipped when cancelled or already final. The held-text flush that precedes
-  // this is a classification concern, driven by the caller before this runs.
-  async finalize(ok) {
-    if (!ok || this.opts.signal.aborted || this.emittedFinal || !this.lastProgressBody) return;
-    const body = this.lastProgressBody;
-    const seq = this.opts.nextSeq();
-    try {
-      await this.opts.commit.commitMessage({ body, kind: "final", seq });
-      this.emittedFinal = true;
-      this.finalReplyBody = body;
-      this.emittedFinalSource = "progress_promotion";
-    } catch (err) {
-      this.opts.onError?.(err, "progress-promotion");
-    }
+  // Whether a message has landed under this span — first words, at least. A
+  // span that spoke settles; one that never did is a pass.
+  get spoke() {
+    return this.hasSpoken;
   }
-  // Whether the turn has committed its `final` row — read by the host to decide
-  // whether a marker is owed.
+  // Whether the turn has committed its last words.
   get finalEmitted() {
     return this.emittedFinal;
   }
+  // The `seq` of the last words, for the settle to declare — or null when the
+  // span ended without any. Nothing is put in their place.
+  get lastMessageSeq() {
+    return this.lastSeq;
+  }
   // The turn's final reply text, or null if none landed (failure / cancel /
   // empty). Used for the dashboard feed's reply preview.
   get replyBody() {
@@ -4069,7 +4076,11 @@ function sdkEvents(queryFn, req, signal, built, degraded) {
     degraded
   });
 }
-async function* runWithResumeRecovery(queryFn, req, signal, initial, augmentOptions, onWarn, degraded) {
+async function freshRequest(req, reason, hooks) {
+  const recomposed = hooks?.fresh ? await hooks.fresh(reason) : null;
+  return recomposed ? { req: { ...req, ...recomposed, session: null }, degraded: false } : { req: { ...req, session: null }, degraded: true };
+}
+async function* runWithResumeRecovery(queryFn, req, signal, initial, augmentOptions, onWarn, degraded, hooks) {
   let emitted = false;
   for await (const event of sdkEvents(queryFn, req, signal, initial, degraded)) {
     const recoverResume = initial.resume !== null && !emitted && event.type === "result" && !event.ok && event.reason === "session_start_failed" && event.mcpInventory?.initReceived === false;
@@ -4083,9 +4094,10 @@ async function* runWithResumeRecovery(queryFn, req, signal, initial, augmentOpti
           discardedSessionId: initial.resume
         }
       );
-      const freshReq = { ...req, session: null };
-      const fresh = buildClaudeCodeOptions(freshReq, augmentOptions);
-      yield* sdkEvents(queryFn, freshReq, signal, fresh, true);
+      const fresh = await freshRequest(req, "session_start_failed", hooks);
+      if (signal.aborted) return;
+      const options = buildClaudeCodeOptions(fresh.req, augmentOptions);
+      yield* sdkEvents(queryFn, fresh.req, signal, options, fresh.degraded);
       return;
     }
     emitted = true;
@@ -4098,23 +4110,32 @@ function createClaudeCodeAdapter(deps = {}) {
     name: "claude-code",
     promptAddendum: () => CLAUDE_CODE_ADDENDUM,
     dialectSchema: claudeCodeDialectSchema,
-    runTurn(req, signal) {
-      const { options, resume, freshReason } = buildClaudeCodeOptions(req, deps.augmentOptions);
-      if (freshReason === "cwd_mismatch") {
+    async *runTurn(request, signal, hooks) {
+      let req = request;
+      let built = buildClaudeCodeOptions(req, deps.augmentOptions);
+      if (built.freshReason === "cwd_mismatch") {
         deps.onWarn?.(
           "claude-code adapter: stored session cwd no longer matches the current environment \u2014 starting a fresh session (SJ527 guard)",
           { cwd: req.local.cwd }
         );
       }
-      const degraded = freshReason !== void 0 && freshReason !== "no_session";
-      return runWithResumeRecovery(
+      let degraded = false;
+      if (built.freshReason !== void 0 && built.freshReason !== "no_session") {
+        const fresh = await freshRequest(req, built.freshReason, hooks);
+        if (signal.aborted) return;
+        req = fresh.req;
+        degraded = fresh.degraded;
+        built = buildClaudeCodeOptions(req, deps.augmentOptions);
+      }
+      yield* runWithResumeRecovery(
         queryFn,
         req,
         signal,
-        { options, resume, freshReason },
+        built,
         deps.augmentOptions,
         deps.onWarn,
-        degraded
+        degraded,
+        hooks
       );
     }
   };
@@ -5276,7 +5297,8 @@ function createOpencodeAdapter(deps = {}) {
     // argument went with the named tool surface it selected against.
     promptAddendum: () => OPENCODE_ADDENDUM,
     dialectSchema: opencodeDialectSchema,
-    async *runTurn(req, signal) {
+    async *runTurn(request, signal, hooks) {
+      let req = request;
       if (!transport) {
         yield {
           type: "result",
@@ -5294,7 +5316,15 @@ function createOpencodeAdapter(deps = {}) {
           { directory }
         );
       }
-      const degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
+      let degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
+      if ("fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session" && hooks?.fresh) {
+        const recomposed = await hooks.fresh(decision.reason);
+        if (signal.aborted) return;
+        if (recomposed) {
+          req = { ...req, ...recomposed, session: null };
+          degraded = false;
+        }
+      }
       const spec = buildRunSpec(req, resume);
       const result = await transport.run(spec, signal);
       if (signal.aborted) return;
@@ -6301,7 +6331,8 @@ function createCodexAdapter(deps = {}) {
     // argument went with the named tool surface it selected against.
     promptAddendum: () => CODEX_ADDENDUM,
     dialectSchema: codexDialectSchema,
-    async *runTurn(req, signal) {
+    async *runTurn(request, signal, hooks) {
+      let req = request;
       if (!transport) {
         yield {
           type: "result",
@@ -6320,7 +6351,15 @@ function createCodexAdapter(deps = {}) {
           { directory }
         );
       }
-      const degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
+      let degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
+      if ("fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session" && hooks?.fresh) {
+        const recomposed = await hooks.fresh(decision.reason);
+        if (signal.aborted) return;
+        if (recomposed) {
+          req = { ...req, ...recomposed, session: null };
+          degraded = false;
+        }
+      }
       let instructions = null;
       if (!req.policy.hostFs) {
         if (!deps.writeInstructionsFile) {
@@ -7362,14 +7401,11 @@ var MIN_ASK_OPTIONS = 2;
 var MAX_ASK_OPTIONS = 4;
 var MAX_WAKE_NOTE_BYTES = 2e3;
 var MAX_WITHDRAW_REASON_BYTES = 400;
-var MAX_SEND_MESSAGE_BYTES = 65536;
 var MAX_SKIP_REASON_BYTES = 500;
 var TURN_CONTROL_TOOL_DESCRIPTIONS = {
-  ask: `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. Provide EITHER \`question\` (single) or \`questions\` (array), never both. **Several decisions landing together are ONE call with \`questions\`** \u2014 never cram the extras into prose, drop all but one, or fire an ask each: a second \`ask\` is a second inbox item competing with the first, never an edit to it. Each question keeps the same form: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links and detail go in your REPLY; inline markdown only, no lists or headings), and ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. The ask is a first-class attention item aimed at that person; your final reply carries the CONTEXT, the ask carries the QUESTION(S). It is written and delivered THE MOMENT you call this \u2014 the person sees it in their inbox while your turn is still running \u2014 so call it once you know the question. The human sends ONE response: supplied answers are recorded, omissions become terminally Unanswered. Ask only when blocked \u2014 never ceremonially. \`replaces\` withdraws a stale ask of yours (or anyone's) in this conversation in the same write, with the reason shown to the person. Targets a human only; to hand work to another AGENT use send/dispatch instead.`,
+  ask: `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. Provide EITHER \`question\` (single) or \`questions\` (array), never both. **Several decisions landing together are ONE call with \`questions\`** \u2014 never cram the extras into prose, drop all but one, or fire an ask each: a second \`ask\` is a second inbox item competing with the first, never an edit to it. Each question keeps the same form: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links and detail go in your REPLY; inline markdown only, no lists or headings), and ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. The ask is a first-class attention item aimed at that person; your final reply carries the CONTEXT, the ask carries the QUESTION(S). It is written and delivered THE MOMENT you call this \u2014 the person sees it in their inbox while your turn is still running \u2014 so call it once you know the question. The human sends ONE response: supplied answers are recorded, omissions become terminally Unanswered. Ask only when blocked \u2014 never ceremonially. \`replaces\` withdraws a stale ask of yours (or anyone's) in this conversation in the same write, with the reason shown to the person. Targets a human only; to bring a peer AGENT in, name them by \`@handle\` in your reply.`,
   cancel_wake: `Stand down your own wake \u2014 the inverse of \`wake_me\`. No arguments: it cancels the wake you have armed in this conversation, NOW, when you call it. Reach for it when the thing you armed a wake to check has already happened, or the work it was watching is over \u2014 an armed wake you no longer need fires into a turn with nothing to do, and a supervision loop with no off switch is one you can only end by leaving it running. Whether you have one armed is printed in your turn context ("Wake armed: \u2026"); calling this with nothing armed is a clean no-op, no error. Each call acts as it arrives: \`cancel_wake\` then \`wake_me\` leaves the NEW wake armed; \`wake_me\` then \`cancel_wake\` leaves nothing armed. It reaches only your own wake in this conversation \u2014 never a peer's, and never a recurring schedule (those are \`schedules.*\`).`,
-  reply_to: `Declare which addressed ask your final response answers. Pass the \`messageId\` shown as the owed reply id in your turn context, then finish your response normally. This records lineage only: it does not send another message. The server verifies that this agent owes that ask in this conversation; one reply per turn \u2014 a later call replaces the earlier declaration.`,
-  send: `Send one addressed message to another agent in THIS conversation. Pass the peer's \`agentId\` and the complete \`message\` they should act on. The message is WRITTEN the moment you call this \u2014 durable, in the conversation's queue, in the order you called \u2014 but it is DELIVERED only after your own turn ends: the peer is not running yet and cannot answer you inside this turn. Each call is one message; two calls are two messages. Writing \`@handle\` in prose dispatches nobody. An unknown, deactivated, or self target is refused here, in the result. A handoff to a DIFFERENT conversation is \`conversations.create\` / \`conversations.post\` with their \`dispatch\` field instead. Never use send to hand an answer back to the requester \u2014 declare that with reply_to.`,
-  skip_turn: `End your current turn WITHOUT posting a reply. Call this when you've been dispatched but the message genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or a pile-on where someone else has it. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
+  skip_turn: `End your current turn WITHOUT posting a reply. Call this when you've been woken to read a message that genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or something another participant clearly owns. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
   wake_me: `Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for "wait until X": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an \`ask\`. Pass EXACTLY ONE of \`afterSeconds\` (a relative delay \u2014 \`300\` for five minutes) or \`at\` (an absolute ISO-8601 timestamp WITH a zone, e.g. \`2026-07-16T09:00:00-07:00\` \u2014 YOU compute it; the system never parses natural-language time). \`note\` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check ("check whether CT441 merged yet"). The wake arms NOW, when you call this, and the delay counts from this call; a later \`wake_me\` in the same turn replaces it, and \`cancel_wake\` stands it down. A wake that comes due while your turn is still running waits and is delivered after your reply. This is the ONLY sanctioned way to schedule your own continuation; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days \u2014 a wake that can't be armed returns an error here, in this call, so you can recompute; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an \`ask\` to the human instead.`,
   withdraw_ask: `Withdraw an open ask \u2014 yours or anyone's in this conversation \u2014 because the question is moot, was wrong, or has been overtaken. \`reason\` is required and is shown to the person and, if it wasn't your ask, to the agent who asked it. If there is a current question to put in its place, don't call this \u2014 call \`ask\` with \`replaces\` so the two land as one and the person never sees neither or both. Never withdraw to hurry an answer; to act on a deadline, arm a \`wake_me\` and decide then.`
 };
@@ -7388,13 +7424,6 @@ var TURN_CONTROL_FIELD_DESCRIPTIONS = {
     "replaces.reason": `Why the old question is no longer the question \u2014 shown to the person on their Done row. Up to ${MAX_WITHDRAW_REASON_BYTES} characters.`
   },
   cancel_wake: {},
-  reply_to: {
-    messageId: "The owed ask message id from this turn context."
-  },
-  send: {
-    agentId: "The peer agent to address \u2014 a workspace agent id, from your turn context's roster.",
-    message: `The complete new request the peer should receive and act on. Up to ${MAX_SEND_MESSAGE_BYTES} characters.`
-  },
   skip_turn: {
     reason: `Short reason you are declining \u2014 used for telemetry/debugging, never posted. Up to ${MAX_SKIP_REASON_BYTES} characters.`
   },
@@ -7412,34 +7441,20 @@ var TURN_CONTROL_FIELD_DESCRIPTIONS = {
 // src/turn-control-tools.ts
 import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
-var SEND_TOOL = "send";
-var SEND_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SEND_TOOL}`;
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var SKIP_TURN_TOOL = "skip_turn";
 var ASK_TOOL = "ask";
 var ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
 var WITHDRAW_ASK_TOOL = "withdraw_ask";
 var WITHDRAW_ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WITHDRAW_ASK_TOOL}`;
-var REPLY_TO_TOOL = "reply_to";
-var REPLY_TO_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${REPLY_TO_TOOL}`;
 var WAKE_ME_TOOL = "wake_me";
 var WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
 var CANCEL_WAKE_TOOL = "cancel_wake";
 var CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
 var TURN_ACT_TIMEOUT_MS = 45e3;
-function createReplyState() {
-  return { answersMessageId: null };
-}
 function createSkipState() {
   return { skipped: false, reason: null };
 }
-function resolveDeclaredReplyField(input) {
-  const explicit = input.replyState.answersMessageId;
-  if (explicit) return { answersMessageId: explicit };
-  if (input.kind !== "final") return {};
-  if (!input.owedReplyMessageId) return {};
-  return { answersMessageId: input.owedReplyMessageId, answersAutoDeclared: true };
-}
 function toolError(text) {
   return { isError: true, content: [{ type: "text", text }] };
 }
@@ -7469,7 +7484,7 @@ async function performAct(acts, act) {
   if (!result.ok) return toolError(JSON.stringify(result));
   return { content: [{ type: "text", text: JSON.stringify(result) }] };
 }
-function createTurnControlMcpServer(acts, skipState, replyState) {
+function createTurnControlMcpServer(acts, skipState) {
   const ACT_TOOL = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
   const CANCEL_TOOL = { ...ACT_TOOL, idempotentHint: true };
   const RECORDER_TOOL = { readOnlyHint: true, openWorldHint: false };
@@ -7477,42 +7492,6 @@ function createTurnControlMcpServer(acts, skipState, replyState) {
     name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
     tools: [
-      tool(
-        SEND_TOOL,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.send,
-        {
-          agentId: z13.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.send.agentId),
-          message: z13.string().min(1).max(MAX_SEND_MESSAGE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.send.message)
-        },
-        async (args) => performAct(acts, {
-          kind: "send",
-          callId: randomUUID(),
-          agentId: args.agentId,
-          message: args.message
-        }),
-        { annotations: ACT_TOOL, alwaysLoad: true }
-      ),
-      ...replyState ? [
-        tool(
-          REPLY_TO_TOOL,
-          TURN_CONTROL_TOOL_DESCRIPTIONS.reply_to,
-          {
-            messageId: z13.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.reply_to.messageId)
-          },
-          async (args) => {
-            replyState.answersMessageId = args.messageId;
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ answersMessageId: args.messageId })
-                }
-              ]
-            };
-          },
-          { annotations: RECORDER_TOOL, alwaysLoad: true }
-        )
-      ] : [],
       ...skipState ? [
         tool(
           SKIP_TURN_TOOL,
@@ -8039,8 +8018,7 @@ var TurnCommitter = class {
             kind,
             turnId: deps.turnId,
             seq,
-            parentMessageId: deps.parentMessageId,
-            ...kind === "final" ? this.turnControlFields("final") : {}
+            parentMessageId: deps.parentMessageId
           },
           deps.signal
         );
@@ -8081,19 +8059,22 @@ var TurnCommitter = class {
           { turnId: deps.turnId, text, seq },
           deps.signal
         );
+      },
+      reportText: async ({ text, seq }) => {
+        await deps.api.reportText(
+          deps.workspaceId,
+          deps.conversationId,
+          deps.agentId,
+          { turnId: deps.turnId, text, seq },
+          deps.signal
+        );
       }
     };
     this.pump = new TurnPump({
       commit,
       signal: deps.signal,
       nextSeq: deps.nextSeq,
-      onError: (err) => {
-        deps.log.warn(
-          { err: err instanceof Error ? err.message : String(err) },
-          "dispatcher: progress-promotion commit failed"
-        );
-        deps.onCommitFailed?.(err);
-      }
+      ...deps.spoke !== void 0 ? { spoke: deps.spoke } : {}
     });
     this.emit = sinkEmitter(this.pump.sink, this.onError);
   }
@@ -8117,15 +8098,17 @@ var TurnCommitter = class {
       this.onError(err, event.type);
     }
   }
-  // End-of-turn progress promotion. The held-text flush is now the adapter's
-  // job (it emits the closing reply as a `text` event before `result`), so this
-  // only asks the pump to promote agent-authored interim text. A wordless turn
-  // stays wordless and the dispatcher closes it with a `silent`/`skipped`
-  // marker (CT1295: a CANCELLED turn is closed by the SERVER's `stopped`
-  // marker, not from this side). Guards on the abort signal, so on cancel no
-  // `final` is forced.
-  async finalize(okResult) {
-    await this.pump.finalize(okResult);
+  // A message has landed under this span — its first words at least. A span
+  // that spoke settles; one that never did is a pass. Nothing is promoted at
+  // the end of a turn: the held-text flush is the adapter's (it emits the
+  // closing reply as a terminal `text` event before `result`), and a span
+  // that ended on working text ends without last words.
+  get spoke() {
+    return this.pump.spoke;
+  }
+  // The `seq` of the last words, for the settle to declare; null when none.
+  get lastMessageSeq() {
+    return this.pump.lastMessageSeq;
   }
   // The turn's final reply text, or null if none landed.
   get replyBody() {
@@ -8137,26 +8120,6 @@ var TurnCommitter = class {
   get finalEmitted() {
     return this.pump.finalEmitted;
   }
-  // A closing textual reply and a wordless terminal marker carry the same
-  // declared-reply projection. The KIND matters: the auto-declared reply binds
-  // only a textual `final` — a wordless turn has no answer to bind, and the
-  // server's mute-settle notice speaks for it.
-  turnControlFields(kind) {
-    return this.answersField(kind);
-  }
-  // The declared reply: explicit `reply_to` first, else the runtime's own
-  // declaration for the turn that just answers — see
-  // `resolveDeclaredReplyField` for the whole rule and its reasons. CT1224: an
-  // auto-declaration is flagged as such on the wire, because the server drops
-  // it when the turn performed an outward act (CT1354: any of them, read off
-  // the ledger). An explicit `reply_to` carries no flag and always stands.
-  answersField(kind) {
-    return resolveDeclaredReplyField({
-      kind,
-      owedReplyMessageId: this.deps.owedReplyMessageId,
-      replyState: this.deps.replyState
-    });
-  }
 };
 
 // src/turn-runtime-integrity.ts
@@ -8170,7 +8133,7 @@ async function postIncompleteNotice(ctx, harness, resolution) {
   try {
     await ctx.postTurnMessage(ctx.workspaceId, ctx.conversationId, {
       body: turnIncompleteCopy(harness),
-      kind: "final",
+      kind: "runtime_notice",
       turnId: ctx.turnId,
       parentMessageId: ctx.parentMessageId
     });
@@ -8239,12 +8202,9 @@ async function absorbBundledLoss(ctx, aborted, outcome) {
 
 // src/turn-execution.ts
 var PREPARING_TOOL_NAME = "preparing";
-var PREPARE_FAILED_PREFIX = "**Couldn't prepare your environment.** I wasn't able to provision a working directory for this conversation, so I can't run this turn. The provisioning command reported:";
 var MISSING_SECRET_PREFIX = "**Missing secret on this companion.** This agent's tools need a credential this device hasn't been given, so I can't run this turn safely. Declare it in this companion\u2019s secret store (`~/.cabane/secrets.json`) and try again. Missing:";
 var RUNTIME_UNAVAILABLE_PREFIX = "**This agent's runtime isn't available on this companion.** The model this agent uses needs a runtime this device isn't running, so I can't run this turn here. Details:";
 var UNEXPECTED_ROLE_REASON = `refused the wake trigger (role "system" isn't dispatchable on this companion) \u2014 the companion is likely running outdated code; refresh it, then re-address the agent`;
-var SKIPPED_MARKER_BODY = "(skipped)";
-var SILENT_MARKER_BODY = "(no reply)";
 var DEFAULT_PREPARING_ROW_DELAY_MS = 1500;
 var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
@@ -8265,7 +8225,6 @@ function initialOutcome() {
     contentBearingEvents: 0,
     latestSessionState: null,
     settledDiagnostics: null,
-    silentMarkerEmitted: false,
     timeoutReason: null,
     leaseLost: false,
     runtimeIncomplete: false
@@ -8314,13 +8273,15 @@ var TurnExecution = class {
   // `turnId` is set on every dispatch. `resumedFromSeq` is what it seeded from.
   resumed;
   resumedFromSeq;
+  // Whether the span this resumed run continues already has first words —
+  // from the server (`turnSpoke`) or from speech still queued in the outbox.
+  resumedSpoke = false;
   turnContext;
   resolvedMcpServers;
   effectiveCwd;
   hookEnv;
   turnEnv;
   skipState;
-  replyState;
   turnControlServer;
   request;
   adapter;
@@ -8338,9 +8299,9 @@ var TurnExecution = class {
   disarmWatchdogs = () => {
   };
   // Codo's stack review, blocking finding #2: set the moment `acquireLease`'s
-  // PATCH returns — the mailroom now holds this turn as the conversation's
-  // running one, so every exit after this point must settle THE TURN, not just
-  // clear the participant flag.
+  // PATCH returns — the lease is granted and this is the pair's running span,
+  // so every exit after this point must settle THE SPAN, not just clear the
+  // participant flag.
   admitted = false;
   concluded(reason, errorReason) {
     return new TurnConcluded(reason, errorReason);
@@ -8378,14 +8339,16 @@ var TurnExecution = class {
     return this.report();
   }
   async concludeBeforeRun(reason, errorReason) {
-    const { payload, turnLog, startedAt } = this;
-    const body = {
-      activeRunStartedAt: null,
-      // CT1046: this dispatch is over before it ran — retire its evidence so it
-      // can't authorize a turn-token mint afterwards.
-      settledMessageId: payload.messageId
-    };
+    const { payload, turnLog, startedAt, turnId } = this;
+    const body = { activeRunStartedAt: null, turnId, outcome: "failed" };
     if (errorReason) body.errorReason = errorReason.slice(0, 200);
+    const context = this.turnContext;
+    if (context?.readThrough !== void 0) {
+      body.readThrough = context.readThrough;
+      if (context.readRevision !== void 0) body.readRevision = context.readRevision;
+    } else {
+      body.readThrough = payload.messageId;
+    }
     try {
       await this.opts.api.setActiveRun(
         this.opts.workspaceId,
@@ -8404,21 +8367,18 @@ var TurnExecution = class {
     return { ok: false, durationMs, reason };
   }
   // The post-admission analogue of `concludeBeforeRun` (Codo's stack review,
-  // blocking finding #2): this turn WAS admitted — the mailroom holds it as
-  // the conversation's running turn — so the clear must NAME the turn and
-  // DECLARE its terminal outcome. A bare pre-run clear here would reset the
-  // participant flag while the turn metadata stayed running, the dispatch
-  // stayed live, and the queue stayed held until the reaper. `outcome`
-  // follows the settle wire's rule: a failure names its reason; without one
-  // the turn settled — the runtime-unavailable exit posts its user-facing
-  // `final` before concluding, so the turn genuinely produced its terminal
-  // output and `settled` releases the queue honestly.
+  // blocking finding #2): this turn WAS admitted — it holds the conversation's
+  // lease — so the clear must NAME the turn and DECLARE its terminal outcome.
+  // A bare pre-run clear here would reset the participant flag while the span
+  // stayed running until the lost sweep. `outcome` follows the settle wire's
+  // rule: a failure names its reason; without one the turn settled — the
+  // runtime-unavailable exit posts its user-facing `final` before concluding,
+  // so the turn genuinely produced its terminal output.
   async concludeAdmittedRun(reason, errorReason) {
     const { payload, turnLog, startedAt, turnId } = this;
     const body = {
       activeRunStartedAt: null,
       turnId,
-      settledMessageId: payload.messageId,
       // CT1379: `runtimeIncomplete` is a real failure that deliberately carries
       // no `errorReason`, so the inference alone would read it as settled.
       outcome: errorReason || this.outcome.runtimeIncomplete ? "failed" : "settled"
@@ -8444,6 +8404,7 @@ var TurnExecution = class {
   async fetchContext() {
     const { payload, turnId, turnLog } = this;
     const outboxFloor = this.resumed ? readOutboxFloor((id) => this.opts.api.outboxMaxSeqForTurn(id), turnId, turnLog) : 0;
+    const outboxSpoke = this.resumed && this.opts.api.outboxHasSpeechForTurn(turnId);
     let turnContext;
     try {
       turnContext = await this.opts.api.getTurnContext(
@@ -8471,12 +8432,14 @@ var TurnExecution = class {
       const sources = { serverFloor: turnContext.turnSeqFloor, outboxFloor };
       this.resumedFromSeq = resolveSeqFloor(sources, { turnId, log: turnLog });
       this.seqCounter = Math.max(this.seqCounter, this.resumedFromSeq);
+      this.resumedSpoke = turnContext.turnSpoke === true || outboxSpoke;
+      if (this.resumedSpoke) turnLog.info({ turnId }, "dispatcher: resumed span already spoke");
     }
   }
   gateTrigger() {
     const { payload, turnLog } = this;
     const message = this.turnContext.message;
-    const isDispatchableTrigger = message.role === "user" || message.role === "agent" || message.role === "system" && message.hasPrimaryDispatch === true;
+    const isDispatchableTrigger = message.role === "user" || message.role === "agent" || message.role === "system";
     if (!isDispatchableTrigger) {
       turnLog.warn({ role: message.role }, "dispatcher: trigger role not dispatchable \u2014 skipping");
       throw this.concluded("unexpected_role", UNEXPECTED_ROLE_REASON);
@@ -8502,7 +8465,7 @@ var TurnExecution = class {
       try {
         await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
           body: `${MISSING_SECRET_PREFIX} ${list}`,
-          kind: "final",
+          kind: "runtime_notice",
           turnId: randomUUID2(),
           // CT113: even a turn that fails before it runs answers a message.
           parentMessageId: payload.messageId
@@ -8532,32 +8495,6 @@ var TurnExecution = class {
       effectiveCwd = void 0;
     }
     let hookEnv;
-    const triggerIsPrepareFailure = this.turnContext.message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const sendPrepareFailureHandback = async () => {
-      if (!this.turnContext.dispatchedByAgentId || triggerIsPrepareFailure) return;
-      try {
-        await this.opts.api.postAddressedMessage(workspaceId, payload.conversationId, {
-          body: `${PREPARE_FAILED_PREFIX}
-
-The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`,
-          dispatch: this.turnContext.dispatchedByAgentId,
-          // Keyed on the TRIGGER, not the turn: a redelivered dispatch event is
-          // the replay this has to survive, and it mints a fresh `turnId` while
-          // carrying the same `messageId`. One handback per failed pickup of a
-          // given trigger — which is also CT992's rule, that the first failure
-          // is the one carrying information. A genuine re-dispatch after a
-          // repair authors a NEW trigger message, so it keys differently and
-          // hands back again.
-          idempotencyKey: `prepare-failure-handback:${payload.messageId}`,
-          parentMessageId: payload.messageId
-        });
-      } catch (err) {
-        turnLog.warn(
-          { err: err instanceof Error ? err.message : String(err) },
-          "dispatcher: prepare-failure handback failed"
-        );
-      }
-    };
     if (prepareHook) {
       let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2 && !checkoutState(cached2.cwd).ok) {
@@ -8589,23 +8526,8 @@ The dispatched turn could not start. Re-dispatch it after repairing the preparat
           } catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
             turnLog.error({ err: reason }, "dispatcher: prepare hook rejected a prepared turn");
-            try {
-              await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-                body: `${PREPARE_FAILED_PREFIX}
-
-${reason}`,
-                kind: "final",
-                turnId,
-                parentMessageId: payload.messageId
-              });
-            } catch (postErr) {
-              turnLog.warn(
-                { err: postErr instanceof Error ? postErr.message : String(postErr) },
-                "dispatcher: prepare-rejection post failed"
-              );
-            }
-            await sendPrepareFailureHandback();
-            throw this.concluded(`prepare_failed: ${reason}`);
+            const failReason = `prepare_failed: ${reason}`;
+            throw this.concluded(failReason, failReason);
           }
         }
       } else {
@@ -8664,25 +8586,8 @@ ${reason}`,
           if (preparingStarted) reportPreparing("error");
           const reason = err instanceof Error ? err.message : String(err);
           turnLog.error({ err: reason }, "dispatcher: prepare hook failed");
-          try {
-            await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-              body: `${PREPARE_FAILED_PREFIX}
-
-${reason}`,
-              kind: "final",
-              turnId,
-              // CT113: stamp the parent even on the prepare-failed close.
-              parentMessageId: payload.messageId
-            });
-          } catch (postErr) {
-            turnLog.warn(
-              { err: postErr instanceof Error ? postErr.message : String(postErr) },
-              "dispatcher: prepare-failure post failed"
-            );
-          }
-          await sendPrepareFailureHandback();
           const failReason = `prepare_failed: ${reason}`;
-          throw this.concluded(failReason);
+          throw this.concluded(failReason, failReason);
         }
       }
     }
@@ -8709,7 +8614,12 @@ ${reason}`,
         // already emitted a "preparing" activity row for this turn above (it
         // runs before this flip), which would otherwise make the sweep mistake
         // this live turn for an abandoned one and close it with a `stopped`.
-        turnId
+        turnId,
+        // The newest message this turn's read covered: the lease records it,
+        // and settle moves the cursor to it. Omitted when the server sent
+        // none (an older API), so the cursor stays where it was.
+        ...this.turnContext.readThrough !== void 0 ? { readThrough: this.turnContext.readThrough } : {},
+        ...this.turnContext.readRevision !== void 0 ? { readRevision: this.turnContext.readRevision } : {}
       });
     } catch (err) {
       const refusal = leaseRefusal(err);
@@ -8732,11 +8642,9 @@ ${reason}`,
   buildRequest() {
     const { payload, workspaceId } = this;
     const skipState = this.skipState = createSkipState();
-    const replyState = this.replyState = createReplyState();
     const turnControlServer = createTurnControlMcpServer(
       { api: this.opts.api, workspaceId, turnId: this.turnId },
-      skipState,
-      replyState
+      skipState
     );
     this.request = buildCompanionTurnRequest({
       turnContext: this.turnContext,
@@ -8805,7 +8713,7 @@ ${reason}`,
       try {
         await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
           body: `${RUNTIME_UNAVAILABLE_PREFIX} ${err.message}`,
-          kind: "final",
+          kind: "runtime_notice",
           turnId,
           parentMessageId: payload.messageId
         });
@@ -8820,6 +8728,43 @@ ${reason}`,
       throw this.concluded(`runtime_unavailable:${err.runtime}`);
     }
   }
+  // The adapter refused to resume this pair's stored session and is starting a
+  // fresh one. The request it holds was composed for a session that had the
+  // conversation so far — the read is what landed since the cursor, the
+  // agent's own words left out because the session held them. A fresh session
+  // holds none of it, so fetch the context again as a first turn on an empty
+  // session (the whole conversation, own words included, the first-turn
+  // material) and hand the adapter that to run on — before it speaks or acts.
+  // The lease already granted stands; the read reaches at least its mark. A
+  // fetch that fails returns null and the adapter falls back to the request
+  // it has, flagged degraded, so the server rewinds the cursor at settle.
+  async freshRequest(reason) {
+    const { payload, turnId, turnLog } = this;
+    try {
+      const context = await this.opts.api.getTurnContext(
+        payload.conversationId,
+        payload.messageId,
+        turnId,
+        false,
+        true
+      );
+      turnLog.warn(
+        { reason },
+        "dispatcher: stored session not resumed \u2014 the turn context was recomposed for a fresh session"
+      );
+      return {
+        systemPrompt: context.systemPrompt,
+        prompt: context.prompt,
+        content: context.content
+      };
+    } catch (err) {
+      turnLog.error(
+        { reason, err: err instanceof Error ? err.message : String(err) },
+        "dispatcher: could not recompose the turn context for a fresh session \u2014 running on the incremental one, degraded"
+      );
+      return null;
+    }
+  }
   async execute() {
     const { payload, workspaceId, turnId, turnLog, startedAt } = this;
     const o = this.outcome;
@@ -8851,10 +8796,7 @@ ${reason}`,
       signal: abortController.signal,
       log: turnLog,
       nextSeq: this.nextSeq,
-      replyState: this.replyState,
-      // The ledger-derived owed reply, for the runtime's own declaration when
-      // the agent doesn't call `reply_to` (resolveDeclaredReplyField).
-      owedReplyMessageId: this.turnContext.owedReplyMessageId ?? null,
+      spoke: this.resumedSpoke,
       // CT1292: a commit that didn't land may mean this turn's lease is gone.
       // `noteCommitFailed` is a field slot the lease watchdog fills when it
       // arms (it starts as a no-op) — the committer only fires it from inside
@@ -8873,9 +8815,6 @@ ${reason}`,
           payload.agentId,
           turnId
         );
-        if (intent.answersMessageId) {
-          this.replyState.answersMessageId = intent.answersMessageId;
-        }
         if (intent.skipped) {
           this.skipState.skipped = true;
           this.skipState.reason = intent.skipReason;
@@ -8883,7 +8822,7 @@ ${reason}`,
       } catch (err) {
         turnLog.warn(
           { err: err instanceof Error ? err.message : String(err) },
-          "dispatcher: turn-control intent fetch failed; the declared reply / skip for this turn are dropped"
+          "dispatcher: turn-control intent fetch failed; the skip for this turn is dropped"
         );
       }
     };
@@ -8941,7 +8880,9 @@ ${reason}`,
       clearInterval(leaseTimer);
     };
     try {
-      for await (const event of this.adapter.runTurn(this.request, abortController.signal)) {
+      for await (const event of this.adapter.runTurn(this.request, abortController.signal, {
+        fresh: (reason) => this.freshRequest(reason)
+      })) {
         transcript?.write(event);
         o.eventCounts[event.type] += 1;
         if (isContentBearingEvent(event)) o.contentBearingEvents += 1;
@@ -9026,43 +8967,6 @@ ${reason}`,
           { reason: this.skipState.reason, turnId, ok: o.okResult },
           "agent skipped turn (skip_turn)"
         );
-        try {
-          await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-            body: SKIPPED_MARKER_BODY,
-            kind: "skipped",
-            turnId,
-            seq: this.nextSeq(),
-            parentMessageId: payload.messageId
-          });
-        } catch (err) {
-          turnLog.warn(
-            { err: err instanceof Error ? err.message : String(err) },
-            "dispatcher: skipped-marker commit failed"
-          );
-        }
-      } else {
-        await committer.finalize(o.okResult);
-        if (!abortController.signal.aborted && o.okResult && !committer.finalEmitted) {
-          try {
-            await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-              body: SILENT_MARKER_BODY,
-              kind: "silent",
-              turnId,
-              seq: this.nextSeq(),
-              parentMessageId: payload.messageId,
-              // An explicit `reply_to` survives a wordless turn exactly as it
-              // survives a textual final (the auto-declaration does not — a
-              // marker has no answer to bind).
-              ...committer.turnControlFields("silent")
-            });
-            o.silentMarkerEmitted = true;
-          } catch (err) {
-            turnLog.warn(
-              { err: err instanceof Error ? err.message : String(err) },
-              "dispatcher: silent-marker commit failed"
-            );
-          }
-        }
       }
     } catch (err) {
       o.okResult = false;
@@ -9105,12 +9009,7 @@ ${reason}`,
         // CT277: the server keys the turn-end metadata UPDATE (ended_at + tokens)
         // off this turn id, so the settle PATCH must carry it — the start PATCH
         // isn't enough. Always sent (every settle closes a real turn).
-        turnId,
-        // CT1046: and the trigger this turn answered, so the server retires the
-        // dispatch that authorized it. Always sent, unlike `lastSeenMessageId`
-        // below (which is a success-only catch-up advance): a failed or cancelled
-        // turn is just as over, and its evidence must die with it.
-        settledMessageId: payload.messageId
+        turnId
       };
       if (o.turnUsage) {
         body.usage = o.turnUsage;
@@ -9124,10 +9023,8 @@ ${reason}`,
       if (!o.okResult && o.resultReason && o.resultReason !== "cancelled" && !userCancelled && !o.leaseLost && !o.runtimeIncomplete && !this.skipState.skipped) {
         body.errorReason = o.resultReason.slice(0, 200);
       }
-      if (o.okResult) {
-        body.lastSeenMessageId = payload.messageId;
-      }
-      body.outcome = o.okResult ? "settled" : body.errorReason || o.runtimeIncomplete ? "failed" : "interrupted";
+      body.outcome = o.okResult ? committer.spoke ? "settled" : "passed" : body.errorReason || o.runtimeIncomplete ? "failed" : "interrupted";
+      if (body.outcome === "settled") body.lastMessageSeq = committer.lastMessageSeq;
       if (o.sessionDegraded) {
         body.degraded = true;
       }
@@ -9144,7 +9041,7 @@ ${reason}`,
         eventCounts: o.eventCounts,
         runtimeResultKind: o.runtimeResultKind,
         ...o.turnMcpInventory ? { mcpInventory: o.turnMcpInventory } : {},
-        finalSource: outcome === "skipped" || outcome === "cancelled" || o.silentMarkerEmitted ? "marker" : committer.finalSource
+        finalSource: outcome === "skipped" || outcome === "cancelled" || !committer.finalEmitted ? "none" : committer.finalSource
       };
       body.diagnostics = o.settledDiagnostics;
       if (diagnosticReason && !["usage_capped", "rate_limited", "auth_expired", "cancelled", "skipped"].includes(
@@ -9438,8 +9335,8 @@ var Outbox = class {
     this.enforceBounds();
   }
   // Every queued entry, oldest-first by `(enqueuedAt, turnId, seq)` so the
-  // drainer delivers `progress` before `final` within a turn and older turns
-  // before newer ones. Malformed files are dropped (logged) rather than
+  // drainer delivers a turn's rows in the order they were minted, and older
+  // turns before newer ones. Malformed files are dropped (logged) rather than
   // wedging the drain.
   list() {
     const dir2 = this.dir();
@@ -9465,8 +9362,9 @@ var Outbox = class {
         this.dropCorrupt(full);
       }
     }
+    const rank = (e) => e.kind === "active-run" ? 1 : 0;
     entries.sort(
-      (a, b) => a.enqueuedAt - b.enqueuedAt || (a.turnId < b.turnId ? -1 : a.turnId > b.turnId ? 1 : 0) || a.seq - b.seq
+      (a, b) => a.enqueuedAt - b.enqueuedAt || rank(a) - rank(b) || (a.turnId < b.turnId ? -1 : a.turnId > b.turnId ? 1 : 0) || a.seq - b.seq
     );
     return entries;
   }