@cabane/companion 0.6.79 → 0.6.82

package/dist/cli.js

@@ -1735,7 +1735,7 @@ function getLogger() {
 }
 
 // src/runtime.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/dashboard/server.ts
 import { dirname as dirname4, join as join7 } from "path";
@@ -2279,7 +2279,7 @@ async function warnAboutHarnessReadiness(cfg, deps = {}) {
 }
 
 // src/supervisor.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/api.ts
 var RETRY_BACKOFF_MS = [250, 750];
@@ -2459,14 +2459,14 @@ var CabaneApi = class {
     const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
-  // CT714: read a turn's recorded turn-control intent (ask/wake/send/skip). An
-  // EXTERNAL adapter (Codex / opencode) records its turn-control verbs into
-  // `turn_intents` server-side (the URL MCP surface) rather than the dispatcher's
-  // in-memory closures, so the dispatcher fetches this once at settle — by
-  // `turnId` — and populates those closures, letting the unchanged settle path
-  // materialize the effects identically to claude-code. Agent-PAT authed +
-  // self-scoped (`:agentId` must match the PAT's agent). A turn that recorded no
-  // control verb returns all-empty fields.
+  // 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
+  // closures, so the dispatcher fetches this once at settle — by `turnId` —
+  // and populates those closures, letting the unchanged settle path close the
+  // turn identically to claude-code. CT1354: those two verbs are all it
+  // carries now; the outgoing acts commit at the call (`turnAct`). Agent-PAT
+  // authed + self-scoped (`:agentId` must match the PAT's agent).
   getTurnIntent(workspaceId, conversationId, agentId, turnId) {
     const q = `turnId=${encodeURIComponent(turnId)}`;
     return this.request(
@@ -2474,6 +2474,27 @@ var CabaneApi = class {
       `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/turn-intent?${q}`
     );
   }
+  // CT1354: COMMIT ONE OUTGOING ACT of a running turn — a `send`, an `ask`, a
+  // `wake_me`, a `cancel_wake` — the moment the tool is called. The server
+  // runs `performTurnAct` inside the turn's write fence: the row is in the
+  // ledger when this resolves, and a 200 `ok: false` is the server's REFUSAL
+  // (an unknown target, a non-member, a wake outside its guardrails) for the
+  // tool to hand back as its error. 409 means the turn already settled.
+  //
+  // Bounded retry, on purpose: the act is a durable write whose loss strands a
+  // person or a peer, and `act.callId` — minted once per tool invocation by the
+  // caller — is what makes the retry safe: the server keys on `(turnId,
+  // callId)`, so an attempt that landed before the response was lost is
+  // replayed as the same row, never a second message. The caller's `signal`
+  // is the per-call deadline (the tool must answer the model, not hang it).
+  turnAct(workspaceId, turnId, act, signal) {
+    return this.request(
+      "POST",
+      `/api/workspaces/${workspaceId}/turns/${turnId}/acts`,
+      act,
+      signal ? { retry: true, signal } : { retry: true }
+    );
+  }
   // CT1292: RENEW THE TURN'S LEASE — ask the server whether this turn is still
   // running. The dispatcher calls this on a cadence for the life of the SDK loop,
   // and out of cadence the moment a commit is refused, so a loop whose turn was
@@ -5100,6 +5121,10 @@ async function* decodeOpencodeStream(events, ctx) {
       if (sealed) yield sealed;
       ok = false;
       const errorText = readSessionError(ev.properties);
+      const notice = errorText.trim().slice(0, 200).trimEnd();
+      if (notice && !/^[\w:-]+$/.test(notice)) {
+        yield { type: "runtime_notice", body: notice };
+      }
       const failure = classifyErrorText(errorText);
       reason = failure ? encodeFailureReason(failure) : `error:${errorText.slice(0, 200)}`;
       settled = true;
@@ -5509,6 +5534,7 @@ var opencodeAdapter = createOpencodeAdapter();
 // packages/agent-runtime/src/opencode/conformance.ts
 var ABORT_SENTINEL2 = { __abortHere: true };
 var NEW_SESSION_ID = "sess_new";
+var BOUNDED_NOTICE = "You've hit your usage limit \xB7 ".padEnd(200, "x");
 var COMPANION_POLICY = {
   hostFs: false,
   web: true,
@@ -5700,6 +5726,7 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
     expected: [
       sessionEvent2(NEW_SESSION_ID),
       { type: "text", body: "Partial work.", terminal: false },
+      { type: "runtime_notice", body: "provider exploded" },
       { type: "result", ok: false, reason: "error:provider exploded" }
     ]
   },
@@ -5716,7 +5743,11 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
         properties: { error: { name: "RateLimitError", message: "rate limit exceeded (429)" } }
       }
     ],
-    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "rate_limited" }]
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "RateLimitError: rate limit exceeded (429)" },
+      { type: "result", ok: false, reason: "rate_limited" }
+    ]
   },
   {
     // CT592: a subscription cap surfaced as text ("usage limit reached") → the cap
@@ -5730,7 +5761,11 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
         properties: { error: { name: "Error", message: "Claude usage limit reached" } }
       }
     ],
