fix(workflow): align engine with ant 2.1.150 (throttle, alias, serialize guard)

Three faithful-parity fixes to the workflow engine ported in 933da2a, found
by diffing against ant 2.1.150 (3886/3892/3904):

1. Throttle backoff (hooks.ts) — ant 3886 `aH`/`r6(45000)`. After the stall
   loop, detect a throttled/empty response: no stop_reason, no structured
   output, <50 output tokens, yet ran >half the stall window. Sleep 45s
   (abort-aware) and retry once. Without it a rate-limited workflow burns its
   hard-stall (180s) retries instead of cooling down. Threaded `stop_reason`
   through AgentExecResult to drive the predicate.

2. RunWorkflow alias (WorkflowTool.ts) — ant 3904 `gJ3` declares
   `aliases:["RunWorkflow"]`; ccb omitted it, so the model couldn't invoke the
   tool under that name.

3. Serializability guard (engine.ts) — ant 3892 `ZHK` calls `IH(M)`
   (JSON.stringify) on the cloned result before returning. ccb's
   structuredCloneSafe falls back to the raw value for non-cloneable inputs, so
   a non-serializable result would leak into the task notification. Re-assert
   JSON.stringify(cloned) so it surfaces as a workflow error instead.

Two ant divergences left as documented staged-gaps (not regressions): the
named-workflow registry (.claude/workflows/ loader + builtin merge — ccb marks
it "wired in P5") and worktree-isolation agent spawning (ccb's
`isolation:'worktree'` is currently a progress-event field only; ant serializes
real worktree creation via an ElH(1) semaphore — full worktree creation +
cleanup is a self-contained follow-up, not half-implemented here).

Author: Icarus603

packages/agent/workflow/engine.ts

@@ -90,6 +90,12 @@ export async function runWorkflow(
     // Deep-clone the result out of the vm realm so host-side consumers don't
     // hold references into the (frozen) sandbox.
     const cloned = structuredCloneSafe(result)
+    // ant 3892 ZHK calls `IH(M)` (= JSON.stringify) on the cloned result before
+    // returning — a serializability guard. structuredCloneSafe can fall back to
+    // the raw value for non-cloneable inputs, so re-assert here: a result that
+    // can't serialize must surface as a workflow error (caught below), not leak
+    // a non-JSON value into the task notification.
+    JSON.stringify(cloned)
     return {
       result: cloned,
       agentCount: hooks.getAgentCount(),

packages/agent/workflow/hooks.ts

@@ -120,6 +120,33 @@ type AgentExecResult = {
   skipped: boolean
   durationMs: number
   outputTokens?: number
+  // Last assistant message's stop_reason — null when the turn ended without
+  // one (the throttle signal: ant 3886 `aH` treats stopReason==null + tiny
+  // output + long duration as a throttled/empty response).
+  stopReason?: string | null
+}
+
+/**
+ * Abort-aware sleep — ant 3886 `r6(ms, signal, {throwOnAbort:true})`. Resolves
+ * after `ms`, or rejects immediately if `signal` aborts (so a workflow abort
+ * during the throttle cooldown propagates instead of waiting out the 45s).
+ */
+function sleepAbortable(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error('Workflow aborted'))
+      return
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort)
+      resolve()
+    }, ms)
+    const onAbort = (): void => {
+      clearTimeout(timer)
+      reject(new Error('Workflow aborted'))
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
 }
 
 /**
@@ -404,6 +431,44 @@ export function createWorkflowHooks(
       )
     }
 
+    // Throttle backoff — ant 3886 `aH`/`r6(45000)`. A turn with no stop_reason,
+    // no structured output, <50 output tokens, yet running >half the stall
+    // window is a rate-limited/empty response, not real work. Sleep 45s + retry
+    // once (ant parity); without it a throttled workflow burns the hard-stall
+    // (180s) retries instead of cooling down.
+    const isThrottled = (r: AgentExecResult): boolean =>
+      !r.stalled &&
+      !r.skipped &&
+      (r.stopReason == null) &&
+      r.structured === undefined &&
+      (r.outputTokens ?? Infinity) < 50 &&
+      r.durationMs > stallMs * 0.5
+    if (isThrottled(res)) {
+      log(
+        `[throttle] agent "${label}" throttled response (no stop_reason, ${res.outputTokens ?? '?'} output tokens in ${Math.round(res.durationMs / 1000)}s) — sleeping 45s before retry`,
+      )
+      await sleepAbortable(45_000, abortSignal)
+      res = await runWithStall(
+        index,
+        prompt,
+        `${label} (throttle-retry)`,
+        phaseTitle,
+        phaseIndex,
+        stallMs,
+        opts,
+        agentDef,
+        availableTools,
+        !!schemaTool,
+        onAgentId,
+        res.durationMs,
+      )
+      if (isThrottled(res)) {
+        log(
+          `[throttle] agent "${label}" still throttled after retry — continuing with partial result`,
+        )
+      }
+    }
+
     if (res.skipped) return null
     if (res.stalled) {
       throw new Error(
@@ -445,6 +510,7 @@ export function createWorkflowHooks(
     let structured: unknown
     let lastText = ''
     let outputTokens: number | undefined
+    let stopReason: string | null = null
 
     const model = opts?.model ?? toolUseContext.options.mainLoopModel
     const emit = (
@@ -533,6 +599,7 @@ export function createWorkflowHooks(
             message: {
               content: Array<{ type: string; text?: string; name?: string }>
               usage?: { output_tokens?: number }
+              stop_reason?: string | null
             }
           }
           let textPart = ''
@@ -543,6 +610,7 @@ export function createWorkflowHooks(
           }
           if (textPart) lastText = textPart
           toolCalls += calls
+          stopReason = am.message.stop_reason ?? null
           outputTokens = am.message.usage?.output_tokens ?? outputTokens
           if (typeof outputTokens === 'number') tokens = outputTokens
           if (calls > 0) {
@@ -616,6 +684,7 @@ export function createWorkflowHooks(
       skipped: false,
       durationMs,
       outputTokens,
+      stopReason,
     }
   }
 

packages/tool-registry/src/tools/WorkflowTool/WorkflowTool.ts

@@ -118,6 +118,9 @@ async function resolveScript(input: {
 export const WorkflowTool = buildTool({
   isMcp: false,
   name: WORKFLOW_TOOL_NAME,
+  // ant 3904.js gJ3: `aliases:["RunWorkflow"]` — the model may invoke the tool
+  // under either name.
+  aliases: ['RunWorkflow'],
   searchHint: 'orchestrate subagents with a deterministic JavaScript workflow',
   maxResultSizeChars: 100_000,
   isEnabled() {