@letta-ai/letta-code 0.33.3 → 0.33.5

package/letta.js

@@ -5653,7 +5653,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.33.3",
+    version: "0.33.5",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -5785,7 +5785,7 @@ var init_package = __esm(() => {
     dependencies: {
       "@earendil-works/pi-ai": "^0.87.1",
       "@janhapke/sharp-electron": "0.35.3-electron.1",
-      "@letta-ai/letta-agent-sdk": "^0.8.17",
+      "@letta-ai/letta-agent-sdk": "0.8.21",
       "@letta-ai/letta-client": "^1.10.2",
       "@letta-ai/trajectory": "0.2.0",
       "@modelcontextprotocol/sdk": "1.30.0",
@@ -111416,7 +111416,6 @@ var init_names = __esm(() => {
     "Songbird",
     "Slider",
     "Aguilar",
-    "Dogmeat",
     "Codsworth",
     "Nick Valentine",
     "Yes Man",
@@ -187644,7 +187643,7 @@ function getSubagentByToolCallId(toolCallId) {
   }
   return;
 }
-function registerSubagent(id2, type3, description, toolCallId, isBackground, silent, parentScope, prompt) {
+function registerSubagent(id2, type3, description, toolCallId, isBackground, silent, parentScope, prompt, claimsParentRuntime) {
   const displayType = type3.charAt(0).toUpperCase() + type3.slice(1);
   const agent = {
     id: id2,
@@ -187661,6 +187660,7 @@ function registerSubagent(id2, type3, description, toolCallId, isBackground, sil
     startTime: Date.now(),
     toolCallId,
     isBackground,
+    claimsParentRuntime,
     silent,
     parentAgentId: parentScope?.agentId ?? undefined,
     parentConversationId: parentScope?.conversationId && parentScope.conversationId.length > 0 ? parentScope.conversationId : undefined
@@ -188768,9 +188768,7 @@ function enqueueOutboundFrame(transport, frame) {
   if (frame.frameClass === "status" && frame.coalesceKey) {
     const index = state.frames.findIndex((f4) => f4.frameClass === "status" && f4.coalesceKey === frame.coalesceKey);
     if (index !== -1) {
-      state.frames[index] = frame;
-      drainOutboundQueue(transport, state);
-      return;
+      state.frames.splice(index, 1);
     }
   }
   state.frames.push(frame);
@@ -189196,6 +189194,9 @@ function createTurnCorrelation(runtime, message, batchId) {
     }
   }
   return {
+    get clientMessageIds() {
+      return [...clientMessageIds];
+    },
     appendDequeuedBatch(nextBatchId) {
       for (const clientMessageId of takeDequeuedClientMessageIds(runtime, nextBatchId)) {
         clientMessageIds.add(clientMessageId);
@@ -189241,7 +189242,6 @@ __export(exports_protocol_outbound, {
   emitProtocolV2Message: () => emitProtocolV2Message,
   emitLoopStatusUpdate: () => emitLoopStatusUpdate,
   emitLoopStatusIfOpen: () => emitLoopStatusIfOpen,
-  emitLoopErrorDelta: () => emitLoopErrorDelta,
   emitInterruptedStatusDelta: () => emitInterruptedStatusDelta,
   emitDeviceStatusUpdateIfChanged: () => emitDeviceStatusUpdateIfChanged,
   emitDeviceStatusUpdate: () => emitDeviceStatusUpdate,
@@ -189688,8 +189688,10 @@ function buildSubagentSnapshot(runtime, scope) {
     status: a2.status,
     agent_url: a2.agentURL,
     conversation_id: a2.conversationId ?? null,
+    super_run_id: a2.superRunId,
     model: a2.model,
     is_background: a2.isBackground,
+    claims_parent_runtime: a2.claimsParentRuntime,
     silent: a2.silent,
     tool_call_id: a2.toolCallId,
     parent_agent_id: a2.parentAgentId,
@@ -189726,18 +189728,6 @@ function createLifecycleMessageBase(messageType, runId) {
 function emitCanonicalMessageDelta(socket, runtime, delta2, scope) {
   emitStreamDelta(socket, runtime, delta2, scope);
 }
-function emitLoopErrorDelta(socket, runtime, params) {
-  emitCanonicalMessageDelta(socket, runtime, {
-    ...createLifecycleMessageBase("loop_error", params.runId),
-    message: params.message,
-    stop_reason: params.stopReason,
-    is_terminal: params.isTerminal,
-    ...params.apiError ? { api_error: params.apiError } : {}
-  }, {
-    agent_id: params.agentId,
-    conversation_id: params.conversationId
-  });
-}
 function emitRetryDelta(socket, runtime, params) {
   const delta2 = {
     ...createLifecycleMessageBase("retry", params.runId),
@@ -203027,40 +203017,31 @@ Pass a URL ending at the PR number, such as \`https://github.com/owner/repo/pull
 var init_WatchPR = () => {};
 
 // src/tools/descriptions/Workflow.md
-var Workflow_default = `Execute a workflow script that orchestrates multiple subagents deterministically. Use for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.
-
-Workflows run in the background — this tool validates the script and returns immediately with a task ID (\`workflow_N\`) and output file path; a <task-notification> arrives when the workflow completes, carrying the script's return value. Do not poll or sleep for it: keep working or end your turn, and never fabricate the result before the notification arrives. Read the output file only when you need interim progress; TaskStop aborts the run.
+var Workflow_default = `Execute a workflow script that orchestrates multiple subagents deterministically (loops, conditionals, fan-out) rather than model-driven.
 
-ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of subagent sessions and cost real money; the user must request that scale, not have it inferred. Explicit opt-in means: the user directly asked for a workflow or multi-agent orchestration in their own words ("use a workflow", "fan out agents", "orchestrate this with subagents"), asked for a comprehensive audit/sweep at a scale that plainly requires it, or invoked a skill whose instructions call this tool. For any other task — even one that would benefit from parallelism — describe what a workflow could do and ask first.
+Workflows run in the background: this tool returns immediately with a task ID, and a <task-notification> carrying the script's return value arrives when the workflow completes. Do not poll or sleep for it, and never fabricate the result before it arrives. TaskStop aborts the run.
 
-Every script must begin with \`export const meta = {...}\`: a PURE LITERAL (no variables, calls, or interpolation) giving the workflow's \`name\` (kebab-case), a one-line \`description\`, and optionally \`phases\` — one \`{ title, detail? }\` per phase() call. Scripts are plain JavaScript, not TypeScript. The script runs in the CLI process with the CLI's privileges and the user approves it by reading it, so keep it to orchestration (deciding what runs, combining results); reading, searching, and writing belong in subagents, where the tool allowlist applies.
+ONLY call this tool when the user has explicitly opted into multi-agent orchestration — they asked for a workflow or multi-agent orchestration in their own words ("use a workflow", "fan out agents"), or invoked a skill whose instructions call this tool. Workflows can spawn many subagents and cost real money. For any other task, even one that would benefit from parallelism, describe what a workflow could do and ask first.
 
-The canonical multi-stage pattern — pipeline by default, each item verifies as soon as its review completes:
+Scripts are plain JavaScript and must begin with \`export const meta = {...}\`, a pure literal (no variables, calls, or interpolation). Pass the work list via \`args\`. Prefer \`pipeline()\` so each item moves to its next stage as soon as it is ready; \`agent()\` resolves to \`null\` on failure, so guard and filter:
 
   export const meta = {
-    name: 'review-changes',
-    description: 'Review changed files across dimensions, verify each finding',
+    name: 'review-files',
+    description: 'Review each file for bugs, verify each finding',
     phases: [{ title: 'Review' }, { title: 'Verify' }],
   }
-  const DIMENSIONS = [{key: 'bugs', prompt: '...'}, {key: 'perf', prompt: '...'}]
-  const findingsSchema = {type: 'object', properties: {findings: {type: 'array', items: {type: 'object', properties: {file: {type: 'string'}, summary: {type: 'string'}}, required: ['file', 'summary']}}}, required: ['findings']}
-  const verdictSchema = {type: 'object', properties: {real: {type: 'boolean'}, why: {type: 'string'}}, required: ['real', 'why']}
+  const findings = {type: 'object', properties: {bugs: {type: 'array', items: {type: 'string'}}}, required: ['bugs']}
+  const verdict = {type: 'object', properties: {real: {type: 'boolean'}}, required: ['real']}
   const results = await pipeline(
-    DIMENSIONS,
-    d => agent(d.prompt, {label: \`review:\${d.key}\`, phase: 'Review', schema: findingsSchema}),
-    review => review ? parallel(review.findings.map(f => () =>
-      agent(\`Adversarially verify: \${f.summary}\`, {label: \`verify:\${f.file}\`, phase: 'Verify', schema: verdictSchema})
-        .then(v => ({...f, verdict: v})))) : []
+    args.files,
+    f => agent(\`Review \${f} for bugs.\`, { phase: 'Review', schema: findings }),
+    (review, f) => parallel((review?.bugs ?? []).map(bug => () =>
+      agent(\`Is this a real bug in \${f}? \${bug}\`, { phase: 'Verify', schema: verdict })
+        .then(v => v?.real ? { file: f, bug } : null))),
   )
-  return { confirmed: results.filter(Boolean).flat().filter(Boolean).filter(f => f.verdict?.real) }
-
-Script hooks: agent(prompt, opts?) spawns one subagent and resolves to final text. Prefer opts.schema (JSON Schema) for a validated object; invalid/missing results retry and then resolve to null with the validation error in the journal. opts.json still parses without validating; schema wins if both are supplied. Options: label, phase, schema, json, model, effort, allowedTools, systemPrompt, timeoutMs, maxToolCalls. pipeline(items, ...stages) runs each item through all stages independently with NO barrier between stages; each stage receives (prevResult, originalItem, index); a throwing stage drops that item to null. parallel(thunks) runs zero-arg functions concurrently and IS a barrier — use only when a stage genuinely needs all prior results together. phase(title) groups subsequent agents in progress output (inside concurrent stages use opts.phase instead — the global phase races). log(message) emits a progress line. args is the invocation's args input, verbatim.
+  return results.filter(Boolean).flat().filter(Boolean)
 
-Subagents run in isolated agent-free ephemeral conversations with read-only tools by default (Read, Grep, Glob) and no access to your memory or conversation — put ALL context they need in the prompt. Their model defaults to the invoking conversation's model; opts.model or the tool's model input accept any handle or alias from \`letta model list\`. They are told their final text IS the return value, so they return raw data. Concurrency is capped (excess agent() calls queue); a lifetime cap of 1000 agents per run is the runaway-loop backstop. Each subagent is also guarded: a 10-minute default timeout (override with opts.timeoutMs), at most 1000 unique tool calls by default (override with the positive safe integer opts.maxToolCalls), and a stop after three identical consecutive tool calls — a guarded call resolves to null and the journal records which guard fired.
-
-Every run persists its script and a journal of each subagent's outcome under ~/.letta/workflows/executions/<id>/ (the paths are in the tool result). Before diagnosing an empty or unexpected result, read that run's journal.jsonl; it records each agent's actual return value. Workflow subagents require the API backend.
-
-Before authoring a script, load the \`workflow-authoring\` skill — the workflow authoring reference: script API and gotchas, pipeline-vs-barrier rules, quality patterns (adversarial verify, judge panel, loop-until-dry), and worked examples.
+Before authoring a script, load the \`workflow-authoring\` skill — the script API, pipeline-vs-barrier rules, quality patterns, worked examples, and how to diagnose a run.
 `;
 var init_Workflow = () => {};
 
@@ -212179,6 +212160,9 @@ async function listEnqueuedRunMessages(runId, signal) {
   }
   return result2;
 }
+async function getExactSuperRun(agentId, superRunId, signal, request = apiRequest) {
+  return request("GET", `/v1/agents/${encodeURIComponent(agentId)}/super-runs/${encodeURIComponent(superRunId)}`, undefined, { signal });
+}
 async function getLatestConversationSuperRun(conversationId, signal) {
   return apiRequest("GET", `/v1/conversations/${encodeURIComponent(conversationId)}/super-run`, undefined, { signal });
 }
@@ -212189,212 +212173,93 @@ var init_conversation_enqueue = __esm(() => {
   init_request();
 });
 
-// src/headless-enqueue-wait.ts
-function getSendRunIds(status, clientMessageId) {
-  return Object.entries(status?.runtime_status?.loop_state?.client_message_ids_by_run_id ?? {}).filter(([, ids]) => ids.includes(clientMessageId)).map(([runId]) => runId);
-}
-function getConversationStatus(event, conversationId) {
-  if (event.type === "conversation_super_run_snapshot") {
-    return event.statuses.find((status) => status.conversation_id === conversationId) ?? null;
+// src/headless-super-run-wait.ts
+import { setTimeout as delay3 } from "node:timers/promises";
+function isTransientReadError(error4) {
+  if (error4 instanceof ApiRequestError || error4 instanceof APIError) {
+    return error4.status === 408 || error4.status === 429 || error4.status >= 500;
   }
-  return event.conversation_id === conversationId ? event.status : undefined;
+  return error4 instanceof TypeError || error4 instanceof Error && error4.name === "TimeoutError";
 }
-async function waitForEnqueuedReply(params) {
-  const runIds = new Set;
-  const now2 = params.now ?? Date.now;
-  let completedWithoutText;
-  let next = Promise.resolve({
-    done: false,
-    value: params.firstEvent
-  });
-  try {
-    while (true) {
-      params.signal.throwIfAborted();
-      let timer;
-      const event = await Promise.race([
-        next,
-        new Promise((resolve29) => {
-          timer = setTimeout(() => resolve29(null), params.pollMs ?? 1000);
-        })
-      ]).finally(() => clearTimeout(timer));
-      if (event) {
-        if (event.done)
-          throw new Error("Conversation status connection closed; remote execution may still be running.");
-        const status = getConversationStatus(event.value, params.receipt.conversation_id);
-        if (status !== undefined) {
-          for (const runId2 of getSendRunIds(status, params.receipt.client_message_id))
-            runIds.add(runId2);
-        }
-        next = params.events.next();
-        next.catch(() => {});
-      }
-      const runId = [...runIds].at(-1);
-      if (!runId) {
-        const latest = await params.latestSuperRun();
-        if (latest?.id === params.receipt.super_run_id && (latest.errored_at || latest.cancelled_at)) {
-          throw new Error(`Accepted send ${latest.id} ${latest.errored_at ? "failed" : "was cancelled"} before a run was observed.`);
-        }
-        continue;
-      }
-      const run = await params.retrieveRun(runId);
-      if (run.status === "failed" || run.status === "cancelled") {
-        throw new Error(`Remote run ${runId} ${run.status}${run.stop_reason ? ` (${run.stop_reason})` : ""}`);
-      }
-      if (run.status !== "completed" || run.stop_reason === "requires_approval")
-        continue;
-      const messages = await params.listRunMessages(runId);
-      const assistant = messages.filter((message) => message.message_type === "assistant_message").sort((a2, b3) => (b3.seq_id ?? 0) - (a2.seq_id ?? 0))[0];
-      if (assistant?.message_type === "assistant_message") {
-        const text2 = typeof assistant.content === "string" ? assistant.content : assistant.content.filter((part) => part.type === "text").map((part) => part.text).join(`
-`);
-        if (text2.trim())
-          return {
-            text: text2,
-            runIds: [...runIds],
-            stopReason: run.stop_reason ?? null
-          };
+async function retryRead(read2, signal, sleep11, failureLabel) {
+  let failures = 0;
+  while (true) {
+    signal.throwIfAborted();
+    try {
+      return await read2();
+    } catch (error4) {
+      signal.throwIfAborted();
+      if (!isTransientReadError(error4)) {
+        throw new RemoteExecutionFailed(`${failureLabel}: ${error4 instanceof Error ? error4.message : String(error4)}`);
       }
-      if (completedWithoutText?.runId !== runId)
-        completedWithoutText = { runId, at: now2() };
-      if (now2() - completedWithoutText.at < 15000)
-        continue;
-      throw new Error(`Remote run ${runId} completed without an assistant reply (${run.stop_reason ?? "unknown stop reason"})`);
+      await sleep11(Math.min(30000, 1000 * 2 ** Math.min(failures++, 5)), signal);
     }
-  } catch (error4) {
-    throw new EnqueuedWaitError(error4, [...runIds]);
   }
 }
-var EnqueuedWaitError;
-var init_headless_enqueue_wait = __esm(() => {
-  EnqueuedWaitError = class EnqueuedWaitError extends Error {
-    runIds;
-    constructor(error4, runIds) {
-      super(error4 instanceof Error ? error4.message : String(error4), {
-        cause: error4
-      });
-      this.runIds = runIds;
-      this.name = "EnqueuedWaitError";
-    }
-  };
-});
-
-// src/headless-super-run-wait.ts
-import { setTimeout as delay3 } from "node:timers/promises";
-function terminal(run) {
-  if (run.status === "CAN" || run.cancelled_at)
+function throwIfSuperRunFailed(run) {
+  if (run.errored_at) {
+    const detail = run.error ? ` during ${run.error.code}: ${run.error.message}` : "";
+    throw new RemoteExecutionFailed(`Remote Super Run ${run.id} failed${detail}`);
+  }
+  if (run.status === "CAN" || run.cancelled_at) {
     throw new RemoteExecutionFailed(`Remote Super Run ${run.id} was cancelled.`);
-  if (run.status !== "COM" && !run.completed_at)
-    return false;
-  if (run.errored_at)
-    throw new RemoteExecutionFailed(`Remote Super Run ${run.id} finished with an error.`);
-  return true;
+  }
+}
+function assistantText(messages) {
+  const assistant = messages.filter((message) => message.message_type === "assistant_message").sort((left, right) => (right.seq_id ?? 0) - (left.seq_id ?? 0))[0];
+  if (assistant?.message_type !== "assistant_message")
+    return null;
+  const text2 = typeof assistant.content === "string" ? assistant.content : assistant.content.filter((part) => part.type === "text").map((part) => part.text).join(`
+`);
+  return text2.trim() ? text2 : null;
+}
+function noReplyMessage(receipt) {
+  return `Remote task finished. Its reply was not collected. Read the conversation with: letta messages list --agent ${receipt.agent_id} --conversation ${receipt.conversation_id}. Do not launch the task again to retrieve its result.`;
 }
 async function waitForAcceptedSuperRun(receipt, signal, deps) {
-  const runIds = new Set;
-  let finished2 = false;
-  let failures = 0;
-  while (!finished2) {
+  const pollMs = deps.pollMs ?? 1000;
+  const sleep11 = deps.sleep ?? ((ms, waitSignal) => delay3(ms, undefined, { signal: waitSignal }));
+  while (true) {
     signal.throwIfAborted();
-    const controller = new AbortController;
-    const abort = () => controller.abort();
-    signal.addEventListener("abort", abort, { once: true });
-    try {
-      if (receipt.conversation_id !== "default") {
-        try {
-          const latest = await deps.latest(receipt.conversation_id, AbortSignal.any([signal, AbortSignal.timeout(30000)]));
-          if (latest.id === receipt.super_run_id)
-            finished2 = terminal(latest);
-        } catch (error4) {
-          if (!(error4 instanceof ApiRequestError && error4.status === 404))
-            throw error4;
-        }
-      }
-      if (finished2)
-        break;
-      const openTimeout = setTimeout(() => controller.abort(), 30000);
-      const stream11 = await deps.open(receipt.agent_id, controller).finally(() => clearTimeout(openTimeout));
-      const events = stream11[Symbol.asyncIterator]();
-      let next = events.next();
-      next.catch(() => {});
-      while (!finished2) {
-        signal.throwIfAborted();
-        let timer;
-        const event = await Promise.race([
-          next,
-          new Promise((resolve29) => {
-            timer = setTimeout(() => resolve29(null), deps.pollMs ?? 30000);
-          })
-        ]).finally(() => clearTimeout(timer));
-        if (!event)
-          break;
-        if (event.done)
-          throw new Error("Cloud status stream disconnected");
-        failures = 0;
-        const value = event.value;
-        if (value.type === "super_run_update") {
-          if (value.data.id === receipt.super_run_id)
-            finished2 = terminal(value.data);
-        } else {
-          const status = getConversationStatus(value, receipt.conversation_id);
-          if (status !== undefined) {
-            for (const id2 of getSendRunIds(status, receipt.client_message_id))
-              runIds.add(id2);
-            finished2 = !status?.active_super_runs.some((run) => run.id === receipt.super_run_id);
-          }
-        }
-        if (!finished2) {
-          next = events.next();
-          next.catch(() => {});
-        }
-      }
-    } catch (error4) {
-      signal.throwIfAborted();
-      if (error4 instanceof RemoteExecutionFailed)
-        throw error4;
-      if (error4 instanceof ApiRequestError && [401, 403].includes(error4.status))
-        throw error4;
-      await delay3(Math.min(30000, (deps.pollMs ?? 1000) * 2 ** Math.min(failures++, 5)), undefined, { signal });
-    } finally {
-      signal.removeEventListener("abort", abort);
-      controller.abort();
+    const exact = await retryRead(() => deps.exact(receipt.agent_id, receipt.super_run_id, AbortSignal.any([signal, AbortSignal.timeout(30000)])), signal, sleep11, `Cloud status read for accepted Super Run ${receipt.super_run_id} failed`);
+    if (exact.id !== receipt.super_run_id) {
+      throw new RemoteExecutionFailed(`Exact Super Run read returned ${exact.id} for ${receipt.super_run_id}.`);
+    }
+    throwIfSuperRunFailed(exact);
+    const terminal = exact.status === "COM" || exact.completed_at !== null;
+    if (!terminal) {
+      await sleep11(pollMs, signal);
+      continue;
     }
-  }
-  if (receipt.conversation_id !== "default") {
-    try {
-      const latest = await deps.latest(receipt.conversation_id, AbortSignal.any([signal, AbortSignal.timeout(1e4)]));
-      if (latest.id === receipt.super_run_id)
-        terminal(latest);
-    } catch (error4) {
-      signal.throwIfAborted();
-      if (error4 instanceof RemoteExecutionFailed)
-        throw error4;
+    const runId = exact.run_ids[0];
+    if (!runId) {
+      throw new RemoteExecutionFailed(`Remote Super Run ${exact.id} completed without a correlated child run.`);
     }
-  }
-  const runId = [...runIds].at(-1);
-  if (runId) {
+    const run = await retryRead(() => deps.run(runId, AbortSignal.any([signal, AbortSignal.timeout(30000)])), signal, sleep11, `Remote child run read for ${runId} failed`);
+    if (run.status === "failed" || run.status === "cancelled") {
+      throw new RemoteExecutionFailed(`Remote child run ${runId} ${run.status}${run.stop_reason ? ` (${run.stop_reason})` : ""}.`);
+    }
+    if (run.status !== "completed" || run.stop_reason === "requires_approval") {
+      await sleep11(pollMs, signal);
+      continue;
+    }
+    let messages = [];
     try {
-      const messages = await deps.messages(runId, AbortSignal.any([signal, AbortSignal.timeout(1e4)]));
-      const last2 = messages.filter((m4) => m4.message_type === "assistant_message").sort((a2, b3) => (b3.seq_id ?? 0) - (a2.seq_id ?? 0))[0];
-      if (last2?.message_type === "assistant_message") {
-        const text2 = typeof last2.content === "string" ? last2.content : last2.content.filter((p2) => p2.type === "text").map((p2) => p2.text).join(`
-`);
-        if (text2.trim())
-          return { text: text2, runIds: [...runIds], stopReason: null };
-      }
+      messages = await deps.messages(runId, AbortSignal.any([signal, AbortSignal.timeout(1e4)]));
     } catch {
       signal.throwIfAborted();
     }
+    return {
+      text: assistantText(messages) ?? noReplyMessage(receipt),
+      runIds: exact.run_ids,
+      stopReason: run.stop_reason ?? null
+    };
   }
-  return {
-    text: `Remote task finished. Its reply was not collected. Read the conversation with: letta messages list --agent ${receipt.agent_id} --conversation ${receipt.conversation_id}. Do not launch the task again to retrieve its result.`,
-    runIds: [...runIds],
-    stopReason: null
-  };
 }
 var RemoteExecutionFailed;
 var init_headless_super_run_wait = __esm(() => {
+  init_letta_client();
   init_request();
-  init_headless_enqueue_wait();
   RemoteExecutionFailed = class RemoteExecutionFailed extends Error {
   };
 });
@@ -212426,19 +212291,21 @@ async function resolveChildSubagent(backend3, agentId, parentAgentId) {
   }
 }
 function waitForChildRun(receipt, signal) {
+  const backend3 = getBackend();
   return waitForAcceptedSuperRun(receipt, signal, {
-    open: openConversationStatusStream,
-    latest: getLatestConversationSuperRun,
+    exact: getExactSuperRun,
+    run: (runId, readSignal) => backend3.retrieveRun(runId, { signal: readSignal }),
     messages: async () => []
   });
 }
 function trackChildSend(input) {
   const { receipt, child, parentScope } = input;
   const subagentId = generateSubagentId();
-  registerSubagent(subagentId, child.type, child.name, undefined, true, false, parentScope, input.prompt);
+  registerSubagent(subagentId, child.type, child.name, undefined, true, false, parentScope, input.prompt, false);
   updateSubagent(subagentId, {
     agentId: receipt.agent_id,
     conversationId: receipt.conversation_id,
+    superRunId: receipt.super_run_id,
     agentURL: buildAgentReference(receipt.agent_id, {
       conversationId: receipt.conversation_id
     })
@@ -212451,6 +212318,7 @@ function trackChildSend(input) {
 }
 var init_child_send_tracking = __esm(() => {
   init_subagent_state();
+  init_backend2();
   init_conversation_enqueue();
   init_app_urls();
   init_headless_super_run_wait();
@@ -213151,7 +213019,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.33.3"
+        version: "0.33.5"
       },
       capabilities: null
     });
@@ -216509,9 +216377,10 @@ async function collectRemoteTurnResult(receipt, state, subagentId, signal = new
     })
   });
   try {
+    const backend3 = getBackend();
     const reply = await waitForAcceptedSuperRun(receipt, signal, {
-      open: openConversationStatusStream,
-      latest: getLatestConversationSuperRun,
+      exact: getExactSuperRun,
+      run: (runId, readSignal) => backend3.retrieveRun(runId, { signal: readSignal }),
       messages: async (runId, readSignal) => {
         const messages = await listEnqueuedRunMessages(runId, readSignal);
         for (const message of messages) {
@@ -216547,6 +216416,7 @@ async function collectRemoteTurnResult(receipt, state, subagentId, signal = new
 }
 var init_remote_turn_wait = __esm(() => {
   init_subagent_state();
+  init_backend2();
   init_conversation_enqueue();
   init_app_urls();
   init_constants2();
@@ -220477,6 +220347,7 @@ function registerWorkflowExecution(params) {
     startedAt: params.startedAt ?? Date.now(),
     phases: (params.meta.phases ?? []).map((p2) => p2.title),
     agents: new Map,
+    decisionTokens: 0,
     logs: []
   });
   notify();
@@ -220495,6 +220366,9 @@ function recordWorkflowProgress(taskId, event) {
       if (record4.logs.length > MAX_LOG_LINES)
         record4.logs.shift();
       break;
+    case "decision_usage":
+      record4.decisionTokens += event.totalTokens;
+      break;
     case "agent": {
       const previous = record4.agents.get(event.callIndex);
       const phase = event.phase ?? previous?.phase ?? null;
@@ -220566,7 +220440,7 @@ function snapshot(record4, now2) {
     agentsDone: agents.filter((a2) => a2.status === "done").length,
     agentsFailed: agents.filter((a2) => a2.status === "error").length,
     agentsRunning: agents.filter((a2) => a2.status === "running").length,
-    totalTokens: agents.reduce((sum2, a2) => sum2 + (a2.totalTokens ?? 0), 0),
+    totalTokens: record4.decisionTokens + agents.reduce((sum2, a2) => sum2 + (a2.totalTokens ?? 0), 0),
     phases: phaseOrder.map((title) => ({
       title,
       agents: byPhase.get(title) ?? []
@@ -220767,6 +220641,22 @@ import { existsSync as existsSync45, readFileSync as readFileSync35 } from "node
 import { createRequire as createRequire6 } from "node:module";
 import { dirname as dirname26, join as join64 } from "node:path";
 import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL3 } from "node:url";
+function supportsPublishedResume(version2) {
+  if (!version2 || !MIN_RESUME_SDK_VERSION)
+    return false;
+  const match2 = /^(\d+)\.(\d+)\.(\d+)$/.exec(version2);
+  const minimum3 = MIN_RESUME_SDK_VERSION.split(".").map(Number);
+  if (!match2)
+    return false;
+  const parts = match2.slice(1).map(Number);
+  for (let index = 0;index < parts.length; index++) {
+    const part = parts[index];
+    const required5 = minimum3[index];
+    if (part !== required5)
+      return (part ?? 0) > (required5 ?? 0);
+  }
+  return true;
+}
 function preferRunningCliForSubagents() {
   if (process.env.LETTA_CLI_PATH)
     return;
@@ -220775,6 +220665,17 @@ function preferRunningCliForSubagents() {
     process.env.LETTA_CLI_PATH = entry;
   }
 }
+function packageVersion(entry) {
+  for (let dir = dirname26(entry);; dir = dirname26(dir)) {
+    try {
+      const manifest = JSON.parse(readFileSync35(join64(dir, "package.json"), "utf8"));
+      if (manifest.name === SDK_PACKAGE)
+        return manifest.version;
+    } catch {}
+    if (dir === dirname26(dir))
+      return;
+  }
+}
 function packageEntry(packageDir) {
   try {
     const manifest = JSON.parse(readFileSync35(join64(packageDir, "package.json"), "utf8"));
@@ -220842,6 +220743,7 @@ async function loadAgentSdk() {
         continue;
       }
       return {
+        supportsAgentFreeResume: process.env.LETTA_WORKFLOW_AGENT_FREE_RESUME === "1" && Boolean(envPath) && specifier === specifiers[0] || specifier.startsWith("file:") && supportsPublishedResume(packageVersion(fileURLToPath7(specifier))),
         createLocalClient: () => {
           const client = new sdk.LettaAgentClient({
             backend: "local",
@@ -220871,12 +220773,26 @@ async function loadAgentSdk() {
 ${attempts.map((a2) => `  tried ${a2}`).join(`
 `)}`);
 }
-var SDK_PACKAGE;
+var SDK_PACKAGE, MIN_RESUME_SDK_VERSION = "0.8.20";
 var init_sdk_loader = __esm(() => {
   SDK_PACKAGE = ["@letta-ai", "letta-agent-sdk"].join("/");
 });
 
 // src/tools/workflow/sdk-spawner.ts
+async function latestWorkerRun(conversationId) {
+  const client = await getClient();
+  const messages = await client.conversations.messages.list(conversationId, {
+    limit: 100,
+    order: "desc"
+  });
+  const runId = messages.getPaginatedItems().map((message) => message.run_id).find((id2) => typeof id2 === "string" && id2.startsWith("run-"));
+  if (!runId)
+    return null;
+  return client.runs.retrieve(runId);
+}
+async function retrieveWorkerConversation(id2) {
+  return apiRequest("GET", `/v1/conversations/${encodeURIComponent(id2)}`);
+}
 function parseJsonReply(text2) {
   const trimmed = text2.trim();
   const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/.exec(trimmed);
@@ -220962,16 +220878,22 @@ function usageTokensFromEvent(event) {
   const total = event.total_tokens;
   return typeof total === "number" && Number.isFinite(total) ? total : undefined;
 }
-async function drainTurn(query3, usage, stop, maxToolCalls, onUsage) {
-  let assistantText = "";
+async function drainTurn(query3, usage, stop, maxToolCalls, onUsage, onStarted) {
+  let assistantText2 = "";
   let resultText;
   let success = false;
   let error4;
   let structuredOutput;
+  let startedNotified = false;
   const guard = createToolCallGuard(maxToolCalls);
   for await (const message of query3) {
+    const id2 = query3.conversationId ?? message.conversationId;
+    if (!startedNotified && id2) {
+      startedNotified = true;
+      onStarted?.(id2);
+    }
     if (message.type === "assistant")
-      assistantText += message.content ?? "";
+      assistantText2 += message.content ?? "";
     if (message.type === "stream_event") {
       const tokens = usageTokensFromEvent(message.event);
       if (tokens !== undefined) {
@@ -220997,7 +220919,7 @@ async function drainTurn(query3, usage, stop, maxToolCalls, onUsage) {
     }
   }
   return {
-    finalText: (resultText ?? assistantText).trim(),
+    finalText: (resultText ?? assistantText2).trim(),
     success,
     error: error4,
     structuredOutput,
@@ -221020,16 +220942,44 @@ function buildQueryOptions(options, model, config, callIndex) {
     name: options.label ?? `Workflow worker ${callIndex + 1}`,
     system: system2,
     permissionMode: "unrestricted",
-    allowedTools: options.allowedTools ?? config.allowedTools ?? DEFAULT_ALLOWED_TOOLS,
+    allowedTools: options.allowedTools ?? (options.conversationId ? [] : config.allowedTools ?? DEFAULT_ALLOWED_TOOLS),
     skillSources: [],
     ...config.cwd ? { cwd: config.cwd } : {},
+    disableMemoryGuard: true,
     ...options.effort ? { modelSettings: { reasoning_effort: options.effort } } : {}
   };
 }
 function createSdkSpawner(client, config) {
   return async (request, signal, hooks) => {
     const { prompt, options } = request;
-    const model = options.model ? config.resolveModel?.(options.model) ?? null : config.model;
+    const resumeId = options.conversationId;
+    if (resumeId !== undefined && !/^conv-[A-Za-z0-9_-]+$/.test(resumeId)) {
+      throw new Error("agent() conversationId must be a conv-... ID.");
+    }
+    if (resumeId && !config.supportsAgentFreeResume) {
+      throw new Error("Workflow worker continuation requires an Agent SDK release with agent-free query() resume support.");
+    }
+    const persisted = resumeId ? await (config.retrieveConversation ?? retrieveWorkerConversation)(resumeId) : null;
+    if (persisted && (persisted.agent_id !== null || persisted.parent_agent_id !== config.parentAgentId)) {
+      throw new Error("Worker conversation is not agent-free or belongs to another parent agent.");
+    }
+    if (persisted && resumeId) {
+      const latest = await (config.latestRun ?? latestWorkerRun)(resumeId);
+      if (!latest || latest.conversation_id !== resumeId || !["completed", "failed", "cancelled"].includes(latest.status ?? "")) {
+        throw new Error("Cannot confirm worker's latest run is terminal; reconcile it before continuing.");
+      }
+    }
+    if (persisted && (!persisted.model || typeof persisted.model !== "string")) {
+      throw new Error("Worker conversation has no persisted model; cannot continue safely.");
+    }
+    const selectedModel = options.model ? config.resolveModel?.(options.model) ?? null : config.model;
+    if (persisted && options.systemPrompt !== undefined) {
+      throw new Error("agent() continuation cannot override the worker system prompt.");
+    }
+    if (persisted && options.model && selectedModel !== persisted.model) {
+      throw new Error("agent() continuation model must match the persisted worker model.");
+    }
+    const model = persisted ? persisted.model : selectedModel;
     if (!model) {
       return {
         value: null,
@@ -221048,8 +220998,15 @@ function createSdkSpawner(client, config) {
     const usage = {};
     const query3 = client.query({
       prompt,
-      options: buildQueryOptions(options, model, config, request.callIndex)
+      options: {
+        ...buildQueryOptions(options, model, config, request.callIndex),
+        ...resumeId ? { conversationId: resumeId } : {}
+      }
     });
+    if (resumeId && query3.conversationId && query3.conversationId !== resumeId) {
+      query3.close();
+      throw new Error("SDK resumed an unexpected worker conversation; refusing continuation.");
+    }
     let settleStopped;
     const stopped = new Promise((resolve30) => {
       settleStopped = resolve30;
@@ -221079,44 +221036,68 @@ function createSdkSpawner(client, config) {
         drainTurn(query3, usage, stop, options.maxToolCalls ?? DEFAULT_MAX_SUBAGENT_TOOL_CALLS, (totalTokens) => {
           if (!finished2)
             hooks?.onUsage?.(totalTokens);
+        }, (id2) => {
+          if (resumeId && id2 !== resumeId) {
+            stop("SDK resumed an unexpected worker conversation");
+          } else if (!finished2) {
+            hooks?.onStarted?.(id2);
+          }
         }),
         stopped
       ]);
+      if (resumeId && query3.conversationId !== resumeId) {
+        throw new Error("SDK did not resume the requested worker conversation.");
+      }
       const stats = {
         durationMs: Date.now() - startedAt,
         ...turn.totalTokens !== undefined ? { totalTokens: turn.totalTokens } : {},
         ...query3.conversationId ? { conversationId: query3.conversationId } : {}
       };
       if (!turn.success) {
-        return {
+        const outcome2 = {
           value: null,
           failed: true,
           error: turn.error ?? "subagent turn failed",
           ...stats
         };
+        return outcome2;
       }
       if (options.schema) {
-        return { value: turn.structuredOutput, failed: false, ...stats };
+        const outcome2 = {
+          value: turn.structuredOutput,
+          failed: false,
+          ...stats
+        };
+        return outcome2;
       }
       if (options.json) {
         try {
-          return {
+          const outcome2 = {
             value: parseJsonReply(turn.finalText),
             failed: false,
             ...stats
           };
+          return outcome2;
         } catch {
-          return {
+          const outcome2 = {
             value: null,
             failed: true,
             error: `Subagent reply was not valid JSON: ${turn.finalText.slice(0, 200)}`,
             ...stats
           };
+          return outcome2;
         }
       }
-      return { value: turn.finalText, failed: false, ...stats };
+      const outcome = { value: turn.finalText, failed: false, ...stats };
+      return outcome;
     } catch (error4) {
-      return { value: null, failed: true, error: String(error4) };
+      const outcome = {
+        value: null,
+        failed: true,
+        error: String(error4),
+        ...query3.conversationId || resumeId ? { conversationId: query3.conversationId ?? resumeId } : {}
+      };
+      return outcome;
     } finally {
       finished2 = true;
       clearTimeout(timeout);
@@ -221127,10 +221108,140 @@ function createSdkSpawner(client, config) {
 }
 var DEFAULT_ALLOWED_TOOLS, DEFAULT_SUBAGENT_TIMEOUT_MS, DEFAULT_MAX_SUBAGENT_TOOL_CALLS = 1000, MAX_IDENTICAL_TOOL_CALLS = 3, SUBAGENT_PREAMBLE = `You are a subagent inside a deterministic workflow. You are not talking to a human: your final output is consumed by a script. Return raw data with no preamble, no markdown framing, and no questions.`, JSON_PREAMBLE = `Your final message must be a single JSON value and nothing else: no prose, no markdown code fence.`;
 var init_sdk_spawner = __esm(() => {
+  init_client4();
+  init_request();
   DEFAULT_ALLOWED_TOOLS = ["Read", "Grep", "Glob"];
   DEFAULT_SUBAGENT_TIMEOUT_MS = 10 * 60 * 1000;
 });
 
+// src/tools/workflow/decide.ts
+function isRecord9(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validateRequest(input) {
+  if (!isRecord9(input))
+    throw new Error("decide() requires a request object.");
+  const { state, questions, provider, session_id, trace, user } = input;
+  if (Object.hasOwn(input, "model"))
+    throw new Error("decide() does not accept a model option.");
+  if (!(typeof state === "string" || isRecord9(state) || Array.isArray(state))) {
+    throw new Error("decide() state must be a string, object, or array.");
+  }
+  if (!isRecord9(questions) || Object.keys(questions).length === 0) {
+    throw new Error("decide() questions must be a non-empty object.");
+  }
+  for (const [id2, question] of Object.entries(questions)) {
+    if (!isRecord9(question) || typeof question.instructions !== "string" || !question.instructions.trim()) {
+      throw new Error(`decide() question ${id2} requires instructions.`);
+    }
+    if (question.type === "choice") {
+      if (!isRecord9(question.criteria) || Object.keys(question.criteria).length === 0 || Object.keys(question.criteria).length > 255 || !Object.values(question.criteria).every((value) => typeof value === "string")) {
+        throw new Error(`decide() choice ${id2} requires a non-empty criteria map (at most 255 options).`);
+      }
+    } else if (question.type === "score") {
+      if (!Array.isArray(question.criteria) || question.criteria.length === 0 || !question.criteria.every((value) => typeof value === "string")) {
+        throw new Error(`decide() score ${id2} requires a non-empty criteria array.`);
+      }
+    } else if (question.type !== "noul") {
+      throw new Error(`decide() question ${id2} has an unsupported type.`);
+    }
+  }
+  if (provider !== undefined && !isRecord9(provider))
+    throw new Error("decide() provider must be an object.");
+  if (isRecord9(provider) && provider.allow_fallbacks === true) {
+    throw new Error("decide() does not allow model/provider fallbacks.");
+  }
+  if (session_id !== undefined && (typeof session_id !== "string" || session_id.length > 256)) {
+    throw new Error("decide() session_id must be a string of at most 256 characters.");
+  }
+  if (trace !== undefined && !isRecord9(trace))
+    throw new Error("decide() trace must be an object.");
+  if (user !== undefined && typeof user !== "string")
+    throw new Error("decide() user must be a string.");
+  return input;
+}
+function validProbabilityMap(value) {
+  return isRecord9(value) && Object.values(value).every(isFiniteNumber2);
+}
+function validAnswer(answer, question) {
+  if (!isRecord9(answer) || answer.type !== question.type)
+    return false;
+  if (answer.type === "choice") {
+    return typeof answer.choice === "string" && isRecord9(question.criteria) && Object.hasOwn(question.criteria, answer.choice) && (answer.probabilities === undefined || validProbabilityMap(answer.probabilities)) && (answer.confidence === undefined || isFiniteNumber2(answer.confidence));
+  }
+  if (answer.type === "score") {
+    return isFiniteNumber2(answer.score) && isRecord9(answer.legend) && Object.values(answer.legend).every((value) => typeof value === "string") && (answer.probabilities === undefined || validProbabilityMap(answer.probabilities)) && (answer.confidence === undefined || isFiniteNumber2(answer.confidence));
+  }
+  return answer.type === "noul" && isFiniteNumber2(answer.noul) && answer.noul >= 0 && answer.noul <= 1;
+}
+function validateResponse(response, request) {
+  if (!isRecord9(response) || typeof response.model !== "string" || typeof response.id !== "string" || typeof response.provider !== "string" || !isRecord9(response.usage) || !isFiniteNumber2(response.usage.input_tokens) || !isFiniteNumber2(response.usage.output_tokens) || !isFiniteNumber2(response.usage.cost) || !isRecord9(response.answers)) {
+    throw new Error("decide() received a malformed response.");
+  }
+  const answers = response.answers;
+  const questionIds = Object.keys(request.questions);
+  if (Object.keys(answers).length !== questionIds.length || questionIds.some((id2) => !validAnswer(answers[id2], request.questions[id2]))) {
+    throw new InvalidDecisionAnswerError;
+  }
+  return {
+    ...response,
+    answers: Object.fromEntries(questionIds.map((id2) => [
+      id2,
+      { ...answers[id2], calibrated: true }
+    ]))
+  };
+}
+async function submitWorkflowDecision(input, signal, onResult) {
+  const request = validateRequest(input);
+  const body3 = {
+    ...request,
+    model: DEFAULT_JEV_MODEL,
+    provider: { ...request.provider, allow_fallbacks: false }
+  };
+  for (let attempt2 = 0;attempt2 < 2; attempt2++) {
+    if (signal.aborted)
+      throw new Error("Workflow aborted.");
+    const response = await apiRequest("POST", "/v1/alpha/decisions", body3, { signal: AbortSignal.any([signal, AbortSignal.timeout(35000)]) });
+    try {
+      const result3 = validateResponse(response, request);
+      onResult?.({
+        model: result3.model,
+        cost: result3.usage.cost,
+        calibrated: true,
+        valid: true,
+        totalTokens: result3.usage.input_tokens + result3.usage.output_tokens
+      });
+      return result3;
+    } catch (error4) {
+      if (!(error4 instanceof InvalidDecisionAnswerError))
+        throw error4;
+      const usage = response.usage;
+      onResult?.({
+        model: response.model,
+        cost: usage.cost,
+        calibrated: false,
+        valid: false,
+        totalTokens: usage.input_tokens + usage.output_tokens
+      });
+      if (attempt2 === 1)
+        return null;
+    }
+  }
+  return null;
+}
+var DEFAULT_JEV_MODEL = "~typesafe/jev-latest", InvalidDecisionAnswerError;
+var init_decide = __esm(() => {
+  init_request();
+  InvalidDecisionAnswerError = class InvalidDecisionAnswerError extends Error {
+    constructor() {
+      super("decide() received invalid answers for the requested questions.");
+    }
+  };
+});
+
 // src/tools/workflow/workflow-engine.ts
 import vm2 from "node:vm";
 
@@ -221169,18 +221280,57 @@ async function executeWorkflow(spawner, options) {
   };
   const inFlight = new Set;
   const maxTotalAgents = options.maxTotalAgents ?? DEFAULT_MAX_TOTAL_AGENTS;
+  const maxTotalDecisions = options.maxTotalDecisions ?? DEFAULT_MAX_TOTAL_DECISIONS;
   const semaphore = new Semaphore(options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT);
   let currentPhase = null;
   let callCounter = 0;
+  let decisionCounter = 0;
   let agentsSpawned = 0;
   let totalTokens = 0;
-  function agent(prompt, callOptions) {
-    const pending2 = callAgent(prompt, callOptions);
+  function trackCall(pending2) {
     pending2.catch(() => {});
     inFlight.add(pending2);
     pending2.finally(() => inFlight.delete(pending2)).catch(() => {});
     return pending2;
   }
+  function agent(prompt, callOptions) {
+    return trackCall(callAgent(prompt, callOptions));
+  }
+  function decide(state, questions, callOptions) {
+    return trackCall(callDecision(state, questions, callOptions));
+  }
+  async function callDecision(state, questions, callOptions) {
+    if (signal.aborted)
+      throw new Error("Workflow aborted.");
+    if (decisionCounter >= maxTotalDecisions) {
+      throw new Error(`Lifetime decision cap of ${maxTotalDecisions} reached.`);
+    }
+    if (callOptions !== undefined && (!callOptions || typeof callOptions !== "object" || Array.isArray(callOptions))) {
+      throw new Error("decide() options must be an object.");
+    }
+    decisionCounter++;
+    await semaphore.acquire();
+    try {
+      if (signal.aborted)
+        throw new Error("Workflow aborted.");
+      return await submitWorkflowDecision({
+        ...callOptions,
+        state,
+        questions
+      }, signal, (result3) => {
+        totalTokens += result3.totalTokens;
+        emit({ kind: "decision_usage", totalTokens: result3.totalTokens });
+        if (options.journalPath) {
+          appendJournalEntry(options.journalPath, {
+            kind: "decision",
+            ...result3
+          });
+        }
+      });
+    } finally {
+      semaphore.release();
+    }
+  }
   async function callAgent(prompt, callOptions) {
     if (typeof prompt !== "string" || !prompt.trim()) {
       throw new Error("agent() requires a non-empty prompt string.");
@@ -221194,6 +221344,9 @@ async function executeWorkflow(spawner, options) {
       throw new Error("agent() options must be an object.");
     }
     const opts = { ...callOptions };
+    if (opts.conversationId !== undefined && (typeof opts.conversationId !== "string" || !/^conv-[A-Za-z0-9_-]+$/.test(opts.conversationId))) {
+      throw new Error("agent() conversationId must be a conv-... ID.");
+    }
     if (opts.maxToolCalls !== undefined && (!Number.isSafeInteger(opts.maxToolCalls) || opts.maxToolCalls <= 0)) {
       throw new Error("agent() maxToolCalls must be a positive safe integer.");
     }
@@ -221208,6 +221361,15 @@ async function executeWorkflow(spawner, options) {
       emit({ kind: "agent", callIndex, label, phase: phase2, status: "running" });
       agentsSpawned++;
       const outcome = await spawner({ prompt, options: opts, callIndex }, signal, {
+        onStarted: (conversationId) => {
+          if (options.journalPath) {
+            appendJournalEntry(options.journalPath, {
+              kind: "agent_started",
+              callIndex,
+              conversationId
+            });
+          }
+        },
         onUsage: (totalTokens2) => emit({
           kind: "agent",
           callIndex,
@@ -221223,6 +221385,7 @@ async function executeWorkflow(spawner, options) {
           callIndex,
           label,
           prompt,
+          ...opts.conversationId ? { resumedConversationId: opts.conversationId } : {},
           outcome
         });
       }
@@ -221292,6 +221455,7 @@ async function executeWorkflow(spawner, options) {
   }
   const context3 = vm2.createContext({
     agent,
+    decide,
     parallel,
     pipeline: pipeline6,
     phase,
@@ -221339,8 +221503,9 @@ ${stripMetaExport(options.script)}
     settled = true;
   }
 }
-var DEFAULT_MAX_CONCURRENT = 16, DEFAULT_MAX_TOTAL_AGENTS = 1000, MAX_ITEMS_PER_HELPER = 4096;
+var DEFAULT_MAX_CONCURRENT = 16, DEFAULT_MAX_TOTAL_AGENTS = 1000, DEFAULT_MAX_TOTAL_DECISIONS = 1000, MAX_ITEMS_PER_HELPER = 4096;
 var init_workflow_engine = __esm(() => {
+  init_decide();
   init_journal();
   init_meta3();
 });
@@ -221394,7 +221559,8 @@ async function createSdkSpawnerHandle(args, setStage = () => {}) {
       model,
       resolveModel,
       allowedTools: args.allowedTools ?? [...DEFAULT_ALLOWED_TOOLS],
-      cwd: getCurrentWorkingDirectory()
+      cwd: getCurrentWorkingDirectory(),
+      supportsAgentFreeResume: sdk.supportsAgentFreeResume
     });
   } catch (error4) {
     client[Symbol.asyncDispose]?.().catch(() => {
@@ -221417,6 +221583,8 @@ function formatWorkflowProgressLine(event) {
       return `── ${event.title} ──`;
     case "log":
       return `» ${event.message}`;
+    case "decision_usage":
+      return null;
     case "agent": {
       if (event.status === "queued")
         return null;
@@ -221462,7 +221630,7 @@ function formatCompletionResult(run, executionDir) {
   return [
     payload,
     "",
-    `Per-agent results: ${join65(executionDir, "journal.jsonl")} — one line per completed agent with its full return value.`,
+    `Per-call results: ${join65(executionDir, "journal.jsonl")} — one line per completed agent call with its full return value, plus one per decide() API attempt (retries included) with its model, cost, calibration, and tokens.`,
     "If the result above is empty or unexpected, read that file BEFORE diagnosing — do not assume agents returned non-empty results."
   ].join(`
 `);
@@ -221681,7 +221849,7 @@ ${result3}
       `Workflow launched in background. Task ID: ${taskId}`,
       `Summary: ${meta.description}`,
       `Script file: ${scriptPath}`,
-      `Journal: ${journalPath} (one line per completed agent)`,
+      `Journal: ${journalPath} (one line per completed agent, and per decide() API attempt including retries)`,
       `Output file: ${outputFile}`,
       "",
       "You will be notified when it completes. Do not poll or sleep — keep working or end your turn. Read the output file only when you need interim progress; TaskStop aborts the run; the user can watch live status with /workflows."
@@ -398948,7 +399116,7 @@ function createModChangeBatcher(onChange) {
 // src/mods/package-manifest.ts
 import { readFileSync as readFileSync37 } from "node:fs";
 import path35 from "node:path";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function addError(errors4, errorPath, message) {
@@ -399087,7 +399255,7 @@ function validateCapabilities(value, errors4) {
 function validateEngines(value, errors4) {
   if (value === undefined)
     return;
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     addError(errors4, "letta.engines", "engines must be an object");
     return;
   }
@@ -399112,7 +399280,7 @@ function validateEngines(value, errors4) {
   return Object.keys(engines).length > 0 ? engines : undefined;
 }
 function parseLettaPackageManifest(packageJson) {
-  if (!isRecord9(packageJson)) {
+  if (!isRecord10(packageJson)) {
     return {
       errors: [{ message: "package.json must be an object", path: "package" }],
       manifest: null,
@@ -399123,7 +399291,7 @@ function parseLettaPackageManifest(packageJson) {
   if (rawManifest === undefined) {
     return { errors: [], manifest: null, ok: true };
   }
-  if (!isRecord9(rawManifest)) {
+  if (!isRecord10(rawManifest)) {
     return {
       errors: [{ message: "letta manifest must be an object", path: "letta" }],
       manifest: null,
@@ -399193,7 +399361,7 @@ import {
   writeFileSync as writeFileSync28
 } from "node:fs";
 import path36 from "node:path";
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function createDiagnostic(diagnosticPath, message) {
@@ -399270,7 +399438,7 @@ function readRegistryObject(modsRoot) {
       registryPath
     };
   }
-  if (!isRecord10(registryResult.value)) {
+  if (!isRecord11(registryResult.value)) {
     return {
       diagnostics: [
         createDiagnostic(registryPath, "packages.json must be an object")
@@ -399347,7 +399515,7 @@ function resolvePackageEntry(packageRoot, entry) {
 }
 function validatePackageMetadata(modsRoot, rawEntry, index) {
   const diagnosticPath = `packages[${index}]`;
-  if (!isRecord10(rawEntry)) {
+  if (!isRecord11(rawEntry)) {
     return {
       diagnostics: [
         createDiagnostic(diagnosticPath, "package registry entry must be an object")
@@ -399714,7 +399882,7 @@ function setManagedModPackageEnabled(params) {
   const registry3 = readMutablePackageRegistry(params.modsRoot);
   const match3 = findPackageIndex(params.modsRoot, registry3.packagesValue, params.specifier);
   const rawEntry = registry3.packagesValue[match3.index];
-  if (!isRecord10(rawEntry)) {
+  if (!isRecord11(rawEntry)) {
     throw new Error("Invalid package entry");
   }
   rawEntry.enabled = params.enabled;
@@ -399760,7 +399928,7 @@ function upsertManagedModPackage(params) {
   let removedDuplicates = 0;
   let replaced = false;
   registry3.packagesValue.forEach((rawEntry) => {
-    if (isRecord10(rawEntry) && rawEntry.source === params.source) {
+    if (isRecord11(rawEntry) && rawEntry.source === params.source) {
       if (!replaced) {
         insertionIndex = nextPackages.length;
         nextPackages.push(entry);
@@ -399924,7 +400092,7 @@ var init_runtime_dependencies = __esm(() => {
 });
 
 // src/mods/turn-start-cancel.ts
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 function normalizeTurnStartCancelReason(value) {
@@ -399936,7 +400104,7 @@ function normalizeTurnStartCancelReason(value) {
   return trimmed.length > MAX_TURN_START_CANCEL_REASON_LENGTH ? trimmed.slice(0, MAX_TURN_START_CANCEL_REASON_LENGTH) : trimmed;
 }
 function getTurnStartCancel(event) {
-  if (!isRecord11(event) || !isRecord11(event.cancel))
+  if (!isRecord12(event) || !isRecord12(event.cancel))
     return null;
   const reason = normalizeTurnStartCancelReason(event.cancel.reason);
   return reason ? { reason } : null;
@@ -402562,14 +402730,16 @@ function emitLoopErrorNotice(socket, runtime, params) {
     mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
     return null;
   }
-  emitLoopErrorDelta(socket, runtime, {
+  emitCanonicalMessageDelta(socket, runtime, {
+    ...createLifecycleMessageBase("loop_error", params.runId),
     message: decision.message,
-    stopReason: params.stopReason,
-    isTerminal: params.isTerminal,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId,
-    apiError: decision.apiError
+    stop_reason: params.stopReason,
+    is_terminal: params.isTerminal,
+    ...params.clientMessageIds?.length ? { client_message_ids: params.clientMessageIds } : {},
+    ...decision.apiError ? { api_error: decision.apiError } : {}
+  }, {
+    agent_id: params.agentId,
+    conversation_id: params.conversationId
   });
   return decision.message;
 }
@@ -406579,14 +406749,14 @@ var init_approval_suggestions = __esm(async () => {
 });
 
 // src/websocket/listener/cloud-retry-message.ts
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString4(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function parseCloudRetryMessage(value) {
-  if (!isRecord12(value) || value.message_type !== "retry_message") {
+  if (!isRecord13(value) || value.message_type !== "retry_message") {
     return null;
   }
   const attempt2 = value.attempt;
@@ -406841,6 +407011,19 @@ function finishListenerTurn(runtime, lease, options) {
   if (options.stopReason === "end_turn" || options.stopReason === "cancelled") {
     forgetListenerWork(runtime);
   }
+  if (options.socket && options.errorNotice) {
+    const runId = options.errorNotice.runId ?? options.runId ?? transition2.runId;
+    const message = emitLoopErrorNotice(options.socket, runtime, {
+      ...options.errorNotice,
+      stopReason: options.stopReason,
+      isTerminal: true,
+      runId,
+      agentId: options.agentId,
+      conversationId: options.conversationId
+    });
+    runtime.lastTerminalLoopErrorMessage = message ?? options.errorNotice.message;
+    runtime.lastTerminalLoopErrorRunId = runId ?? null;
+  }
   if (options.stopReason === "cancelled" && transition2.previousKind === "active" && options.socket) {
     emitInterruptedStatusDelta(options.socket, runtime, {
       runId: options.runId ?? transition2.runId,
@@ -406873,6 +407056,7 @@ var init_turn_terminal = __esm(() => {
   init_connection();
   init_interrupted_turn_record();
   init_protocol_outbound();
+  init_recoverable_notices();
 });
 
 // src/websocket/listener/recovery.ts
@@ -417121,6 +417305,12 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
     ...options,
     socket: options.socket ?? socket,
     turnId: activeDequeuedBatchId,
+    ...options.errorNotice ? {
+      errorNotice: {
+        ...options.errorNotice,
+        clientMessageIds: turnCorrelation.clientMessageIds
+      }
+    } : {},
     ...runtime.executionSettings ? { usage: buildTurnUsage(buffers.usage) } : {}
   }));
   const finishIfInterrupted = (runId) => {
@@ -417175,24 +417365,16 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       return;
     }
     if (setup.kind === "cancelled") {
-      const transition2 = finishTurn({
+      finishTurn({
         stopReason: "cancelled",
         agentId: agentId || null,
-        conversationId
-      });
-      if (!transition2.finished) {
-        return;
-      }
-      const formattedError = emitLoopErrorNotice(socket, runtime, {
-        message: setup.reason,
-        stopReason: "cancelled",
-        isTerminal: true,
-        agentId,
         conversationId,
-        cancelRequested: turnAbortSignal.aborted,
-        abortSignal: turnAbortSignal
+        errorNotice: {
+          message: setup.reason,
+          cancelRequested: turnAbortSignal.aborted,
+          abortSignal: turnAbortSignal
+        }
       });
-      runtime.lastTerminalLoopErrorMessage = formattedError ?? setup.reason;
       return;
     }
     let turnInput = setup.turnInput;
@@ -417262,19 +417444,15 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       lastApprovalContinuationAccepted = false;
       const maxTurns = runtime.executionSettings?.max_turns;
       if (maxTurns !== undefined && buffers.usage.stepCount >= maxTurns && stopReason !== "requires_approval" && !(stopReason === "error" && fallbackError)) {
-        emitLoopErrorNotice(socket, runtime, {
-          message: `Maximum turns limit reached (${buffers.usage.stepCount}/${maxTurns} steps)`,
-          stopReason: "max_steps",
-          isTerminal: true,
-          runId: runId || runtime.activeRunId,
-          agentId,
-          conversationId
-        });
         finishTurn({
           stopReason: "max_steps",
           socket,
           agentId,
-          conversationId
+          conversationId,
+          errorNotice: {
+            message: `Maximum turns limit reached (${buffers.usage.stepCount}/${maxTurns} steps)`,
+            runId: runId || runtime.activeRunId
+          }
         });
         break;
       }
@@ -417560,23 +417738,13 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
           abortSignal: turnAbortSignal
         };
         const terminalError = getConsumerLoopErrorMessage(noticeParams);
-        const transition2 = finishTurn({
+        finishTurn({
           stopReason: effectiveStopReason,
           agentId,
           conversationId,
-          error: terminalError
-        });
-        if (!transition2.finished) {
-          break;
-        }
-        const formattedError = emitLoopErrorNotice(socket, runtime, {
-          ...noticeParams,
-          stopReason: effectiveStopReason,
-          isTerminal: true,
-          runId: terminalRunId
+          error: terminalError,
+          errorNotice: { ...noticeParams, runId: terminalRunId }
         });
-        runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage5;
-        runtime.lastTerminalLoopErrorRunId = terminalRunId ?? null;
         break;
       }
       const approvalResult = await handleApprovalStop({
@@ -417600,25 +417768,16 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       });
       if (approvalResult.kind === "error") {
         const terminalRunId = runId || runtime.activeRunId;
-        const transition2 = finishTurn({
+        finishTurn({
           stopReason: "error",
           agentId,
           conversationId,
-          error: getTranscriptLoopErrorMessage({ message: approvalResult.message })
-        });
-        if (!transition2.finished) {
-          return;
-        }
-        const formattedError = emitLoopErrorNotice(socket, runtime, {
-          message: approvalResult.message,
-          stopReason: "error",
-          isTerminal: true,
-          runId: terminalRunId,
-          agentId,
-          conversationId
+          error: getTranscriptLoopErrorMessage({ message: approvalResult.message }),
+          errorNotice: {
+            message: approvalResult.message,
+            runId: terminalRunId
+          }
         });
-        runtime.lastTerminalLoopErrorMessage = formattedError ?? approvalResult.message;
-        runtime.lastTerminalLoopErrorRunId = terminalRunId ?? null;
         return;
       }
       turnInput = approvalResult.turnInput;
@@ -417720,19 +417879,12 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       stopReason: "error",
       agentId: agentId || null,
       conversationId,
-      error: terminalError
+      error: terminalError,
+      errorNotice: { ...noticeParams, runId: terminalRunId }
     });
     if (!transition2.finished) {
       return;
     }
-    const formattedError = emitLoopErrorNotice(socket, runtime, {
-      ...noticeParams,
-      stopReason: "error",
-      isTerminal: true,
-      runId: terminalRunId
-    });
-    runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage5;
-    runtime.lastTerminalLoopErrorRunId = terminalRunId ?? null;
     if (isDebugEnabled()) {
       console.error("[Listen] Error handling message:", error4);
     }
@@ -418206,8 +418358,8 @@ function spawnBun(shell, cwd2, cols, rows, terminal_id, connectionId, socket) {
       data: (_t, chunk2) => handleData(new TextDecoder().decode(chunk2))
     }
   });
-  const terminal2 = proc.terminal;
-  if (!terminal2) {
+  const terminal = proc.terminal;
+  if (!terminal) {
     throw new Error("Bun.spawn terminal object missing — API unavailable");
   }
   proc.exited.then((exitCode) => {
@@ -418224,17 +418376,17 @@ function spawnBun(shell, cwd2, cols, rows, terminal_id, connectionId, socket) {
   return {
     write: (d2) => {
       try {
-        terminal2.write(d2);
+        terminal.write(d2);
       } catch {}
     },
     resize: (c, r5) => {
       try {
-        terminal2.resize(c, r5);
+        terminal.resize(c, r5);
       } catch {}
     },
     kill: () => {
       try {
-        terminal2.close();
+        terminal.close();
       } catch {}
       try {
         proc.kill();
@@ -421601,7 +421753,7 @@ var init_inbound_dispatch = __esm(async () => {
 });
 
 // src/websocket/listener/protocol-logging.ts
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function formatLogValue(value) {
@@ -421625,14 +421777,14 @@ function pushField(fields, key2, value, label = key2) {
     fields.push(`${label}=${formatted}`);
 }
 function summarizeInputPayload(payload) {
-  if (!isRecord13(payload))
+  if (!isRecord14(payload))
     return [];
   const fields = [];
   pushField(fields, "kind", payload.kind);
   if (payload.kind === "create_message") {
     pushField(fields, "messages", payload.messages);
     pushField(fields, "client_tool_allowlist", payload.client_tool_allowlist);
-    if (isRecord13(payload.client_toolset)) {
+    if (isRecord14(payload.client_toolset)) {
       pushField(fields, "client_toolset.base", payload.client_toolset.base);
       pushField(fields, "client_toolset.include", payload.client_toolset.include);
     }
@@ -421649,9 +421801,9 @@ function summarizeRuntimeStartCommand(command) {
   const fields = [];
   pushField(fields, "agent_id", command.agent_id, "agent");
   pushField(fields, "conversation_id", command.conversation_id, "conversation");
-  if (isRecord13(command.create_agent))
+  if (isRecord14(command.create_agent))
     fields.push("create_agent=true");
-  if (isRecord13(command.create_conversation)) {
+  if (isRecord14(command.create_conversation)) {
     fields.push("create_conversation=true");
   }
   pushField(fields, "cwd", command.cwd);
@@ -421660,17 +421812,17 @@ function summarizeRuntimeStartCommand(command) {
   return fields;
 }
 function summarizeV2Command(parsed) {
-  if (!isRecord13(parsed) || typeof parsed.type !== "string")
+  if (!isRecord14(parsed) || typeof parsed.type !== "string")
     return "unknown";
   const fields = [];
-  const runtime = isRecord13(parsed.runtime) ? parsed.runtime : null;
+  const runtime = isRecord14(parsed.runtime) ? parsed.runtime : null;
   if (runtime) {
     fields.push(`runtime=${runtime.agent_id ?? "<unknown>"}/${runtime.conversation_id ?? "<unknown>"}`);
   }
   pushField(fields, "request_id", parsed.request_id);
   if (parsed.type === "input") {
     fields.push(...summarizeInputPayload(parsed.payload));
-  } else if (parsed.type === "change_device_state" && isRecord13(parsed.payload)) {
+  } else if (parsed.type === "change_device_state" && isRecord14(parsed.payload)) {
     pushField(fields, "mode", parsed.payload.mode);
     pushField(fields, "cwd", parsed.payload.cwd);
     pushField(fields, "agent_id", parsed.payload.agent_id);
@@ -421680,7 +421832,7 @@ function summarizeV2Command(parsed) {
   } else if (parsed.type === "runtime_external_tools_update" && Array.isArray(parsed.updates)) {
     fields.push(`updates=${parsed.updates.length}`);
     fields.push(`runtimes=${parsed.updates.reduce((count, update3) => {
-      return count + (isRecord13(update3) && Array.isArray(update3.runtimes) ? update3.runtimes.length : 0);
+      return count + (isRecord14(update3) && Array.isArray(update3.runtimes) ? update3.runtimes.length : 0);
     }, 0)}`);
   } else {
     for (const key2 of [
@@ -424539,7 +424691,7 @@ function decodeJwtClaims(token2, sharedSecret) {
   } catch {
     return { error: unauthorized("invalid websocket jwt") };
   }
-  if (!isRecord14(header) || header.alg !== "HS256") {
+  if (!isRecord15(header) || header.alg !== "HS256") {
     return { error: unauthorized("invalid websocket jwt") };
   }
   const expectedSignature = createHmac("sha256", sharedSecret).update(`${encodedHeader}.${encodedClaims}`).digest();
@@ -424577,7 +424729,7 @@ function audienceMatches(actual, expectedAudience) {
   return false;
 }
 function isJwtClaims(value) {
-  if (!isRecord14(value) || !Number.isSafeInteger(value.exp)) {
+  if (!isRecord15(value) || !Number.isSafeInteger(value.exp)) {
     return false;
   }
   if (value.nbf !== undefined && !Number.isSafeInteger(value.nbf)) {
@@ -424597,7 +424749,7 @@ function isJwtClaims(value) {
   }
   return true;
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function base64UrlDecode(value) {
@@ -428790,8 +428942,8 @@ function formatError(error4, mapper = (issue2) => issue2.message) {
           let i4 = 0;
           while (i4 < fullpath.length) {
             const el = fullpath[i4];
-            const terminal2 = i4 === fullpath.length - 1;
-            if (!terminal2) {
+            const terminal = i4 === fullpath.length - 1;
+            if (!terminal) {
               curr[el] = curr[el] || { _errors: [] };
             } else {
               curr[el] = curr[el] || { _errors: [] };
@@ -444692,8 +444844,8 @@ async function connectMcpServer(config2, options = {}) {
         return {
           content: Array.isArray(result3.content) ? result3.content : [],
           ...typeof result3.isError === "boolean" ? { isError: result3.isError } : {},
-          ...isRecord15(result3.structuredContent) ? { structuredContent: result3.structuredContent } : {},
-          ...isRecord15(result3._meta) ? { _meta: result3._meta } : {}
+          ...isRecord16(result3.structuredContent) ? { structuredContent: result3.structuredContent } : {},
+          ...isRecord16(result3._meta) ? { _meta: result3._meta } : {}
         };
       },
       close: async () => {
@@ -444766,11 +444918,11 @@ function mergeHeaders4(init, headers) {
   };
 }
 function normalizeInputSchema(value) {
-  if (isRecord15(value) && value.type === "object")
+  if (isRecord16(value) && value.type === "object")
     return value;
   return { type: "object", properties: {} };
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var DEFAULT_CLIENT_INFO;
@@ -444782,7 +444934,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.33.3"
+    version: "0.33.5"
   };
 });
 
@@ -447450,7 +447602,7 @@ import {
 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
 import path45 from "node:path";
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPathInsideOrEqual2(childPath, parentPath) {
@@ -447466,7 +447618,7 @@ function readPackageJson(packageJsonPath) {
   } catch (error5) {
     throw new Error(`Could not read package.json: ${error5 instanceof Error ? error5.message : String(error5)}`);
   }
-  if (!isRecord16(parsed)) {
+  if (!isRecord17(parsed)) {
     throw new Error("package.json must be an object");
   }
   return parsed;
@@ -447476,7 +447628,7 @@ function formatRepository(repository) {
     const trimmed2 = repository.trim();
     return trimmed2 || undefined;
   }
-  if (!isRecord16(repository))
+  if (!isRecord17(repository))
     return;
   const url2 = repository.url;
   if (typeof url2 !== "string")
@@ -448006,7 +448158,7 @@ function hasRuntimeDependencies(packageJson) {
   if (!packageJson)
     return false;
   const dependencies4 = packageJson.dependencies;
-  return isRecord16(dependencies4) && Object.keys(dependencies4).length > 0;
+  return isRecord17(dependencies4) && Object.keys(dependencies4).length > 0;
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path45.join(packageDirectory, "package.json");
@@ -456140,23 +456292,23 @@ class ChannelGateway {
       active.richDraft?.flushPending();
     }
   }
-  handleTurnFinished(runtime, terminal2) {
+  handleTurnFinished(runtime, terminal) {
     const state = this.getState(runtime);
     const active = state.active;
     if (!active)
       return;
     state.active = null;
     active.richDraft?.dispose();
-    const remainingSources = lifecycleOutcome(terminal2.stopReason) === "completed" ? this.remainingSources(state) : [];
+    const remainingSources = lifecycleOutcome(terminal.stopReason) === "completed" ? this.remainingSources(state) : [];
     this.enqueueHook(state, () => this.hooks.onLifecycle({
       type: "finished",
       batchId: active.batchId,
       sources: active.lifecycleSources,
-      outcome: lifecycleOutcome(terminal2.stopReason),
-      stopReason: terminal2.stopReason,
+      outcome: lifecycleOutcome(terminal.stopReason),
+      stopReason: terminal.stopReason,
       ...remainingSources.length ? { remainingSources } : {},
-      ...terminal2.runId ?? active.runId ? { runId: terminal2.runId ?? active.runId } : {},
-      ...terminal2.error ? { error: terminal2.error } : {}
+      ...terminal.runId ?? active.runId ? { runId: terminal.runId ?? active.runId } : {},
+      ...terminal.error ? { error: terminal.error } : {}
     }));
   }
   handleControlRequest(message) {
@@ -458967,6 +459119,95 @@ var init_local_backend_mod_events = __esm(() => {
   init_local_backend();
 });
 
+// src/headless-enqueue-wait.ts
+function getSendRunIds(status, clientMessageId) {
+  return Object.entries(status?.runtime_status?.loop_state?.client_message_ids_by_run_id ?? {}).filter(([, ids]) => ids.includes(clientMessageId)).map(([runId]) => runId);
+}
+function getConversationStatus(event, conversationId) {
+  if (event.type === "conversation_super_run_snapshot") {
+    return event.statuses.find((status) => status.conversation_id === conversationId) ?? null;
+  }
+  return event.conversation_id === conversationId ? event.status : undefined;
+}
+async function waitForEnqueuedReply(params) {
+  const runIds = new Set;
+  const now2 = params.now ?? Date.now;
+  let completedWithoutText;
+  let next = Promise.resolve({
+    done: false,
+    value: params.firstEvent
+  });
+  try {
+    while (true) {
+      params.signal.throwIfAborted();
+      let timer;
+      const event = await Promise.race([
+        next,
+        new Promise((resolve42) => {
+          timer = setTimeout(() => resolve42(null), params.pollMs ?? 1000);
+        })
+      ]).finally(() => clearTimeout(timer));
+      if (event) {
+        if (event.done)
+          throw new Error("Conversation status connection closed; remote execution may still be running.");
+        const status = getConversationStatus(event.value, params.receipt.conversation_id);
+        if (status !== undefined) {
+          for (const runId2 of getSendRunIds(status, params.receipt.client_message_id))
+            runIds.add(runId2);
+        }
+        next = params.events.next();
+        next.catch(() => {});
+      }
+      const runId = [...runIds].at(-1);
+      if (!runId) {
+        const latest = await params.latestSuperRun();
+        if (latest?.id === params.receipt.super_run_id && (latest.errored_at || latest.cancelled_at)) {
+          throw new Error(`Accepted send ${latest.id} ${latest.errored_at ? "failed" : "was cancelled"} before a run was observed.`);
+        }
+        continue;
+      }
+      const run = await params.retrieveRun(runId);
+      if (run.status === "failed" || run.status === "cancelled") {
+        throw new Error(`Remote run ${runId} ${run.status}${run.stop_reason ? ` (${run.stop_reason})` : ""}`);
+      }
+      if (run.status !== "completed" || run.stop_reason === "requires_approval")
+        continue;
+      const messages = await params.listRunMessages(runId);
+      const assistant = messages.filter((message) => message.message_type === "assistant_message").sort((a2, b3) => (b3.seq_id ?? 0) - (a2.seq_id ?? 0))[0];
+      if (assistant?.message_type === "assistant_message") {
+        const text2 = typeof assistant.content === "string" ? assistant.content : assistant.content.filter((part) => part.type === "text").map((part) => part.text).join(`
+`);
+        if (text2.trim())
+          return {
+            text: text2,
+            runIds: [...runIds],
+            stopReason: run.stop_reason ?? null
+          };
+      }
+      if (completedWithoutText?.runId !== runId)
+        completedWithoutText = { runId, at: now2() };
+      if (now2() - completedWithoutText.at < 15000)
+        continue;
+      throw new Error(`Remote run ${runId} completed without an assistant reply (${run.stop_reason ?? "unknown stop reason"})`);
+    }
+  } catch (error5) {
+    throw new EnqueuedWaitError(error5, [...runIds]);
+  }
+}
+var EnqueuedWaitError;
+var init_headless_enqueue_wait = __esm(() => {
+  EnqueuedWaitError = class EnqueuedWaitError extends Error {
+    runIds;
+    constructor(error5, runIds) {
+      super(error5 instanceof Error ? error5.message : String(error5), {
+        cause: error5
+      });
+      this.runIds = runIds;
+      this.name = "EnqueuedWaitError";
+    }
+  };
+});
+
 // src/headless-cloud-send.ts
 import { randomUUID as randomUUID48 } from "node:crypto";
 function shouldEnqueueCloudSend(values4, cloud, isAgentLaunch) {
@@ -465672,14 +465913,14 @@ function detectTerminalType() {
 function isVSCodeLikeTerminal() {
   return detectTerminalType() !== null;
 }
-function getKeybindingsPath(terminal2) {
-  if (!terminal2)
+function getKeybindingsPath(terminal) {
+  if (!terminal)
     return null;
   const appName = {
     vscode: "Code",
     cursor: "Cursor",
     windsurf: "Windsurf"
-  }[terminal2];
+  }[terminal];
   const os9 = platform10();
   if (os9 === "darwin") {
     return join96(homedir52(), "Library", "Application Support", appName, "User", "keybindings.json");
@@ -465802,35 +466043,35 @@ function removeKeybinding(keybindingsPath) {
   }
 }
 function installKeybindingForCurrentTerminal() {
-  const terminal2 = detectTerminalType();
-  if (!terminal2) {
+  const terminal = detectTerminalType();
+  if (!terminal) {
     return {
       success: false,
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path48 = getKeybindingsPath(terminal2);
+  const path48 = getKeybindingsPath(terminal);
   if (!path48) {
     return {
       success: false,
-      error: `Could not determine keybindings.json path for ${terminal2}`
+      error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
   return installKeybinding(path48);
 }
 function removeKeybindingForCurrentTerminal() {
-  const terminal2 = detectTerminalType();
-  if (!terminal2) {
+  const terminal = detectTerminalType();
+  if (!terminal) {
     return {
       success: false,
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path48 = getKeybindingsPath(terminal2);
+  const path48 = getKeybindingsPath(terminal);
   if (!path48) {
     return {
       success: false,
-      error: `Could not determine keybindings.json path for ${terminal2}`
+      error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
   return removeKeybinding(path48);
@@ -466582,16 +466823,16 @@ var init_registry2 = __esm(() => {
         } = await Promise.resolve().then(() => (init_terminal_keybinding_installer(), exports_terminal_keybinding_installer));
         const { updateSettings: updateSettings2 } = await Promise.resolve().then(() => (init_settings4(), exports_settings2));
         const isRevert = args.includes("--revert") || args.includes("--remove");
-        const terminal2 = detectTerminalType2();
-        if (!terminal2) {
+        const terminal = detectTerminalType2();
+        if (!terminal) {
           return "Not running in a VS Code-like terminal. Shift+Enter keybinding is not needed.";
         }
         const terminalName = {
           vscode: "VS Code",
           cursor: "Cursor",
           windsurf: "Windsurf"
-        }[terminal2];
-        const keybindingsPath = getKeybindingsPath2(terminal2);
+        }[terminal];
+        const keybindingsPath = getKeybindingsPath2(terminal);
         if (!keybindingsPath) {
           return `Could not determine keybindings.json path for ${terminalName}`;
         }
@@ -508893,13 +509134,13 @@ Error: ${message}`);
           installKeybinding: installKeybinding2
         } = await Promise.resolve().then(() => (init_terminal_keybinding_installer(), exports_terminal_keybinding_installer));
         const { loadSettings: loadSettings2, updateSettings: updateSettings2 } = await Promise.resolve().then(() => (init_settings4(), exports_settings2));
-        const terminal2 = detectTerminalType2();
-        if (!terminal2) {
+        const terminal = detectTerminalType2();
+        if (!terminal) {
           setShowKeybindingSetup(false);
           return;
         }
         const settings4 = await loadSettings2();
-        const keybindingsPath = getKeybindingsPath2(terminal2);
+        const keybindingsPath = getKeybindingsPath2(terminal);
         if (!keybindingsPath || settings4.shiftEnterKeybindingInstalled) {
           setShowKeybindingSetup(false);
           return;
@@ -512015,4 +512256,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=F0EE3697E822655164756E2164756E21
+//# debugId=4BF692CA3D7D262964756E2164756E21