-    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "usage_capped" }]
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "Claude usage limit reached" },
+      { type: "result", ok: false, reason: "usage_capped" }
+    ]
   },
   {
     // CT592: a transient provider outage (5xx / overload) surfaced as text → the
@@ -5746,7 +5781,11 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
         }
       }
     ],
-    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "server_error" }]
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "AI_APICallError: overloaded_error (529)" },
+      { type: "result", ok: false, reason: "server_error" }
+    ]
   },
   {
     // CT558: an expired/invalid credential classifies as `auth_expired`.
@@ -5758,7 +5797,66 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
         properties: { error: { name: "AuthenticationError", message: "HTTP 401 Unauthorized" } }
       }
     ],
-    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "auth_expired" }]
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "AuthenticationError: HTTP 401 Unauthorized" },
+      { type: "result", ok: false, reason: "auth_expired" }
+    ]
+  },
+  {
+    // CT1351: an unclassified failure remains as informative as a classified one:
+    // its provider text is visible while the raw machine reason stays unchanged.
+    name: "unclassified failure keeps a runtime notice and raw reason",
+    request: makeRequest2(),
+    nativeStream: [errored("something local broke")],
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "something local broke" },
+      { type: "result", ok: false, reason: "error:something local broke" }
+    ]
+  },
+  {
+    name: "runtime notice is trimmed and bounded to 200 characters",
+    request: makeRequest2(),
+    nativeStream: [errored(`  ${BOUNDED_NOTICE}${"y".repeat(20)}  `)],
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: BOUNDED_NOTICE },
+      { type: "result", ok: false, reason: "usage_capped" }
+    ]
+  },
+  {
+    // CT1351: empty, whitespace-only, and bare status-token failures still set
+    // the machine reason but do not add an empty/unhelpful transcript notice.
+    name: "empty failure text emits no runtime notice",
+    request: makeRequest2(),
+    nativeStream: [errored("")],
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "result", ok: false, reason: "error:unknown" }
+    ]
+  },
+  {
+    name: "whitespace-only failure text emits no runtime notice",
+    request: makeRequest2(),
+    nativeStream: [errored("   ")],
+    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "error:   " }]
+  },
+  {
+    name: "bare status token emits no runtime notice",
+    request: makeRequest2(),
+    nativeStream: [errored("429")],
+    expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "rate_limited" }]
+  },
+  {
+    name: "single-word provider sentence emits a runtime notice",
+    request: makeRequest2(),
+    nativeStream: [errored("Unavailable.")],
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "runtime_notice", body: "Unavailable." },
+      { type: "result", ok: false, reason: "error:Unavailable." }
+    ]
   },
   {
     // CT1144: the same zero-content success the claude-code suite pins, in
@@ -6180,6 +6278,10 @@ async function* decodeCodexStream(events, ctx) {
       yield* flushInterim();
       ok = false;
       const text = readErrorMessage(ev);
+      const notice = text.trim().slice(0, 200).trimEnd();
+      if (notice && !/^[\w:-]+$/.test(notice)) {
+        yield { type: "runtime_notice", body: notice };
+      }
       const failure = classifyErrorText(text);
       reason = failure ? encodeFailureReason(failure) : `error:${text.slice(0, 200)}`;
       settled = true;
@@ -6498,6 +6600,7 @@ var codexAdapter = createCodexAdapter();
 // packages/agent-runtime/src/codex/conformance.ts
 var ABORT_SENTINEL3 = { __abortHere: true };
 var NEW_THREAD_ID = "th_new";
+var BOUNDED_NOTICE2 = "You've hit your usage limit \xB7 ".padEnd(200, "x");
 var COMPANION_POLICY2 = {
   hostFs: false,
   web: true,
@@ -7027,6 +7130,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
     expected: [
       sessionEvent3(NEW_THREAD_ID),
       { type: "text", body: "Partial work.", terminal: false },
+      { type: "runtime_notice", body: "provider exploded" },
       { type: "result", ok: false, reason: "error:provider exploded" }
     ]
   },
@@ -7043,6 +7147,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
     expected: [
       sessionEvent3(NEW_THREAD_ID),
       { type: "text", body: "Starting.", terminal: false },
+      { type: "runtime_notice", body: "stream died" },
       { type: "result", ok: false, reason: "error:stream died" }
     ]
   },
@@ -7055,25 +7160,47 @@ var CODEX_CONFORMANCE_FIXTURES = [
     name: "turn.failed 429 \u2192 rate_limited (throttle)",
     request: makeRequest3(),
     nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("429 Too Many Requests")],
-    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "rate_limited" }]
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: "429 Too Many Requests" },
+      { type: "result", ok: false, reason: "rate_limited" }
+    ]
   },
   {
     name: "turn.failed overload \u2192 server_error",
     request: makeRequest3(),
     nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("503 Service Unavailable")],
-    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "server_error" }]
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: "503 Service Unavailable" },
+      { type: "result", ok: false, reason: "server_error" }
+    ]
   },
   {
     name: "turn.failed usage cap \u2192 usage_capped",
     request: makeRequest3(),
-    nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("You have hit your usage limit")],
-    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "usage_capped" }]
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      turnFailed("You've hit your session limit \xB7 resets 8:20pm (UTC)")
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "runtime_notice",
+        body: "You've hit your session limit \xB7 resets 8:20pm (UTC)"
+      },
+      { type: "result", ok: false, reason: "usage_capped" }
+    ]
   },
   {
     name: "turn.failed auth \u2192 auth_expired",
     request: makeRequest3(),
     nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("401 Unauthorized: invalid api key")],
-    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "auth_expired" }]
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: "401 Unauthorized: invalid api key" },
+      { type: "result", ok: false, reason: "auth_expired" }
+    ]
   },
   {
     // CT592: a Codex failure text the classifier can't place still keeps today's
@@ -7083,9 +7210,53 @@ var CODEX_CONFORMANCE_FIXTURES = [
     nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("something local broke")],
     expected: [
       sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: "something local broke" },
       { type: "result", ok: false, reason: "error:something local broke" }
     ]
   },
+  {
+    name: "runtime notice is trimmed and bounded to 200 characters",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      turnFailed(`  ${BOUNDED_NOTICE2}${"y".repeat(20)}  `)
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: BOUNDED_NOTICE2 },
+      { type: "result", ok: false, reason: "usage_capped" }
+    ]
+  },
+  {
+    // CT1351: empty, whitespace-only, and bare status-token failures still set
+    // the machine reason but do not add an empty/unhelpful transcript notice.
+    name: "empty failure text emits no runtime notice",
+    request: makeRequest3(),
+    nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("")],
+    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "error:unknown" }]
+  },
+  {
+    name: "whitespace-only failure text emits no runtime notice",
+    request: makeRequest3(),
+    nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("   ")],
+    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "error:   " }]
+  },
+  {
+    name: "bare status token emits no runtime notice",
+    request: makeRequest3(),
+    nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("429")],
+    expected: [sessionEvent3(NEW_THREAD_ID), { type: "result", ok: false, reason: "rate_limited" }]
+  },
+  {
+    name: "single-word provider sentence emits a runtime notice",
+    request: makeRequest3(),
+    nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("Unavailable.")],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      { type: "runtime_notice", body: "Unavailable." },
+      { type: "result", ok: false, reason: "error:Unavailable." }
+    ]
+  },
   {
     // CT481: fail LOUD on unknown model metadata. An unknown `--model` makes Codex
     // emit an `error` item ("… Defaulting to fallback metadata …") and then go
@@ -7392,10 +7563,11 @@ import { existsSync as existsSync11, readdirSync as readdirSync2, statSync } fro
 import { join as join14 } from "path";
 
 // src/turn-execution.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
 
 // src/turn-control-tools.ts
+import { randomUUID } from "crypto";
 import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
 var SEND_TOOL = "send";
@@ -7411,89 +7583,83 @@ 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, order: null };
-}
-function createSendState() {
-  return { agentId: null, message: null, order: null };
-}
-function createTurnControlOrder() {
-  let calls = 0;
-  return {
-    next: () => {
-      calls += 1;
-      return calls;
-    }
-  };
+  return { answersMessageId: null };
 }
 function createSkipState() {
   return { skipped: false, reason: null };
 }
-function createAskState() {
-  return { targetUserId: null, question: null, headline: null, options: null, questions: null };
-}
-function createWakeState() {
-  return { afterSeconds: null, at: null, note: null, cancelled: false };
-}
 function resolveDeclaredReplyField(input) {
   const explicit = input.replyState.answersMessageId;
   if (explicit) return { answersMessageId: explicit };
   if (input.kind !== "final") return {};
   if (!input.owedReplyMessageId) return {};
-  const outwardSend = Boolean(
-    input.sendState.agentId && input.sendState.message && input.sendState.agentId !== input.agentId
-  );
-  const askRaised = Boolean(input.askState.targetUserId);
-  const wakeArmed = input.wakeState.afterSeconds !== null || input.wakeState.at !== null;
-  if (outwardSend || askRaised || wakeArmed) return {};
   return { answersMessageId: input.owedReplyMessageId, answersAutoDeclared: true };
 }
-function wakeCommitField(state) {
-  if (state.cancelled) return { wake: { cancel: true } };
-  const { afterSeconds, at, note } = state;
-  if (!note || afterSeconds === null && at === null) return {};
-  return {
-    wake: {
-      ...afterSeconds !== null ? { afterSeconds } : {},
-      ...at !== null ? { at } : {},
-      note
+function toolError(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+async function performAct(acts, act) {
+  let result;
+  try {
+    result = await acts.api.turnAct(
+      acts.workspaceId,
+      acts.turnId,
+      act,
+      AbortSignal.timeout(TURN_ACT_TIMEOUT_MS)
+    );
+  } catch (err) {
+    if (err instanceof ApiError) {
+      if (err.status === 409) {
+        return toolError(
+          "No active turn: this turn has already settled, so the act was not performed."
+        );
+      }
+      return toolError(`The act was refused (${err.status}): ${err.message}`);
     }
-  };
+    const message = err instanceof Error ? err.message : String(err);
+    return toolError(
+      `Cabane could not be reached (${message}), so it is UNKNOWN whether this act was recorded \u2014 it may have committed with only the response lost. Do NOT simply repeat the call: a repeat is a second, separate act, not a retry. Carry on, and say in your reply that you could not confirm it.`
+    );
+  }
+  if (!result.ok) return toolError(JSON.stringify(result));
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
 }
-function createTurnControlMcpServer(sendState, skipState, askState, wakeState, replyState, controlOrder) {
+function createTurnControlMcpServer(acts, skipState, replyState) {
+  const ACT_TOOL = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+  const CANCEL_TOOL = { ...ACT_TOOL, idempotentHint: true };
+  const RECORDER_TOOL = { readOnlyHint: true, openWorldHint: false };
   return createSdkMcpServer({
     name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
     tools: [
       tool(
         SEND_TOOL,
-        "Send one addressed message to another agent in THIS conversation. Pass the peer's `agentId` and the complete `message` they should act on; the server writes it separately from your terminal reply. Writing `@handle` in prose dispatches nobody. Single target \u2014 the last call wins. Sending to yourself is a no-op. 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.",
+        "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.",
         {
           agentId: z13.string().uuid().describe(
             "The peer agent to address \u2014 a workspace agent id, from your turn context's roster."
           ),
           message: z13.string().min(1).max(65536).describe("The complete new request the peer should receive and act on.")
         },
-        async (args) => {
-          sendState.agentId = args.agentId;
-          sendState.message = args.message;
-          sendState.order = controlOrder?.next() ?? null;
-          return {
-            content: [{ type: "text", text: JSON.stringify({ sent: args.agentId }) }]
-          };
-        },
-        { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
+        async (args) => performAct(acts, {
+          kind: "send",
+          callId: randomUUID(),
+          agentId: args.agentId,
+          message: args.message
+        }),
+        { annotations: ACT_TOOL, alwaysLoad: true }
       ),
       ...replyState ? [
         tool(
           REPLY_TO_TOOL,
-          "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, last call wins.",
+          "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.",
           {
             messageId: z13.string().uuid().describe("The owed ask message id from this turn context.")
           },
           async (args) => {
             replyState.answersMessageId = args.messageId;
-            replyState.order = controlOrder?.next() ?? null;
             return {
               content: [
                 {
@@ -7503,7 +7669,7 @@ function createTurnControlMcpServer(sendState, skipState, askState, wakeState, r
               ]
             };
           },
-          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
+          { annotations: RECORDER_TOOL, alwaysLoad: true }
         )
       ] : [],
       ...skipState ? [
@@ -7520,161 +7686,112 @@ function createTurnControlMcpServer(sendState, skipState, askState, wakeState, r
               content: [{ type: "text", text: JSON.stringify({ skipped: true }) }]
             };
           },
-          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
-        )
-      ] : [],
-      ...askState ? [
-        tool(
-          ASK_TOOL,
-          `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? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 \`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. An option can be a short button label or a whole sentence. Provide EITHER \`question\` (single) or \`questions\` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). The human sends ONE response: supplied answers are recorded, omissions become terminally Unanswered; later answers require a fresh ask. Ask only when blocked \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use send/dispatch instead.`,
-          {
-            targetUserId: z13.string().uuid().describe(
-              "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
-            ),
-            question: z13.string().min(1).max(400).optional().describe(
-              "SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (capped, inline markdown only). Provide EITHER this or `questions`, not both. Put the crisp one-sentence question in `headline`."
-            ),
-            headline: z13.string().min(1).max(120).optional().describe(
-              'SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in `?` ("Do we go to prod?"). What the human reads first in the inbox and the chip \u2014 one scannable question, no elaboration (that goes in `question`). Strongly encouraged.'
-            ),
-            options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
-            questions: z13.array(
-              z13.object({
-                headline: z13.string().min(1).max(120).describe(
-                  'The one-sentence question ("Do we go to prod?") \u2014 required for each item.'
-                ),
-                body: z13.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
-                options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
-              })
-            ).min(1).max(MAX_ASK_ITEMS).optional().describe(
-              `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`
-            )
-          },
-          async (args) => {
-            const hasSingle = args.question !== void 0;
-            const hasArray = args.questions !== void 0 && args.questions.length > 0;
-            if (hasSingle && hasArray) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Provide either `question` (single) or `questions` (array), not both."
-                  }
-                ]
-              };
-            }
-            if (!hasSingle && !hasArray) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Provide `question` (single) or `questions` (array)."
-                  }
-                ]
-              };
-            }
-            askState.targetUserId = args.targetUserId;
-            if (hasArray) {
-              askState.questions = args.questions;
-              askState.question = null;
-              askState.headline = null;
-              askState.options = null;
-            } else {
-              askState.question = args.question;
-              askState.headline = args.headline ?? null;
-              askState.options = args.options ?? null;
-              askState.questions = null;
-            }
-            return {
-              content: [
-                { type: "text", text: JSON.stringify({ asked: args.targetUserId }) }
-              ]
-            };
-          },
-          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
+          { annotations: RECORDER_TOOL, alwaysLoad: true }
         )
       ] : [],
-      ...wakeState ? [
-        tool(
-          WAKE_ME_TOOL,
-          "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 from a phrase like \"tomorrow morning\"; 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 is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; 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. If a wake can't be armed you're re-dispatched with a note explaining why \u2014 never a silent drop.",
-          {
-            afterSeconds: z13.number().int().positive().optional().describe(
-              "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
-            ),
-            at: z13.string().datetime({ offset: true }).optional().describe(
-              "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both."
-            ),
-            note: z13.string().min(1).max(2e3).describe(
-              'A note to your future self \u2014 becomes the body of the wake message that re-dispatches you. Write the condition to re-check ("check whether the PR merged").'
-            )
-          },
-          async (args) => {
-            const hasAfter = args.afterSeconds !== void 0;
-            const hasAt = args.at !== void 0;
-            if (hasAfter && hasAt) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Provide either `afterSeconds` (relative) or `at` (absolute), not both."
-                  }
-                ]
-              };
+      tool(
+        ASK_TOOL,
+        `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? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: 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 2\u20134 \`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. Provide EITHER \`question\` (single) or \`questions\` (array), never both. 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; a second call is a second question, not an edit. The human sends ONE response: supplied answers are recorded, omissions become terminally Unanswered. Ask only when blocked \u2014 never ceremonially. After asking, finish your reply and stop; when the person replies addressed to you, the ask resolves and you resume. Targets a human only; to hand work to another AGENT use send/dispatch instead.`,
+        {
+          targetUserId: z13.string().uuid().describe(
+            "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
+          ),
+          question: z13.string().min(1).max(400).optional().describe(
+            "SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (capped, inline markdown only). Provide EITHER this or `questions`, not both. Put the crisp one-sentence question in `headline`."
+          ),
+          headline: z13.string().min(1).max(120).optional().describe(
+            'SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in `?` ("Do we go to prod?"). What the human reads first in the inbox and the chip \u2014 one scannable question, no elaboration (that goes in `question`). Strongly encouraged.'
+          ),
+          options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
+          questions: z13.array(
+            z13.object({
+              headline: z13.string().min(1).max(120).describe(
+                'The one-sentence question ("Do we go to prod?") \u2014 required for each item.'
+              ),
+              body: z13.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
+              options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
+            })
+          ).min(1).max(MAX_ASK_ITEMS).optional().describe(
+            `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`
+          )
+        },
+        async (args) => {
+          const hasSingle = args.question !== void 0;
+          const hasArray = args.questions !== void 0 && args.questions.length > 0;
+          if (hasSingle && hasArray) {
+            return toolError(
+              "Provide either `question` (single) or `questions` (array), not both."
+            );
+          }
+          if (!hasSingle && !hasArray) {
+            return toolError("Provide `question` (single) or `questions` (array).");
+          }
+          return performAct(acts, {
+            kind: "ask",
+            callId: randomUUID(),
+            ask: hasArray ? {
+              targetUserId: args.targetUserId,
+              questions: args.questions.map((q) => ({
+                headline: q.headline,
+                ...q.body ? { body: q.body } : {},
+                ...q.options && q.options.length > 0 ? { options: q.options } : {}
+              }))
+            } : {
+              targetUserId: args.targetUserId,
+              question: args.question,
+              ...args.headline ? { headline: args.headline } : {},
+              ...args.options && args.options.length > 0 ? { options: args.options } : {}
             }
-            if (!hasAfter && !hasAt) {
-              return {
-                isError: true,
-                content: [{ type: "text", text: "Provide `afterSeconds` or `at`." }]
-              };
+          });
+        },
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      tool(
+        WAKE_ME_TOOL,
+        "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.",
+        {
+          afterSeconds: z13.number().int().positive().optional().describe(
+            "Relative delay in seconds from NOW \u2014 this call (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
+          ),
+          at: z13.string().datetime({ offset: true }).optional().describe(
+            "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both."
+          ),
+          note: z13.string().min(1).max(2e3).describe(
+            'A note to your future self \u2014 becomes the body of the wake message that re-dispatches you. Write the condition to re-check ("check whether the PR merged").'
+          )
+        },
+        async (args) => {
+          const hasAfter = args.afterSeconds !== void 0;
+          const hasAt = args.at !== void 0;
+          if (hasAfter && hasAt) {
+            return toolError(
+              "Provide either `afterSeconds` (relative) or `at` (absolute), not both."
+            );
+          }
+          if (!hasAfter && !hasAt) {
+            return toolError("Provide `afterSeconds` or `at`.");
+          }
+          return performAct(acts, {
+            kind: "wake",
+            callId: randomUUID(),
+            wake: {
+              ...hasAfter ? { afterSeconds: args.afterSeconds } : {},
+              ...hasAt ? { at: args.at } : {},
+              note: args.note
             }
-            wakeState.afterSeconds = args.afterSeconds ?? null;
-            wakeState.at = args.at ?? null;
-            wakeState.note = args.note;
-            wakeState.cancelled = false;
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    armed: hasAt ? { at: args.at } : { afterSeconds: args.afterSeconds },
-                    note: "Recorded. It arms when this turn ends \u2014 end your turn now; you'll be woken with this note."
-                  })
-                }
-              ]
-            };
-          },
-          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
-        ),
-        // CT990: the inverse. No arguments — it can only ever stand down the
-        // caller's own wake in the conversation it's holding a turn in.
-        tool(
-          CANCEL_WAKE_TOOL,
-          'Stand down your own wake \u2014 the inverse of `wake_me`. No arguments: it means "when this turn settles, leave no wake armed for me in this conversation." 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. It writes the same per-turn slot as `wake_me`, so the two are last-call-wins against each other: `cancel_wake` then `wake_me` leaves the NEW wake armed, `wake_me` then `cancel_wake` leaves nothing armed. Like `wake_me` it takes effect when the turn SETTLES, not now. It reaches only your own wake in this conversation \u2014 never a peer\'s, and never a recurring schedule (those are `schedules.*`).',
-          {},
-          async () => {
-            wakeState.cancelled = true;
-            wakeState.afterSeconds = null;
-            wakeState.at = null;
-            wakeState.note = null;
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    cancelled: true,
-                    note: "Recorded. Any wake you have armed in this conversation is stood down when this turn ends. If you had none, nothing happens."
-                  })
-                }
-              ]
-            };
-          },
-          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
-        )
-      ] : []
+          });
+        },
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      // CT990: the inverse. No arguments — it can only ever stand down the
+      // caller's own wake in the conversation it's holding a turn in.
+      tool(
+        CANCEL_WAKE_TOOL,
+        '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.*`).',
+        {},
+        async () => performAct(acts, { kind: "cancel_wake", callId: randomUUID() }),
+        { annotations: CANCEL_TOOL, alwaysLoad: true }
+      )
     ]
   });
 }
@@ -8101,107 +8218,25 @@ var TurnCommitter = class {
     return this.pump.finalEmitted;
   }
   // A closing textual reply and a wordless terminal marker carry the same
-  // per-turn control state. Keep this one projection so ask/wake/send cannot
-  // silently diverge when the agent ends without words. The KIND matters to
-  // exactly one field: 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.
+  // 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) {
-    const fields = {
-      ...this.answersField(kind),
-      ...this.sendField(),
-      ...this.askField(),
-      ...this.wakeField()
-    };
-    return { ...fields, ...this.orderField(fields) };
-  }
-  // CT1281: the order the control tools were CALLED, for the addressed rows the
-  // server writes from this one commit. It reports a position only for an intent
-  // that actually made it into the commit — a self-send the committer stripped
-  // contributes no row and so has no place in the line. An intent with no
-  // recorded call (the runtime's auto-declared reply) is deliberately absent, and
-  // the server sorts it after every recorded one — it binds the turn's closing
-  // words.
-  //
-  // The ask is absent by design, not by omission: its carrier queues last among
-  // the turn's rows however early the tool fired, so there is no position to
-  // report.
-  orderField(fields) {
-    const order = {};
-    const replyOrder = this.deps.replyState.order;
-    if (fields.answersMessageId !== void 0 && replyOrder !== null) order.reply = replyOrder;
-    if (fields.dispatch !== void 0 && this.deps.sendState.order !== null) {
-      order.send = this.deps.sendState.order;
-    }
-    return Object.keys(order).length > 0 ? { turnControlOrder: order } : {};
+    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 also opened a conversation (a fan-out is mid-arc). An explicit
-  // `reply_to` carries no flag and always stands.
+  // 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,
-      agentId: this.deps.agentId,
-      replyState: this.deps.replyState,
-      sendState: this.deps.sendState,
-      askState: this.deps.askState,
-      wakeState: this.deps.wakeState
+      replyState: this.deps.replyState
     });
   }
-  // Carry both halves of the addressed send. The server writes `dispatchBody`
-  // on a distinct message row; the turn row itself remains unaddressed speech.
-  sendField() {
-    const { agentId: target, message } = this.deps.sendState;
-    if (!target || !message || target === this.deps.agentId) return {};
-    return { dispatch: target, dispatchBody: message };
-  }
-  // CT326: resolve the per-turn ask into the `ask` field for a `final` commit.
-  // The server validates the target (must be a workspace member/owner) and
-  // creates the `asks` row; an absent/incomplete ask attaches nothing. Kept
-  // independent of `sendField` — a turn can send and ask independently.
-  askField() {
-    const { targetUserId, question, headline, options, questions } = this.deps.askState;
-    if (!targetUserId) return {};
-    if (questions && questions.length > 0) {
-      return {
-        ask: {
-          targetUserId,
-          questions: questions.map((q) => ({
-            headline: q.headline,
-            ...q.body ? { body: q.body } : {},
-            ...q.options && q.options.length > 0 ? { options: q.options } : {}
-          }))
-        }
-      };
-    }
-    if (!question) return {};
-    return {
-      ask: {
-        targetUserId,
-        question,
-        // CT400: the optional one-sentence headline question, when supplied.
-        ...headline ? { headline } : {},
-        ...options && options.length > 0 ? { options } : {}
-      }
-    };
-  }
-  // CT442: resolve the per-turn wake into the `wake` field for a `final` commit.
-  // The tool guarantees exactly one of `afterSeconds`/`at` is set once armed (both
-  // null = no wake this turn → attach nothing). The server computes `fire_at` and
-  // arms the CT441 schedule. Kept independent of send/ask — a turn could
-  // conceivably ask AND arm a wake.
-  //
-  // CT990: the field now carries three states, and the third can't be spelled by
-  // absence — attaching NOTHING means "leave the standing wake alone", which is
-  // exactly what a stand-down must not do. So a `cancel_wake` turn attaches the
-  // discriminated `{ cancel: true }` payload instead.
-  wakeField() {
-    return wakeCommitField(this.deps.wakeState);
-  }
 };
 
 // src/turn-execution.ts
@@ -8292,7 +8327,7 @@ var TurnExecution = class {
       agentId: payload.agentId,
       messageId: payload.messageId
     });
-    this.turnId = handleOpts.turnId ?? randomUUID();
+    this.turnId = handleOpts.turnId ?? randomUUID2();
   }
   opts;
   supervisor;
@@ -8312,12 +8347,8 @@ var TurnExecution = class {
   effectiveCwd;
   hookEnv;
   turnEnv;
-  sendState;
   skipState;
-  askState;
-  wakeState;
   replyState;
-  controlOrder;
   turnControlServer;
   request;
   adapter;
@@ -8487,7 +8518,7 @@ var TurnExecution = class {
         await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
           body: `${MISSING_SECRET_PREFIX} ${list}`,
           kind: "final",
-          turnId: randomUUID(),
+          turnId: randomUUID2(),
           // CT113: even a turn that fails before it runs answers a message.
           parentMessageId: payload.messageId
         });
@@ -8694,19 +8725,12 @@ ${reason}`,
   }
   buildRequest() {
     const { payload, workspaceId } = this;
-    const sendState = this.sendState = createSendState();
     const skipState = this.skipState = createSkipState();
-    const askState = this.askState = createAskState();
-    const wakeState = this.wakeState = createWakeState();
     const replyState = this.replyState = createReplyState();
-    const controlOrder = this.controlOrder = createTurnControlOrder();
     const turnControlServer = createTurnControlMcpServer(
-      sendState,
+      { api: this.opts.api, workspaceId, turnId: this.turnId },
       skipState,
-      askState,
-      wakeState,
-      replyState,
-      controlOrder
+      replyState
     );
     this.request = buildCompanionTurnRequest({
       turnContext: this.turnContext,
@@ -8808,16 +8832,6 @@ ${reason}`,
       signal: abortController.signal,
       log: turnLog,
       nextSeq: this.nextSeq,
-      // The committer reads this at commit to carry the addressed send on the
-      // terminal row; the server writes the send itself as a distinct message.
-      sendState: this.sendState,
-      // CT326: likewise the ask payload. CT1281: the server writes the ask as its
-      // own addressed message to the human — which ENQUEUES like any other send —
-      // and creates the `asks` row against that carrier, not against turn speech.
-      askState: this.askState,
-      // CT442: likewise the wake payload — attached to the `final` row so the
-      // server arms the wake schedule atomically with the reply it rode on.
-      wakeState: this.wakeState,
       replyState: this.replyState,
       // The ledger-derived owed reply, for the runtime's own declaration when
       // the agent doesn't call `reply_to` (resolveDeclaredReplyField).
@@ -8840,41 +8854,8 @@ ${reason}`,
           payload.agentId,
           turnId
         );
-        if (intent.ask) {
-          this.askState.targetUserId = intent.ask.targetUserId;
-          if (intent.ask.questions && intent.ask.questions.length > 0) {
-            this.askState.questions = intent.ask.questions;
-            this.askState.question = null;
-            this.askState.headline = null;
-            this.askState.options = null;
-          } else {
-            this.askState.question = intent.ask.question ?? null;
-            this.askState.headline = intent.ask.headline ?? null;
-            this.askState.options = intent.ask.options ?? null;
-            this.askState.questions = null;
-          }
-        }
-        if (intent.wake) {
-          if ("cancel" in intent.wake) {
-            this.wakeState.cancelled = true;
-            this.wakeState.afterSeconds = null;
-            this.wakeState.at = null;
-            this.wakeState.note = null;
-          } else {
-            this.wakeState.cancelled = false;
-            this.wakeState.afterSeconds = intent.wake.afterSeconds ?? null;
-            this.wakeState.at = intent.wake.at ?? null;
-            this.wakeState.note = intent.wake.note;
-          }
-        }
-        if (intent.sendAgentId && intent.sendBody) {
-          this.sendState.agentId = intent.sendAgentId;
-          this.sendState.message = intent.sendBody;
-          this.sendState.order = intent.sendOrder ?? null;
-        }
         if (intent.answersMessageId) {
           this.replyState.answersMessageId = intent.answersMessageId;
-          this.replyState.order = intent.replyOrder ?? null;
         }
         if (intent.skipped) {
           this.skipState.skipped = true;
@@ -8883,7 +8864,7 @@ ${reason}`,
       } catch (err) {
         turnLog.warn(
           { err: err instanceof Error ? err.message : String(err) },
-          "dispatcher: turn-control intent fetch failed; turn-control effects for this turn are dropped"
+          "dispatcher: turn-control intent fetch failed; the declared reply / skip for this turn are dropped"
         );
       }
     };
@@ -9026,15 +9007,13 @@ ${reason}`,
           { reason: this.skipState.reason, turnId, ok: o.okResult },
           "agent skipped turn (skip_turn)"
         );
-        const { wake: skipWake } = wakeCommitField(this.wakeState);
         try {
           await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
             body: SKIPPED_MARKER_BODY,
             kind: "skipped",
             turnId,
             seq: this.nextSeq(),
-            parentMessageId: payload.messageId,
-            ...skipWake ? { wake: skipWake } : {}
+            parentMessageId: payload.messageId
           });
         } catch (err) {
           turnLog.warn(
@@ -9052,9 +9031,9 @@ ${reason}`,
               turnId,
               seq: this.nextSeq(),
               parentMessageId: payload.messageId,
-              // ask, wake and send must survive a wordless turn exactly as
-              // they survive a textual final; dropping one can strand a person
-              // or the next actor with no visible failure.
+              // 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;
@@ -10366,7 +10345,7 @@ var CompanionSupervisor = class {
       );
     }
     const resumedTurnId = ev.id ? turnIdForEvent(workspaceId, ev.id) : null;
-    const turnId = resumedTurnId ?? randomUUID2();
+    const turnId = resumedTurnId ?? randomUUID3();
     if (ev.id) {
       const liveTurnIds = rememberTurnId(workspaceId, ev.id, turnId);
       if (liveTurnIds > TURN_ID_OVERFLOW_WARN) {
@@ -10774,7 +10753,7 @@ async function createCompanionRuntime(opts = {}) {
     opencodeServerUrl: cfg.opencode?.serverUrl,
     codex: isCodexEnabled(cfg)
   });
-  const instanceId = randomUUID3();
+  const instanceId = randomUUID4();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const pre = readLiveRuntimeState();
   if (pre && await verifyRuntime(pre) === "stale") clearRuntimeState();