@rowan-agent/agent 0.6.0 → 0.6.2

package/dist/index.js

@@ -521,10 +521,10 @@ ${indent}</${tag}>`;
     return `${indent}<${tag}>${escapeXml(String(val))}</${tag}>`;
   }).join("\n");
 }
-function buildPhaseDirectiveMessage(phase, output, toolUseId) {
+function buildPhaseDirectiveMessage(phase, output) {
   const parts = [];
-  parts.push(`<phase name="${escapeXml(phase.name)}">`);
-  parts.push(`  <content>${phase.content}</content>`);
+  parts.push(`<phase_content name="${escapeXml(phase.name)}">`);
+  parts.push(phase.content);
   if (output.results && output.results.length > 0) {
     parts.push(`  <prev_phase_outputs>`);
     if (output.instruction) {
@@ -539,13 +539,8 @@ function buildPhaseDirectiveMessage(phase, output, toolUseId) {
     }
     parts.push(`  </prev_phase_outputs>`);
   }
-  parts.push(`</phase>`);
-  return [{
-    type: "tool_result",
-    toolUseId,
-    content: parts.join("\n"),
-    isError: false
-  }];
+  parts.push(`</phase_content>`);
+  return parts.join("\n");
 }
 
 // src/harness/phases/loader.ts
@@ -781,34 +776,27 @@ var DEFAULT_MAX_READ_BYTES = 64e3;
 var DEFAULT_BASH_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_BASH_OUTPUT_BYTES = 64e3;
 var ReadArgsSchema = Type2.Object({
-  path: Type2.String(),
-  maxBytes: Type2.Optional(Type2.Number()),
-  type: Type2.Optional(Type2.Union([
-    Type2.Literal("skill"),
-    Type2.Literal("phase"),
-    Type2.Literal("markdown"),
-    Type2.Literal("code"),
-    Type2.Literal("file")
-  ]))
+  path: Type2.String({ description: "Path to the file to read." }),
+  offset: Type2.Optional(Type2.Number({ description: "1-based line to start from." })),
+  limit: Type2.Optional(Type2.Number({ description: "Maximum number of lines." }))
 });
 var ReadArgsValidator = Schema.Compile(ReadArgsSchema);
 var WriteArgsSchema = Type2.Object({
-  path: Type2.String(),
-  content: Type2.String()
+  path: Type2.String({ description: "Path to the file to write." }),
+  content: Type2.String({ description: "Complete file contents." })
 });
 var WriteArgsValidator = Schema.Compile(WriteArgsSchema);
 var EditArgsSchema = Type2.Object({
-  path: Type2.String(),
-  oldText: Type2.String(),
-  newText: Type2.String(),
-  replaceAll: Type2.Optional(Type2.Boolean())
+  path: Type2.String({ description: "Path to the file to edit." }),
+  edits: Type2.Array(Type2.Object({
+    oldText: Type2.String({ description: "Exact unique text to replace." }),
+    newText: Type2.String({ description: "Replacement text." })
+  }), { description: "One or more non-overlapping replacements." })
 });
 var EditArgsValidator = Schema.Compile(EditArgsSchema);
 var BashArgsSchema = Type2.Object({
-  command: Type2.String(),
-  cwd: Type2.Optional(Type2.String()),
-  timeoutMs: Type2.Optional(Type2.Number()),
-  maxOutputBytes: Type2.Optional(Type2.Number())
+  command: Type2.String({ description: "Bash command to execute." }),
+  timeout: Type2.Optional(Type2.Number({ description: "Timeout in seconds." }))
 });
 var BashArgsValidator = Schema.Compile(BashArgsSchema);
 var validatorCache = /* @__PURE__ */ new WeakMap();
@@ -911,12 +899,7 @@ async function executeRuntimeToolCall(input) {
   }
   await input.observe?.({ type: "tool_start", tool, args });
   try {
-    const rawResult = await tool.execute(args, input.toolContext, input.signal);
-    let result = {
-      ...rawResult,
-      toolCallId: input.toolCall.id,
-      toolName: tool.name
-    };
+    let result = await tool.execute(args, input.toolContext, input.signal);
     if (input.afterToolCall) {
       await input.observe?.({
         type: "result_review_requested",
@@ -950,6 +933,20 @@ function positiveNumber(value, name) {
   }
   return void 0;
 }
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    return `${name} must be a positive integer.`;
+  }
+  return void 0;
+}
+function readTextLines(text, offset, limit) {
+  if (offset === void 0 && limit === void 0) {
+    return text;
+  }
+  const start = (offset ?? 1) - 1;
+  const lines = text.split(/\r\n|\n|\r/);
+  return lines.slice(start, limit === void 0 ? void 0 : start + limit).join("\n");
+}
 async function captureStream(stream, maxBytes) {
   const reader = stream.getReader();
   const chunks = [];
@@ -989,17 +986,25 @@ async function captureStream(stream, maxBytes) {
 function createReadTool(context) {
   return {
     name: "read",
-    description: "Reads a text file within the workspace.",
+    description: "Read a file in the workspace.",
     parameters: ReadArgsSchema,
-    promptSnippet: "Read a text file (max 64KB default).",
-    promptGuidelines: [
-      "Always read a file before editing or writing to understand its current content.",
-      "Use maxBytes to limit output for large files."
-    ],
+    promptSnippet: "Read file contents.",
+    promptGuidelines: ["Read files before editing them."],
     async execute(args, toolContext) {
       const parsed = ReadArgsValidator.Parse(args);
+      const offsetError = parsed.offset === void 0 ? void 0 : positiveInteger(parsed.offset, "offset");
+      const limitError = parsed.limit === void 0 ? void 0 : positiveInteger(parsed.limit, "limit");
+      if (offsetError || limitError) {
+        return toolResult({
+          context: toolContext,
+          toolName: "read",
+          ok: false,
+          content: null,
+          error: offsetError ?? limitError
+        });
+      }
       const resolved = resolveCoreToolPath(context, parsed.path);
-      const maxBytes = parsed.maxBytes ?? context.maxReadBytes;
+      const maxBytes = context.maxReadBytes;
       const invalidLimit = positiveNumber(maxBytes, "maxBytes");
       if (invalidLimit) {
         return toolResult({
@@ -1021,9 +1026,12 @@ function createReadTool(context) {
         });
       }
       const bytes = await readFile2(resolved.absolutePath);
-      const sliced = bytes.subarray(0, maxBytes);
+      const source = new TextDecoder().decode(bytes);
+      const selected = readTextLines(source, parsed.offset, parsed.limit);
+      const selectedBytes = new TextEncoder().encode(selected);
+      const sliced = selectedBytes.subarray(0, maxBytes);
       const text = new TextDecoder().decode(sliced);
-      const resourceType = parsed.type ?? detectResourceType(resolved.absolutePath);
+      const resourceType = detectResourceType(resolved.absolutePath);
       let name;
       let baseDir;
       if (resourceType === "skill" || resourceType === "phase") {
@@ -1034,16 +1042,14 @@ function createReadTool(context) {
       } else {
         name = inferResourceName(resolved.absolutePath, basename2(resolved.absolutePath));
       }
+      const formatted = resourceType === "skill" || resourceType === "phase" ? formatResourceOutput({ type: resourceType, name, location: resolved.absolutePath, content: text, baseDir }) : text;
+      const content = selectedBytes.byteLength > maxBytes ? `${formatted}
+[truncated]` : formatted;
       return toolResult({
         context: toolContext,
         toolName: "read",
         ok: true,
-        content: {
-          path: resolved.relativePath,
-          content: formatResourceOutput({ type: resourceType, name, location: resolved.absolutePath, content: text, baseDir }),
-          sizeBytes: bytes.byteLength,
-          truncated: bytes.byteLength > maxBytes
-        }
+        content
       });
     }
   };
@@ -1051,13 +1057,10 @@ function createReadTool(context) {
 function createWriteTool(context) {
   return {
     name: "write",
-    description: "Writes provided text content to a workspace file, creating parent directories as needed.",
+    description: "Create or overwrite a file in the workspace.",
     parameters: WriteArgsSchema,
-    promptSnippet: "Write content to a file (creates parent dirs automatically).",
-    promptGuidelines: [
-      "Use write for new files or full file rewrites.",
-      "For partial edits, prefer the edit tool to avoid overwriting unchanged content."
-    ],
+    promptSnippet: "Create or overwrite files.",
+    promptGuidelines: ["Use edit for partial changes."],
     async execute(args, toolContext) {
       const parsed = WriteArgsValidator.Parse(args);
       const resolved = resolveCoreToolPath(context, parsed.path);
@@ -1067,69 +1070,74 @@ function createWriteTool(context) {
         context: toolContext,
         toolName: "write",
         ok: true,
-        content: {
-          path: resolved.relativePath,
-          bytesWritten: new TextEncoder().encode(parsed.content).byteLength
-        }
+        content: `Successfully wrote ${parsed.content.length} bytes to ${resolved.relativePath}.`
       });
     }
   };
 }
+function applyEditReplacements(current, edits) {
+  if (edits.length === 0) {
+    throw new Error("edits must contain at least one replacement.");
+  }
+  const matches = [];
+  for (const edit of edits) {
+    if (!edit.oldText) throw new Error("oldText must not be empty.");
+    const start = current.indexOf(edit.oldText);
+    if (start < 0) throw new Error(`oldText not found in file.`);
+    const second = current.indexOf(edit.oldText, start + edit.oldText.length);
+    if (second >= 0) {
+      const count = current.split(edit.oldText).length - 1;
+      throw new Error(`oldText appears ${count} times; provide more context.`);
+    }
+    matches.push({ start, end: start + edit.oldText.length, newText: edit.newText });
+  }
+  matches.sort((a, b) => a.start - b.start);
+  for (let index = 1; index < matches.length; index += 1) {
+    const previous = matches[index - 1];
+    const currentMatch = matches[index];
+    if (currentMatch.start < previous.end) {
+      throw new Error("edits must not overlap.");
+    }
+  }
+  let content = current;
+  for (let index = matches.length - 1; index >= 0; index -= 1) {
+    const match = matches[index];
+    content = content.slice(0, match.start) + match.newText + content.slice(match.end);
+  }
+  return { content, replacements: matches.length };
+}
 function createEditTool(context) {
   return {
     name: "edit",
-    description: "Edits a workspace text file by replacing exact oldText with newText.",
+    description: "Apply exact text replacements to a workspace file.",
     parameters: EditArgsSchema,
-    promptSnippet: "Replace exact text in a file (oldText \u2192 newText).",
-    promptGuidelines: [
-      "Read the file first to get the exact oldText to replace.",
-      "oldText must be an exact match including whitespace and indentation.",
-      "If oldText appears multiple times, set replaceAll=true or provide more surrounding context."
-    ],
+    promptSnippet: "Apply exact text replacements.",
+    promptGuidelines: ["Read the file first; each oldText must match exactly once."],
     async execute(args, toolContext) {
       const parsed = EditArgsValidator.Parse(args);
-      if (!parsed.oldText) {
-        return toolResult({
-          context: toolContext,
-          toolName: "edit",
-          ok: false,
-          content: null,
-          error: "oldText must not be empty."
-        });
-      }
       const resolved = resolveCoreToolPath(context, parsed.path);
       const current = await readFile2(resolved.absolutePath, "utf8");
-      if (!current.includes(parsed.oldText)) {
-        return toolResult({
-          context: toolContext,
-          toolName: "edit",
-          ok: false,
-          content: null,
-          error: `oldText not found in ${resolved.relativePath}.`
-        });
-      }
-      const matches = current.split(parsed.oldText).length - 1;
-      if (matches > 1 && !parsed.replaceAll) {
+      let next;
+      let replacements;
+      try {
+        const result = applyEditReplacements(current, parsed.edits);
+        next = result.content;
+        replacements = result.replacements;
+      } catch (error) {
         return toolResult({
           context: toolContext,
           toolName: "edit",
           ok: false,
           content: null,
-          error: `oldText appears ${matches} times in ${resolved.relativePath}; set replaceAll=true or provide more context.`
+          error: error instanceof Error ? error.message : String(error)
         });
       }
-      const replacements = parsed.replaceAll ? matches : 1;
-      const next = parsed.replaceAll ? current.split(parsed.oldText).join(parsed.newText) : current.replace(parsed.oldText, parsed.newText);
       await writeFile(resolved.absolutePath, next, "utf8");
       return toolResult({
         context: toolContext,
         toolName: "edit",
         ok: true,
-        content: {
-          path: resolved.relativePath,
-          replacements,
-          bytesWritten: new TextEncoder().encode(next).byteLength
-        }
+        content: `Successfully replaced ${replacements} block(s) in ${resolved.relativePath}.`
       });
     }
   };
@@ -1137,19 +1145,15 @@ function createEditTool(context) {
 function createBashTool(context) {
   return {
     name: "bash",
-    description: "Runs a bash command within the workspace.",
+    description: "Run a bash command in the workspace.",
     parameters: BashArgsSchema,
-    promptSnippet: "Execute a bash command (30s timeout, 64KB output limit).",
-    promptGuidelines: [
-      "Use bash for build commands, tests, git operations, and system tools.",
-      "Prefer dedicated tools (read/write/edit) for file operations.",
-      "Set timeoutMs for long-running commands."
-    ],
+    promptSnippet: "Run shell commands.",
+    promptGuidelines: ["Use read/write/edit for file operations."],
     async execute(args, toolContext, signal) {
       const parsed = BashArgsValidator.Parse(args);
-      const timeoutMs = parsed.timeoutMs ?? context.bashTimeoutMs;
-      const maxOutputBytes = parsed.maxOutputBytes ?? context.maxBashOutputBytes;
-      const invalidTimeout = positiveNumber(timeoutMs, "timeoutMs");
+      const timeoutMs = parsed.timeout === void 0 ? context.bashTimeoutMs : parsed.timeout * 1e3;
+      const maxOutputBytes = context.maxBashOutputBytes;
+      const invalidTimeout = positiveNumber(timeoutMs, "timeout");
       const invalidOutputLimit = positiveNumber(maxOutputBytes, "maxOutputBytes");
       if (invalidTimeout || invalidOutputLimit) {
         return toolResult({
@@ -1160,7 +1164,7 @@ function createBashTool(context) {
           error: invalidTimeout ?? invalidOutputLimit
         });
       }
-      const cwd = resolveCoreToolPath(context, parsed.cwd ?? ".");
+      const cwd = resolveCoreToolPath(context, ".");
       let timedOut = false;
       let aborted = false;
       const proc = Bun.spawn(["bash", "-lc", parsed.command], {
@@ -1187,19 +1191,14 @@ function createBashTool(context) {
           proc.exited
         ]);
         const ok = exitCode === 0 && !timedOut && !aborted;
+        const output = [stdout.text, stderr.text].filter(Boolean).join(stdout.text && stderr.text ? "\n" : "");
+        const content = stdout.truncated || stderr.truncated ? `${output}
+[truncated]` : output;
         return toolResult({
           context: toolContext,
           toolName: "bash",
           ok,
-          content: {
-            command: parsed.command,
-            cwd: cwd.relativePath,
-            exitCode,
-            stdout: stdout.text,
-            stderr: stderr.text,
-            stdoutTruncated: stdout.truncated,
-            stderrTruncated: stderr.truncated
-          },
+          content,
           ...ok ? {} : {
             error: timedOut ? `Command timed out after ${timeoutMs}ms.` : aborted ? "Command aborted." : `Command exited with ${exitCode}.`
           }
@@ -1215,9 +1214,9 @@ function createCoreTools(input = {}) {
   const context = createCoreToolContext(input);
   return [
     createReadTool(context),
-    createWriteTool(context),
+    createBashTool(context),
     createEditTool(context),
-    createBashTool(context)
+    createWriteTool(context)
   ];
 }
 
@@ -1366,11 +1365,17 @@ function compactMessages(messages, options = {}) {
   );
   const recentStart = Math.max(messages.length - keepRecent, firstUserIdx + 1);
   const oldMessages = messages.slice(firstUserIdx >= 0 ? firstUserIdx + 1 : 0, recentStart);
-  if (oldMessages.length < minCompact) {
+  const protectedPhaseMessages = oldMessages.filter(
+    (message) => message.metadata?.kind === "phase_prompt"
+  );
+  const summarizableMessages = oldMessages.filter(
+    (message) => message.metadata?.kind !== "phase_prompt"
+  );
+  if (summarizableMessages.length < minCompact) {
     return { compacted: false, messages };
   }
   const recentMessages = messages.slice(recentStart);
-  const summary = buildSummary(oldMessages);
+  const summary = buildSummary(summarizableMessages);
   const result = [];
   if (firstUserIdx >= 0) {
     result.push(messages[firstUserIdx]);
@@ -1380,14 +1385,15 @@ function compactMessages(messages, options = {}) {
 
 ${summary}`, {
       type: "compaction_summary",
-      compactedCount: oldMessages.length
+      compactedCount: summarizableMessages.length
     })
   );
+  result.push(...protectedPhaseMessages);
   result.push(...recentMessages);
   return {
     compacted: true,
     messages: result,
-    summarizedCount: oldMessages.length,
+    summarizedCount: summarizableMessages.length,
     summary
   };
 }
@@ -1401,6 +1407,23 @@ function removePhaseMessage(messages, msgId) {
   const idx = messages.findIndex((m) => m.id === msgId);
   if (idx !== -1) messages.splice(idx, 1);
 }
+function findLatestUserInputMessage(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    const kind = message.metadata?.kind;
+    if (message.role === "user" && kind !== "phase_prompt" && kind !== "phase_input") {
+      return message;
+    }
+  }
+  return void 0;
+}
+function moveMessageBefore(messages, messageId, targetId) {
+  const messageIndex = messages.findIndex((message2) => message2.id === messageId);
+  const targetIndex = messages.findIndex((message2) => message2.id === targetId);
+  if (messageIndex === -1 || targetIndex === -1 || messageIndex < targetIndex) return;
+  const [message] = messages.splice(messageIndex, 1);
+  if (message) messages.splice(targetIndex, 0, message);
+}
 function normalizePayload(payload) {
   if (typeof payload === "string") {
     try {
@@ -1417,17 +1440,20 @@ function applyFirstDecision(route, output) {
   if (first.reason) output.routeReason = first.reason;
   if (first.payload !== void 0) output.payload = normalizePayload(first.payload);
 }
-function injectPhaseContent(phase, output, messageManager) {
+function injectPhaseContent(phase, output, messages, mirror) {
   try {
     const phaseContent = phase.filePath ? readPhaseContent(phase) : phase.content ?? phase.description ?? "";
     const content = buildPhaseDirectiveMessage(
       { name: phase.id, content: phaseContent },
-      output,
-      `phase_${phase.id}`
+      output
     );
-    const msgId = messageManager.start("tool", content, { phase: phase.id });
-    messageManager.end(msgId);
-    return msgId;
+    const message = createMessage("user", content, {
+      kind: "phase_prompt",
+      phase: phase.id
+    });
+    messages.push(message);
+    if (mirror && mirror !== messages) mirror.push(message);
+    return message.id;
   } catch {
     return void 0;
   }
@@ -1534,6 +1560,15 @@ function createToolResultContent(result) {
     }
   ];
 }
+function createRouteToolResultContent(toolCall) {
+  return [
+    {
+      type: "tool_result",
+      toolUseId: toolCall.id,
+      content: '{"ok": true}'
+    }
+  ];
+}
 async function executePhaseWithModel(ctx) {
   const executableToolNames = new Set(
     ctx.context.tools.filter((tool) => tool.name !== PhaseRouteTool).map((tool) => tool.name)
@@ -1556,6 +1591,13 @@ async function executePhaseWithModel(ctx) {
       phase: ctx.phase.name,
       toolCalls: collected.toolCalls
     };
+    for (const toolCall of collected.toolCalls) {
+      if (toolCall.name !== PhaseRouteTool) continue;
+      const messageId = ctx.messageManager.start("tool", createRouteToolResultContent(toolCall), {
+        phase: ctx.phase.id
+      });
+      await ctx.messageManager.end(messageId);
+    }
     const executableToolCalls = collected.toolCalls.filter(
       (toolCall) => executableToolNames.has(toolCall.name)
     );
@@ -1590,12 +1632,17 @@ async function startPhaseLoop(config, state) {
   return runPhaseLoop(config, state, registry);
 }
 async function runPhaseLoop(config, state, registry) {
-  let currentPhaseId = registry.entryPhaseId;
-  let isContinuing = false;
-  let previousPayload = void 0;
-  let previousPhaseMsgId = void 0;
-  let previousResults = [];
-  let pendingInstruction = void 0;
+  const resumingSuspendedRun = state.status === "suspended" && Boolean(state.currentPhase);
+  let currentPhaseId = resumingSuspendedRun ? state.currentPhase : registry.entryPhaseId;
+  let isContinuing = resumingSuspendedRun ? state.continuation?.isContinuing ?? true : false;
+  if (resumingSuspendedRun) {
+    state.status = "running";
+  }
+  let previousPayload = resumingSuspendedRun ? state.continuation?.previousPayload : void 0;
+  let previousPhaseMsgId = resumingSuspendedRun ? state.continuation?.previousPhaseMessageId : void 0;
+  let previousPhaseInputMsgId;
+  let previousResults = resumingSuspendedRun ? state.continuation?.previousResults?.map((result) => ({ ...result })) ?? [] : [];
+  let pendingInstruction = resumingSuspendedRun ? state.continuation?.pendingInstruction : void 0;
   while (currentPhaseId) {
     const availablePhases = [];
     for (const [, phase2] of registry.phases) {
@@ -1603,6 +1650,10 @@ async function runPhaseLoop(config, state, registry) {
     }
     const abortResult = LoopGuard.checkAbort(config.signal);
     if (abortResult.stopReason !== "none") {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
       return completeRun(config, state, createOutcome.aborted());
     }
     state.metrics.iterations++;
@@ -1640,6 +1691,10 @@ async function runPhaseLoop(config, state, registry) {
       messages: messageManager.visible(),
       tools: phaseTools,
       skills: phaseSkills,
+      invocation: {
+        mode: "serial",
+        instanceId: currentPhaseId
+      },
       state: {
         current: currentPhaseId,
         available: Array.from(registry.phases.keys()),
@@ -1656,10 +1711,18 @@ async function runPhaseLoop(config, state, registry) {
       const extBefore = await config.beforePhase(currentPhaseId, phaseContext);
       if (extBefore.abort) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+        previousPhaseMsgId = void 0;
+        previousPhaseInputMsgId = void 0;
         return completeRun(config, state, extBefore.abort);
       }
       if (extBefore.skip) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+        previousPhaseMsgId = void 0;
+        previousPhaseInputMsgId = void 0;
         if (extBefore.skip.route === "stop") {
           return completeRun(config, state, {
             id: "skip",
@@ -1673,21 +1736,45 @@ async function runPhaseLoop(config, state, registry) {
         phaseContext = extBefore.input;
       }
     }
-    removePhaseMessage(config.context.messages, previousPhaseMsgId);
-    previousPhaseMsgId = void 0;
-    if (enteringNewPhase) {
-      previousPhaseMsgId = injectPhaseContent(phase, { results: previousResults, instruction: pendingInstruction }, messageManager);
+    const phaseMessageIsPresent = previousPhaseMsgId !== void 0 && config.context.messages.some((message) => message.id === previousPhaseMsgId);
+    if (enteringNewPhase || !phaseMessageIsPresent) {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(phaseContext.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      removePhaseMessage(phaseContext.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
+      const latestUserInputMessage = findLatestUserInputMessage(config.context.messages);
+      const lastMessageBeforePhase = config.context.messages.at(-1);
+      previousPhaseMsgId = injectPhaseContent(
+        phase,
+        { results: previousResults, instruction: pendingInstruction },
+        config.context.messages,
+        phaseContext.messages
+      );
+      if (previousPhaseMsgId) {
+        if (lastMessageBeforePhase?.role === "user") {
+          moveMessageBefore(config.context.messages, previousPhaseMsgId, lastMessageBeforePhase.id);
+          moveMessageBefore(phaseContext.messages, previousPhaseMsgId, lastMessageBeforePhase.id);
+        } else if (latestUserInputMessage) {
+          const phaseInputMessage = createMessage("user", latestUserInputMessage.content, {
+            kind: "phase_input",
+            phase: phase.id
+          });
+          config.context.messages.push(phaseInputMessage);
+          phaseContext.messages.push(phaseInputMessage);
+          previousPhaseInputMsgId = phaseInputMessage.id;
+        }
+      }
       previousResults = [];
       pendingInstruction = void 0;
     }
     const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
     let output = await executePhase(runtime);
-    let routeToolCalled = false;
     let routeDecision;
     if (output.toolCalls && output.toolCalls.length > 0) {
       routeDecision = extractRouteCall(output.toolCalls);
       if (routeDecision) {
-        routeToolCalled = true;
         applyFirstDecision(routeDecision, output);
       }
     }
@@ -1695,6 +1782,10 @@ async function runPhaseLoop(config, state, registry) {
       const extAfter = await config.afterPhase(currentPhaseId, output);
       if (extAfter.abort) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+        previousPhaseMsgId = void 0;
+        previousPhaseInputMsgId = void 0;
         return completeRun(config, state, extAfter.abort);
       }
       if (extAfter.retry && (phase.run || phase.factory)) {
@@ -1714,28 +1805,52 @@ async function runPhaseLoop(config, state, registry) {
         if (preAbort.stopReason !== "none") {
           config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
           removePhaseMessage(config.context.messages, previousPhaseMsgId);
+          removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
           previousPhaseMsgId = void 0;
+          previousPhaseInputMsgId = void 0;
           return completeRun(config, state, createOutcome.aborted());
         }
-        config.emit?.({ type: "user_prompt_requested", phase: currentPhaseId, ts: createTimestamp() });
-        const userMessages = await config.waitForInput();
+        const requestedAt = createTimestamp();
+        const inputRequest = {
+          phase: currentPhaseId,
+          prompt: output.message,
+          requestedAt
+        };
+        config.emit?.({
+          type: "user_prompt_requested",
+          phase: currentPhaseId,
+          ts: requestedAt
+        });
+        state.status = "suspended";
+        state.continuation = {
+          isContinuing,
+          previousPayload,
+          previousResults: previousResults.map((result) => ({ ...result })),
+          pendingInstruction,
+          previousPhaseMessageId: previousPhaseMsgId
+        };
+        const userMessages = await config.waitForInput(state, inputRequest);
+        state.status = "running";
         const abortResult2 = LoopGuard.checkAbort(config.signal);
         if (abortResult2.stopReason !== "none") {
           config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
           removePhaseMessage(config.context.messages, previousPhaseMsgId);
+          removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
           previousPhaseMsgId = void 0;
+          previousPhaseInputMsgId = void 0;
           return completeRun(config, state, createOutcome.aborted());
         }
         for (const message of userMessages) {
           config.context.messages.push(message);
         }
-        removePhaseMessage(config.context.messages, previousPhaseMsgId);
-        previousPhaseMsgId = void 0;
         isContinuing = true;
         continue;
       }
       config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
       return completeRun(config, state, createOutcome.default(output, config.context.messages));
     }
     if (output.route === "continue") {
@@ -1747,6 +1862,8 @@ async function runPhaseLoop(config, state, registry) {
       const contextSnapshot = snapshotMessages(config.context.messages);
       const parallelTasks = /* @__PURE__ */ new Map();
       const instanceIds = buildInstanceIds(routeDecision.decision.map((t) => t.phase));
+      const groupId = createId("phase-group");
+      const count = routeDecision.decision.length;
       for (let i = 0; i < routeDecision.decision.length; i++) {
         const target = routeDecision.decision[i];
         const pt = registry.phases.get(target.phase);
@@ -1754,7 +1871,20 @@ async function runPhaseLoop(config, state, registry) {
         const instanceId = instanceIds[i];
         const context = pt.isolated ? [] : contextSnapshot;
         const payload = target.payload !== void 0 ? normalizePayload(target.payload) : void 0;
-        const promise = executeParallelPhase(config, state, registry, pt, payload, context, availablePhases, currentPhaseId);
+        const promise = executeParallelPhase(
+          config,
+          state,
+          registry,
+          pt,
+          payload,
+          context,
+          availablePhases,
+          instanceId,
+          groupId,
+          i,
+          count,
+          currentPhaseId
+        );
         parallelTasks.set(instanceId, { promise, phaseId: target.phase });
       }
       const successfulResults = await waitForBackgroundTasks(parallelTasks);
@@ -1762,6 +1892,10 @@ async function runPhaseLoop(config, state, registry) {
       pendingInstruction = routeDecision.instruction;
       const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+        previousPhaseMsgId = void 0;
+        previousPhaseInputMsgId = void 0;
         return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
       }
       currentPhaseId = entryPhaseId;
@@ -1777,12 +1911,18 @@ async function runPhaseLoop(config, state, registry) {
       nextRoute = "stop";
     }
     if (nextRoute === "stop") {
-      if (routeToolCalled) removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
       return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
     }
     const targetPhaseId = nextRoute;
     if (!registry.phases.has(targetPhaseId)) {
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
       return completeRun(config, state, createOutcome.phaseNotFound(output));
     }
     state.metrics.phaseTransitions.push({
@@ -1898,24 +2038,31 @@ async function executePhase(ctx) {
   return executePhaseWithModel(ctx);
 }
 async function executeToolCall(input) {
+  let result;
   if (input.config.runtime?.tools) {
-    return input.config.runtime.tools({
+    result = await input.config.runtime.tools({
       config: input.config,
       toolCall: input.toolCall
     });
+  } else {
+    const toolContext = {
+      skills: input.config.context.skills,
+      toolCallId: input.toolCall.id
+    };
+    result = await executeRuntimeToolCall({
+      tools: input.tools,
+      toolCall: input.toolCall,
+      toolContext,
+      beforeToolCall: input.config.beforeToolCall,
+      afterToolCall: input.config.afterToolCall,
+      signal: input.config.signal
+    });
   }
-  const toolContext = {
-    skills: input.config.context.skills,
-    toolCallId: input.toolCall.id
+  return {
+    ...result,
+    toolCallId: input.toolCall.id,
+    toolName: input.toolCall.name
   };
-  return executeRuntimeToolCall({
-    tools: input.tools,
-    toolCall: input.toolCall,
-    toolContext,
-    beforeToolCall: input.config.beforeToolCall,
-    afterToolCall: input.config.afterToolCall,
-    signal: input.config.signal
-  });
 }
 function createPhaseExecution(config, state, allTools, phase, messageManager, toolExecutionManager, registry) {
   return {
@@ -1999,17 +2146,25 @@ function createPhaseExecution(config, state, allTools, phase, messageManager, to
     }
   };
 }
-async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, currentPhaseId) {
+async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const allTools = buildToolsWithRouting(config, availablePhases);
   const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
   const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
-  const systemPrompt = phase.isolated ? readPhaseContent(phase) : config.context.systemPrompt;
+  const systemPrompt = config.context.systemPrompt;
   const phaseContext = {
     systemPrompt,
     messages,
     tools: phaseTools,
     skills: phaseSkills,
+    invocation: {
+      mode: "parallel",
+      instanceId,
+      groupId,
+      index,
+      count,
+      sourcePhaseId
+    },
     state: {
       current: phase.id,
       available: Array.from(registry.phases.keys()),
@@ -2018,10 +2173,10 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
     }
   };
   const messageManager = createMessageManager({ messages }, config.emit, config.onMessage);
-  const phaseMsgId = phase.isolated ? void 0 : injectPhaseContent(
+  const phaseMsgId = injectPhaseContent(
     phase,
-    { results: payload !== void 0 ? [{ name: currentPhaseId, output: payload }] : [] },
-    messageManager
+    { results: payload !== void 0 ? [{ name: sourcePhaseId, output: payload }] : [] },
+    messages
   );
   const toolExecutionManager = createToolExecutionManager(config.emit);
   const execution = createPhaseExecution(config, state, phaseTools, phase, messageManager, toolExecutionManager, registry);
@@ -2030,7 +2185,7 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
   const decision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
   const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
-  return { instanceId: "", phaseId: phase.id, payload: resultPayload, content: output.message };
+  return { instanceId, phaseId: phase.id, payload: resultPayload, content: output.message };
 }
 async function waitForBackgroundTasks(backgroundTasks) {
   const entries = Array.from(backgroundTasks.entries());
@@ -3224,19 +3379,29 @@ var AgentExecution = class {
   runWithMessage(message, options, internalHooks = {}) {
     const activeRun = this.activeRun;
     if (activeRun?.resume) {
+      if (internalHooks.onSuspend) activeRun.onSuspend = internalHooks.onSuspend;
       activeRun.resume([message]);
       return activeRun.promise;
     }
     if (activeRun) {
       return Promise.reject(new Error("Agent is already running."));
     }
-    this.appendMessage(message);
+    if (!this.options.context.messages.some((candidate) => candidate.id === message.id)) {
+      this.appendMessage(message);
+    }
     return this.run(options, internalHooks);
   }
   /** Internal Runtime seam: executes one leased Agent Input. */
-  async executeAgentInput(input, runId, control) {
+  async executeAgentInput(input, runId, control, executionState) {
     this.runtimeRunId = runId;
-    const internal = { onSuspend: control.suspend };
+    this.options.sessionState = executionState ? restoreSessionState(executionState) : void 0;
+    const internal = {
+      onSuspend: (reason, state, inputRequest) => control.suspend(
+        reason,
+        state ? snapshotExecutionState(state) : void 0,
+        inputRequest
+      )
+    };
     try {
       return (await this.runWithMessage(input, void 0, internal)).outcome;
     } finally {
@@ -3473,18 +3638,20 @@ var AgentExecution = class {
     }
     const abortController = new AbortController();
     let suspensionRequested = false;
-    const waitForInput = () => {
-      if (!suspensionRequested) {
-        suspensionRequested = true;
-        void hooks.onSuspend?.("Agent requested input.");
-      }
-      return new Promise((resolve7) => {
+    const waitForInput = (state, inputRequest) => {
+      const waiting = new Promise((resolve7) => {
         const activeRun = this.activeRun;
         activeRun.resume = (messages) => {
           activeRun.resume = void 0;
+          suspensionRequested = false;
           resolve7(messages);
         };
       });
+      if (!suspensionRequested) {
+        suspensionRequested = true;
+        void this.activeRun?.onSuspend?.("Agent requested input.", state, inputRequest);
+      }
+      return waiting;
     };
     const promise = Promise.resolve().then(() => executor({ signal: abortController.signal, waitForInput })).catch((error) => {
       this.handleRunFailure(error, abortController.signal.aborted);
@@ -3492,7 +3659,7 @@ var AgentExecution = class {
     }).finally(() => {
       this.finishRun();
     });
-    this.activeRun = { promise, abortController };
+    this.activeRun = { promise, abortController, onSuspend: hooks.onSuspend };
     this.state.running = true;
     return promise;
   }
@@ -3525,7 +3692,8 @@ var AgentExecution = class {
       const extensions = resolved.extensions ?? [];
       await this.loadExtensions(extensions, resolved.cwd);
       const runContext = prepareAgentContext(resolved.context, this.extensionRunner);
-      const entryPhaseId = this.state.initialized ? DEFAULT_PHASE_ID : runContext.phases?.entryPhaseId ?? DEFAULT_PHASE_ID;
+      const resumingSuspendedRun = resolved.sessionState?.status === "suspended";
+      const entryPhaseId = resumingSuspendedRun ? resolved.sessionState?.currentPhase || runContext.phases?.entryPhaseId || DEFAULT_PHASE_ID : this.state.initialized ? DEFAULT_PHASE_ID : runContext.phases?.entryPhaseId ?? DEFAULT_PHASE_ID;
       const loopContext = {
         ...runContext,
         phases: {
@@ -3570,6 +3738,7 @@ var AgentExecution = class {
         model: resolved.model,
         stream: resolved.stream,
         maxAttempts: resolved.maxAttempts,
+        sessionState: resolved.sessionState,
         signal,
         beforeToolCall,
         afterToolCall,
@@ -3594,7 +3763,8 @@ var AgentExecution = class {
       this.options = {
         ...resolved,
         sessionId: result.sessionId,
-        context: nextContext
+        context: nextContext,
+        sessionState: void 0
       };
       return result;
     }, internalHooks);
@@ -3602,6 +3772,9 @@ var AgentExecution = class {
   abort(reason = "Aborted by caller.") {
     this.abortLocal(reason);
   }
+  isSuspended() {
+    return Boolean(this.activeRun?.resume);
+  }
   abortLocal(reason) {
     const activeRun = this.activeRun;
     activeRun?.resume?.([]);
@@ -3676,6 +3849,50 @@ ${additionalInstructions}` : content;
     };
   }
 };
+function restoreSessionState(state) {
+  const persisted = parsePersistedExecutionState(state);
+  return {
+    ...persisted,
+    status: "suspended",
+    metrics: {
+      ...persisted.metrics,
+      phaseTransitions: persisted.metrics.phaseTransitions.map((transition) => ({ ...transition }))
+    },
+    ...persisted.continuation ? {
+      continuation: {
+        ...persisted.continuation,
+        previousResults: persisted.continuation.previousResults.map((result) => ({ ...result }))
+      }
+    } : {}
+  };
+}
+function snapshotExecutionState(state) {
+  return {
+    version: 1,
+    currentPhase: state.currentPhase,
+    attempt: state.attempt,
+    metrics: {
+      ...state.metrics,
+      phaseTransitions: state.metrics.phaseTransitions.map((transition) => ({ ...transition }))
+    },
+    ...state.continuation ? {
+      continuation: {
+        ...state.continuation,
+        previousResults: state.continuation.previousResults.map((result) => ({ ...result }))
+      }
+    } : {}
+  };
+}
+function parsePersistedExecutionState(state) {
+  if (!state || state.version !== 1 || typeof state.currentPhase !== "string" || typeof state.attempt !== "number") {
+    throw new Error("Invalid Agent Run execution checkpoint.");
+  }
+  const metrics = state.metrics;
+  if (!metrics || !Array.isArray(metrics.phaseTransitions)) {
+    throw new Error("Invalid Agent Run execution checkpoint metrics.");
+  }
+  return state;
+}
 function clonePhaseRegistry(registry) {
   return {
     phases: new Map(registry.phases),
@@ -3755,6 +3972,8 @@ async function attachAgent(input) {
     phases: input.options.context.phases
   };
   const persistInput = async (message) => {
+    const context2 = await input.manager.buildAgentContext();
+    if (context2.messages.some((candidate) => candidate.id === message.id)) return;
     await input.manager.appendMessage(message);
   };
   let execution;
@@ -3813,7 +4032,9 @@ async function attachAgent(input) {
     agent,
     binding: {
       abort: (reason) => execution.abortFromRuntime(reason),
-      execute: (message, runId, control) => execution.executeAgentInput(message, runId, control)
+      isSuspended: () => execution.isSuspended(),
+      persistInput,
+      execute: (message, runId, control, executionState) => execution.executeAgentInput(message, runId, control, executionState)
     }
   };
 }
@@ -4240,8 +4461,8 @@ var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
   }
 };
 
-// src/harness/session/provider.ts
-var InMemorySessionProvider = class {
+// src/harness/session/store.ts
+var InMemorySessionStore = class {
   sessions = /* @__PURE__ */ new Map();
   async create(input) {
     const session = InMemorySessionManager.create(input);
@@ -4252,7 +4473,7 @@ var InMemorySessionProvider = class {
     return this.sessions.get(sessionId);
   }
 };
-var LocalJsonlSessionProvider = class {
+var JsonlSessionStore = class {
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
   }
@@ -4268,6 +4489,9 @@ var LocalJsonlSessionProvider = class {
   }
 };
 
+// src/runtime/agent-runtime.ts
+import { createModelStream } from "@rowan-agent/models";
+
 // src/runtime/tool-runtime.ts
 function failed(toolCall, message) {
   return {
@@ -4469,6 +4693,9 @@ var AgentRun = class _AgentRun {
   get state() {
     return this.current.state;
   }
+  get inputRequest() {
+    return this.current.inputRequest ? structuredClone(this.current.inputRequest) : void 0;
+  }
   async getStatus() {
     const run = await this.host.getRun(this.id);
     if (run) this.notify(run);
@@ -4533,8 +4760,8 @@ var AgentRuntime = class _AgentRuntime {
   leaseDurationMs;
   leaseRenewalIntervalMs;
   toolRuntime;
-  factories;
   bindings = /* @__PURE__ */ new Map();
+  agents = /* @__PURE__ */ new Map();
   runHandles = /* @__PURE__ */ new Map();
   runWaiters = /* @__PURE__ */ new Map();
   pendingRuns = [];
@@ -4546,6 +4773,7 @@ var AgentRuntime = class _AgentRuntime {
   runningRuns = 0;
   pumping = false;
   nextWorkerId = 0;
+  leaseRecoveryTimer;
   stopped = false;
   constructor(options) {
     this.stateStore = options.stateStore;
@@ -4555,10 +4783,6 @@ var AgentRuntime = class _AgentRuntime {
     this.leaseDurationMs = options.leaseDurationMs ?? 6e4;
     this.leaseRenewalIntervalMs = options.leaseRenewalIntervalMs ?? Math.max(1, Math.floor(this.leaseDurationMs / 2));
     this.toolRuntime = new ToolRuntime(options.stateStore, options.toolPolicy, () => this.publishEvents());
-    this.factories = options.factories instanceof Map ? new Map([...options.factories.entries()].map(([id, factory]) => [String(id), factory])) : new Map(Object.entries(options.factories ?? {}));
-    for (const id of this.factories.keys()) {
-      if (id.trim().length === 0) throw new Error("Factory ID must not be empty.");
-    }
   }
   static async start(options) {
     if (activeRuntime) {
@@ -4585,6 +4809,7 @@ var AgentRuntime = class _AgentRuntime {
     activeRuntime = runtime;
     try {
       await runtime.recover();
+      runtime.startLeaseRecovery();
       return runtime;
     } catch (error) {
       await runtime.stop().catch(() => void 0);
@@ -4593,20 +4818,16 @@ var AgentRuntime = class _AgentRuntime {
   }
   async createAgent(options) {
     this.assertRunning();
-    if (options.factoryId !== void 0 && options.factoryId.trim().length === 0) {
-      throw new Error("Factory ID must not be empty.");
-    }
+    assertAgentOptions(options);
     const provider = this.sessionProvider;
     if (!provider) throw new Error("Agent Runtime requires a SessionManager provider to create an Agent.");
     const manager = await provider.create({
       systemPrompt: options.context.systemPrompt,
-      input: options.input ?? "",
+      input: "",
       skills: options.context.skills
     });
-    if (options.input) await manager.appendMessage(createMessage("user", options.input));
     const record = await this.stateStore.createAgent({
-      sessionId: manager.getSessionId(),
-      ...options.factoryId ? { factoryId: options.factoryId } : {}
+      sessionId: manager.getSessionId()
     });
     this.pausedAgents.delete(record.id);
     const agent = await this.attachAgent(record, manager, options);
@@ -4615,6 +4836,7 @@ var AgentRuntime = class _AgentRuntime {
   }
   async reconstructAgent(agentId, options) {
     this.assertRunning();
+    assertAgentOptions(options);
     const record = await this.stateStore.getAgent(agentId);
     if (!record) throw new Error(`Agent not found: ${agentId}.`);
     if (record.state === "paused") this.pausedAgents.add(record.id);
@@ -4630,10 +4852,23 @@ var AgentRuntime = class _AgentRuntime {
   async stop() {
     if (this.stopped) return;
     this.stopped = true;
-    for (const binding of this.bindings.values()) {
-      binding.abort("Agent Runtime stopped.");
+    if (this.leaseRecoveryTimer) {
+      clearInterval(this.leaseRecoveryTimer);
+      this.leaseRecoveryTimer = void 0;
+    }
+    let suspendedAgents;
+    try {
+      suspendedAgents = new Set(
+        (await this.stateStore.listRuns({ states: ["suspended"] })).map((run) => run.agentId)
+      );
+    } catch {
+      suspendedAgents = /* @__PURE__ */ new Set();
+    }
+    for (const [agentId, binding] of this.bindings) {
+      if (!suspendedAgents.has(agentId) && !binding.isSuspended()) binding.abort("Agent Runtime stopped.");
     }
     this.bindings.clear();
+    this.agents.clear();
     this.pendingRuns.length = 0;
     this.scheduledRunIds.clear();
     this.pausedAgents.clear();
@@ -4653,6 +4888,7 @@ var AgentRuntime = class _AgentRuntime {
       throw new Error(`Agent ${agentId} is already bound to a live Agent.`);
     }
     this.bindings.set(agentId, agent);
+    void this.pump();
     if (!this.pausedAgents.has(agentId)) void this.scheduleQueuedRuns(agentId);
   }
   registerRunHandle(runId, handle) {
@@ -4702,6 +4938,24 @@ var AgentRuntime = class _AgentRuntime {
     void this.pump();
     this.publishEvents();
   }
+  async getRun(runId) {
+    return this.stateStore.getRun(runId);
+  }
+  async listActiveRuns() {
+    return this.stateStore.listActiveRuns();
+  }
+  async listRuns(input) {
+    return this.stateStore.listRuns(input);
+  }
+  getAgent(agentId) {
+    return this.agents.get(agentId);
+  }
+  async getMessage(messageId) {
+    return this.stateStore.getMessage(messageId);
+  }
+  async getToolCall(toolCallId) {
+    return this.stateStore.getToolCall(toolCallId);
+  }
   async abortRun(runId, reason = "Agent Run aborted by caller.") {
     const run = await this.stateStore.getRun(runId);
     if (!run || ["completed", "failed", "cancelled"].includes(run.state)) return;
@@ -4722,6 +4976,11 @@ var AgentRuntime = class _AgentRuntime {
     this.publishEvents();
   }
   consumeEvents(consumerId, listener) {
+    const subscription = this.registerEventConsumer(consumerId, listener);
+    void subscription.caughtUp.catch(() => void 0);
+    return subscription;
+  }
+  registerEventConsumer(consumerId, listener) {
     this.assertRunning();
     if (consumerId.trim().length === 0) {
       throw new Error("Runtime Event Consumer ID must not be empty.");
@@ -4736,58 +4995,78 @@ var AgentRuntime = class _AgentRuntime {
       redeliver: false
     };
     this.eventSubscriptions.set(consumerId, subscription);
-    void this.deliverEvents(subscription).catch(() => void 0);
-    return () => {
+    let caughtUpSettled = false;
+    let resolveCaughtUp;
+    let rejectCaughtUp;
+    const caughtUp = new Promise((resolve7, reject) => {
+      resolveCaughtUp = resolve7;
+      rejectCaughtUp = reject;
+    });
+    const stop = () => {
       if (this.eventSubscriptions.get(consumerId) === subscription) {
         this.eventSubscriptions.delete(consumerId);
       }
+      if (!caughtUpSettled) {
+        caughtUpSettled = true;
+        const error = new Error("Runtime Event Consumer stopped before catch-up completed.");
+        error.name = "AbortError";
+        rejectCaughtUp(error);
+      }
     };
+    void this.deliverEvents(subscription).then(
+      () => {
+        if (!caughtUpSettled) {
+          caughtUpSettled = true;
+          resolveCaughtUp();
+        }
+      },
+      (error) => {
+        if (!caughtUpSettled) {
+          caughtUpSettled = true;
+          rejectCaughtUp(error);
+        }
+      }
+    );
+    return { caughtUp, stop };
   }
   async listEvents(cursor) {
     return this.stateStore.listEvents(cursor);
   }
   async recover() {
-    await this.stateStore.recoverLeases();
+    await this.recoverExpiredLeases();
     const agents = await this.stateStore.listAgents();
     for (const record of agents) {
       if (record.state === "paused") this.pausedAgents.add(record.id);
     }
-    for (const record of agents) {
-      if (record.state !== "active" || !record.factoryId) continue;
-      const factory = this.factories.get(String(record.factoryId));
-      if (!factory) {
-        await this.stateStore.recordEvent({ kind: "factory_missing", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
-        continue;
-      }
-      try {
-        const options = await factory({ agentId: record.id, sessionId: record.sessionId, factoryId: record.factoryId });
-        if (!options) {
-          await this.stateStore.recordEvent({
-            kind: "agent_recovery_failed",
-            related: { agentId: record.id },
-            payload: { factoryId: record.factoryId, error: "Factory returned no reconstruction options." }
-          });
-          continue;
-        }
-        await this.reconstructAgent(record.id, options);
-        await this.stateStore.recordEvent({ kind: "agent_recovered", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
-      } catch (error) {
-        await this.stateStore.recordEvent({ kind: "agent_recovery_failed", related: { agentId: record.id }, payload: { factoryId: record.factoryId, error: error instanceof Error ? error.message : String(error) } });
-      }
-    }
-    for (const record of await this.stateStore.listAgents()) {
-      if (this.bindings.has(record.id)) await this.scheduleQueuedRuns(record.id);
-    }
     this.publishEvents();
   }
+  startLeaseRecovery() {
+    this.leaseRecoveryTimer = setInterval(() => {
+      void this.recoverExpiredLeases().catch(() => void 0);
+    }, this.leaseRenewalIntervalMs);
+  }
+  async recoverExpiredLeases() {
+    const recovered = await this.stateStore.recoverExpiredLeases();
+    for (const run of recovered) {
+      this.notifyRun(run);
+      if (this.bindings.has(run.agentId)) this.scheduleRun(run.agentId, run.id);
+    }
+    if (recovered.length > 0) this.publishEvents();
+  }
   async scheduleQueuedRuns(agentId) {
     if (!this.bindings.has(agentId)) return;
     const runs = await this.stateStore.listRuns({ agentId, states: ["queued"] });
     for (const run of runs) this.scheduleRun(agentId, run.id);
   }
   async attachAgent(record, manager, options) {
+    const model = { provider: options.model.provider, id: options.model.id };
+    const resolvedOptions = {
+      ...options,
+      model,
+      stream: options.stream ?? createModelStream(options.model)
+    };
     const attached = await attachAgent({
-      options,
+      options: resolvedOptions,
       agentId: record.id,
       sessionId: record.sessionId,
       manager,
@@ -4795,6 +5074,7 @@ var AgentRuntime = class _AgentRuntime {
       executeTool: (input) => this.toolRuntime.execute(input)
     });
     this.bindAgent(record.id, attached.binding);
+    this.agents.set(record.id, attached.agent);
     return attached.agent;
   }
   async submitAgentInput(agentId, input, persist) {
@@ -4802,6 +5082,7 @@ var AgentRuntime = class _AgentRuntime {
     if (!this.bindings.has(agentId)) throw new Error(`Agent ${agentId} has no live Agent Binding.`);
     const enqueued = await this.stateStore.enqueueAgentInput({ agentId, input });
     await persist();
+    if (enqueued.resumed) this.notifyRun(enqueued.run);
     const run = createAgentRun({
       register: (handle) => this.registerRunHandle(enqueued.run.id, handle),
       getRun: (runId) => this.stateStore.getRun(runId),
@@ -4849,10 +5130,10 @@ var AgentRuntime = class _AgentRuntime {
       suspendedResolve = resolve7;
     });
     const control = {
-      suspend: async (reason) => {
+      suspend: async (reason, executionState, inputRequest) => {
         if (suspended) return;
         suspended = true;
-        const current = await this.stateStore.suspendRun({ runId: job.runId, reason });
+        const current = await this.stateStore.suspendRun({ runId: job.runId, reason, executionState, inputRequest });
         this.notifyRun(current);
         this.publishEvents();
         suspendedResolve?.();
@@ -4871,6 +5152,11 @@ var AgentRuntime = class _AgentRuntime {
         leaseDurationMs: this.leaseDurationMs
       });
       this.notifyRun(leased.run);
+      try {
+        await binding.persistInput(leased.message.input);
+      } catch (error) {
+        throw new InfrastructureFailureError("Agent Input persistence failed.", { cause: error });
+      }
       renewalTimer = setInterval(() => {
         void this.stateStore.renewLease({
           runId: job.runId,
@@ -4884,7 +5170,7 @@ var AgentRuntime = class _AgentRuntime {
           failRenewal(failure);
         });
       }, this.leaseRenewalIntervalMs);
-      const execution = binding.execute(leased.message.input, job.runId, control);
+      const execution = binding.execute(leased.message.input, job.runId, control, leased.run.executionState);
       const outcome = await Promise.race([
         execution.then((value) => ({ kind: "terminal", value })).catch((error) => ({ kind: "error", error })),
         suspendedSignal.then(() => ({ kind: "suspended" })),
@@ -4976,8 +5262,21 @@ var AgentRuntime = class _AgentRuntime {
         );
         for (const event of events) {
           if (this.eventSubscriptions.get(subscription.consumerId) !== subscription) return;
-          await subscription.listener(structuredClone(event));
-          await this.stateStore.acknowledgeEvent(subscription.consumerId, event.id);
+          const disposition = await subscription.listener(structuredClone(event));
+          if (disposition?.type === "enqueue") {
+            const delivered = await this.stateStore.acknowledgeEventAndEnqueueAgentInput({
+              consumerId: subscription.consumerId,
+              eventId: event.id,
+              agentId: disposition.agentId,
+              input: disposition.input
+            });
+            if (delivered.enqueued) {
+              this.scheduleRun(delivered.enqueued.run.agentId, delivered.enqueued.run.id);
+              this.publishEvents();
+            }
+          } else {
+            await this.stateStore.acknowledgeEvent(subscription.consumerId, event.id);
+          }
         }
       } while (subscription.redeliver);
     } finally {
@@ -4988,11 +5287,25 @@ var AgentRuntime = class _AgentRuntime {
     if (this.stopped || activeRuntime !== this) throw new Error("Agent Runtime is stopped.");
   }
 };
+function isModelConfig(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "protocol" in value && "baseUrl" in value && "apiKey" in value;
+}
+function assertAgentOptions(options) {
+  if (options.stream && isModelConfig(options.model)) {
+    throw new Error("AgentOptions accepts either a complete model config or a custom stream, not both.");
+  }
+}
 function isRetryableInfrastructureError(error) {
   if (error instanceof InfrastructureFailureError) return true;
   return typeof error === "object" && error !== null && "retryable" in error && error.retryable === true;
 }
 
+// src/runtime/domain.ts
+function runEventPayload(metadata, payload = {}) {
+  return metadata ? { ...payload, metadata: structuredClone(metadata) } : payload;
+}
+
 // src/runtime/memory-store.ts
 function clone2(value) {
   return structuredClone(value);
@@ -5021,7 +5334,6 @@ var InMemoryRuntimeStateStore = class {
     const agent = {
       id: createId("agt"),
       sessionId: input.sessionId,
-      ...input.factoryId ? { factoryId: input.factoryId } : {},
       state: "active",
       createdAt: timestamp,
       updatedAt: timestamp
@@ -5047,6 +5359,9 @@ var InMemoryRuntimeStateStore = class {
     return clone2(agent);
   }
   async enqueueAgentInput(input) {
+    return this.enqueueAgentInputState(input);
+  }
+  enqueueAgentInputState(input) {
     this.requireAgent(input.agentId);
     const suspended = [...this.runs.values()].filter((run2) => run2.agentId === input.agentId && run2.state === "suspended").sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
     const { timestamp } = now();
@@ -5067,6 +5382,7 @@ var InMemoryRuntimeStateStore = class {
       suspended.state = "queued";
       suspended.messageId = messageId;
       delete suspended.suspensionReason;
+      delete suspended.inputRequest;
       suspended.updatedAt = timestamp;
       message.runId = suspended.id;
     }
@@ -5076,13 +5392,14 @@ var InMemoryRuntimeStateStore = class {
       messageId,
       state: "queued",
       attempt: 0,
+      ...suspended?.metadata ? { metadata: clone2(suspended.metadata) } : input.input.metadata ? { metadata: clone2(input.input.metadata) } : {},
       createdAt: timestamp,
       updatedAt: timestamp
     };
     this.messages.set(message.id, message);
     this.runs.set(run.id, suspended ?? run);
     this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
-    this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
+    this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId }, runEventPayload(suspended?.metadata ?? input.input.metadata));
     return { message: clone2(message), run: clone2(suspended ?? run), resumed: Boolean(suspended) };
   }
   async getMessage(messageId) {
@@ -5094,7 +5411,10 @@ var InMemoryRuntimeStateStore = class {
     return run ? clone2(run) : void 0;
   }
   async listRuns(input = {}) {
-    return clone2([...this.runs.values()].filter((run) => input.agentId === void 0 || run.agentId === input.agentId).filter((run) => !input.states || input.states.includes(run.state)).sort((a, b) => a.createdAt.localeCompare(b.createdAt)));
+    return clone2([...this.runs.values()].filter((run) => input.agentId === void 0 || run.agentId === input.agentId).filter((run) => !input.states || input.states.includes(run.state)).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || String(a.id).localeCompare(String(b.id))));
+  }
+  async listActiveRuns() {
+    return this.listRuns({ states: ["queued", "running", "suspended"] });
   }
   async leaseRun(input) {
     const run = this.requireRun(input.runId);
@@ -5159,15 +5479,17 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "suspended";
     run.suspensionReason = input.reason;
+    if (input.inputRequest) run.inputRequest = clone2(input.inputRequest);
+    if (input.executionState) run.executionState = clone2(input.executionState);
     delete run.leaseId;
     run.updatedAt = timestamp;
     requireTransition("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
     message.state = "acknowledged";
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_suspended", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_suspended", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
       reason: input.reason
-    });
+    }));
     return clone2(run);
   }
   async completeRun(input) {
@@ -5179,15 +5501,17 @@ var InMemoryRuntimeStateStore = class {
     const state = input.state ?? "completed";
     run.state = state;
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     message.state = "acknowledged";
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_completed", { agentId: run.agentId, messageId: run.messageId, runId: run.id }, {
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: run.messageId, runId: run.id }, runEventPayload(run.metadata, {
       state,
       outcome: input.outcome
-    });
+    }));
     this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
     return clone2(run);
   }
@@ -5218,16 +5542,18 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "failed";
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     message.state = "dead_lettered";
     message.deadLetterReason = input.reason;
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_completed", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
       state: "failed",
       outcome: input.outcome
-    });
+    }));
     this.recordEvent("message_dead_lettered", { agentId: run.agentId, messageId: message.id }, {
       reason: input.reason
     });
@@ -5240,6 +5566,8 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "cancelled";
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     if (message.state === "queued" || message.state === "leased") {
@@ -5247,9 +5575,10 @@ var InMemoryRuntimeStateStore = class {
       delete message.lease;
       message.updatedAt = timestamp;
     }
-    this.recordEvent("run_aborted", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_aborted", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
+      state: "cancelled",
       outcome: input.outcome
-    });
+    }));
     return clone2(run);
   }
   async recoverExpiredLeases(input) {
@@ -5390,6 +5719,29 @@ var InMemoryRuntimeStateStore = class {
     this.eventCheckpoints.set(consumerId, checkpoint);
     return clone2(checkpoint);
   }
+  async acknowledgeEventAndEnqueueAgentInput(input) {
+    const event = this.events.find((candidate) => candidate.id === input.eventId);
+    if (!event) throw new Error(`Runtime Event not found: ${input.eventId}.`);
+    const current = this.eventCheckpoints.get(input.consumerId) ?? {
+      consumerId: input.consumerId,
+      sequence: 0,
+      updatedAt: createTimestamp(/* @__PURE__ */ new Date(0))
+    };
+    if (event.sequence <= current.sequence) return { checkpoint: clone2(current) };
+    if (event.sequence !== current.sequence + 1) {
+      throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+    }
+    this.requireAgent(input.agentId);
+    const enqueued = this.enqueueAgentInputState(input);
+    const checkpoint = {
+      consumerId: input.consumerId,
+      sequence: event.sequence,
+      eventId: event.id,
+      updatedAt: createTimestamp()
+    };
+    this.eventCheckpoints.set(input.consumerId, checkpoint);
+    return { checkpoint: clone2(checkpoint), enqueued };
+  }
   requireAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -5438,7 +5790,6 @@ var RUNTIME_SCHEMA_SQL = `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY NOT NULL,
       session_id TEXT NOT NULL,
-      factory_id TEXT,
       state TEXT NOT NULL CHECK (state IN ('active', 'paused')),
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
@@ -5466,6 +5817,9 @@ var RUNTIME_SCHEMA_SQL = `
       lease_id TEXT,
       outcome_json TEXT,
       suspension_reason TEXT,
+      input_request_json TEXT,
+      execution_state_json TEXT,
+      metadata_json TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );
@@ -5528,6 +5882,11 @@ function initializeRuntimeSchema(database) {
         database.run(sql);
       }
     }
+    try {
+      database.run("ALTER TABLE agent_runs ADD COLUMN metadata_json TEXT");
+    } catch (error) {
+      if (!(error instanceof Error) || !/duplicate column name/i.test(error.message)) throw error;
+    }
   });
   initialize();
 }
@@ -5572,15 +5931,14 @@ var SqliteRuntimeStateStore = class {
     const agent = {
       id: createId("agt"),
       sessionId: input.sessionId,
-      ...input.factoryId ? { factoryId: input.factoryId } : {},
       state: "active",
       createdAt: timestamp,
       updatedAt: timestamp
     };
     const create = this.database.transaction(() => {
       this.database.run(
-        "INSERT INTO agents (id, session_id, factory_id, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-        [agent.id, agent.sessionId, agent.factoryId ?? null, agent.state, agent.createdAt, agent.updatedAt]
+        "INSERT INTO agents (id, session_id, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+        [agent.id, agent.sessionId, agent.state, agent.createdAt, agent.updatedAt]
       );
       this.recordEvent("agent_created", { agentId: agent.id });
     });
@@ -5607,6 +5965,10 @@ var SqliteRuntimeStateStore = class {
     return clone3(updated);
   }
   async enqueueAgentInput(input) {
+    const enqueue = this.database.transaction(() => this.enqueueAgentInputState(input));
+    return clone3(enqueue());
+  }
+  enqueueAgentInputState(input) {
     this.requireAgent(input.agentId);
     const { timestamp } = timestampFor();
     const messageId = createId("rmsg");
@@ -5631,30 +5993,28 @@ var SqliteRuntimeStateStore = class {
       messageId,
       state: "queued",
       attempt: 0,
+      ...suspendedRow?.metadata_json ? { metadata: parse(suspendedRow.metadata_json) } : input.input.metadata ? { metadata: clone3(input.input.metadata) } : {},
       createdAt: timestamp,
       updatedAt: timestamp
     };
     if (suspendedRow) {
       message.runId = runId;
     }
-    const enqueue = this.database.transaction(() => {
-      this.insertMessage(message);
-      if (suspendedRow) {
-        this.database.run(
-          "UPDATE agent_runs SET message_id = ?, state = 'queued', lease_id = NULL, suspension_reason = NULL, updated_at = ? WHERE id = ?",
-          [messageId, timestamp, runId]
-        );
-      } else {
-        this.database.run(
-          "INSERT INTO agent_runs (id, agent_id, message_id, state, attempt, lease_id, outcome_json, suspension_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-          [run.id, run.agentId, run.messageId, run.state, run.attempt, null, null, null, run.createdAt, run.updatedAt]
-        );
-      }
-      this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
-      this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
-    });
-    enqueue();
+    this.insertMessage(message);
+    if (suspendedRow) {
+      this.database.run(
+        "UPDATE agent_runs SET message_id = ?, state = 'queued', lease_id = NULL, suspension_reason = NULL, input_request_json = NULL, updated_at = ? WHERE id = ?",
+        [messageId, timestamp, runId]
+      );
+    } else {
+      this.database.run(
+        "INSERT INTO agent_runs (id, agent_id, message_id, state, attempt, lease_id, outcome_json, suspension_reason, input_request_json, execution_state_json, metadata_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        [run.id, run.agentId, run.messageId, run.state, run.attempt, null, null, null, null, null, run.metadata ? json(run.metadata) : null, run.createdAt, run.updatedAt]
+      );
+    }
+    this.recordEventInternal("message_enqueued", { agentId: input.agentId, messageId });
     const storedRun = this.requireRun(runId);
+    this.recordEventInternal("run_enqueued", { agentId: input.agentId, messageId, runId }, runEventPayload(storedRun.metadata));
     return { message: clone3(message), run: clone3(storedRun), resumed: Boolean(suspendedRow) };
   }
   async getMessage(messageId) {
@@ -5680,6 +6040,12 @@ var SqliteRuntimeStateStore = class {
     const rows = this.database.query(`SELECT * FROM agent_runs ${where} ORDER BY created_at, id`).all(...params);
     return rows.map((row) => this.runFromRow(row));
   }
+  async listActiveRuns() {
+    const rows = this.database.query(
+      "SELECT * FROM agent_runs WHERE state IN ('queued', 'running', 'suspended') ORDER BY created_at, id"
+    ).all();
+    return rows.map((row) => this.runFromRow(row));
+  }
   async leaseRun(input) {
     const lease = this.database.transaction(() => {
       const run2 = this.requireRun(input.runId);
@@ -5754,17 +6120,17 @@ var SqliteRuntimeStateStore = class {
       requireTransition2("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = ?, lease_id = NULL, suspension_reason = ?, updated_at = ? WHERE id = ?",
-        ["suspended", input.reason ?? null, timestamp, current.id]
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, suspension_reason = ?, input_request_json = ?, execution_state_json = ?, updated_at = ? WHERE id = ?",
+        ["suspended", input.reason ?? null, input.inputRequest ? json(input.inputRequest) : null, input.executionState ? json(input.executionState) : null, timestamp, current.id]
       );
       this.database.run(
         "UPDATE runtime_messages SET state = ?, updated_at = ? WHERE id = ?",
         ["acknowledged", timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_suspended", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_suspended", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
         reason: input.reason
-      });
+      }));
       return this.requireRun(current.id);
     })();
     return clone3(run);
@@ -5778,7 +6144,7 @@ var SqliteRuntimeStateStore = class {
       const { timestamp } = timestampFor();
       const state = input.state ?? "completed";
       this.database.run(
-        "UPDATE agent_runs SET state = ?, lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [state, json(input.outcome), timestamp, current.id]
       );
       this.database.run(
@@ -5786,10 +6152,10 @@ var SqliteRuntimeStateStore = class {
         [timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_completed", { agentId: current.agentId, messageId: current.messageId, runId: current.id }, {
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: current.messageId, runId: current.id }, runEventPayload(current.metadata, {
         state,
         outcome: input.outcome
-      });
+      }));
       this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
       return this.requireRun(current.id);
     })();
@@ -5828,7 +6194,7 @@ var SqliteRuntimeStateStore = class {
       requireTransition2("Runtime Message", message.id, message.state, "dead-letter", ["leased"]);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = 'failed', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = 'failed', lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [json(input.outcome), timestamp, current.id]
       );
       this.database.run(
@@ -5836,10 +6202,10 @@ var SqliteRuntimeStateStore = class {
         [input.reason, timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_completed", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
         state: "failed",
         outcome: input.outcome
-      });
+      }));
       this.recordEvent("message_dead_lettered", { agentId: current.agentId, messageId: message.id }, {
         reason: input.reason
       });
@@ -5854,7 +6220,7 @@ var SqliteRuntimeStateStore = class {
       const message = this.requireMessage(current.messageId);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = 'cancelled', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = 'cancelled', lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [json(input.outcome), timestamp, current.id]
       );
       if (message.state === "queued" || message.state === "leased") {
@@ -5864,9 +6230,10 @@ var SqliteRuntimeStateStore = class {
         ]);
       }
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_aborted", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_aborted", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
+        state: "cancelled",
         outcome: input.outcome
-      });
+      }));
       return this.requireRun(current.id);
     })();
     return clone3(run);
@@ -6040,27 +6407,41 @@ var SqliteRuntimeStateStore = class {
     return clone3(this.eventCheckpoint(consumerId));
   }
   async acknowledgeEvent(consumerId, eventId) {
-    const checkpoint = this.database.transaction(() => {
-      const event = this.requireEvent(eventId);
-      const current = this.eventCheckpoint(consumerId);
-      if (event.sequence <= current.sequence) return current;
-      if (event.sequence !== current.sequence + 1) {
-        throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
-      }
-      const updatedAt = createTimestamp();
-      this.database.run(
-        `INSERT INTO runtime_event_consumers (consumer_id, sequence, event_id, updated_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(consumer_id) DO UPDATE SET
-           sequence = excluded.sequence,
-           event_id = excluded.event_id,
-           updated_at = excluded.updated_at`,
-        [consumerId, event.sequence, event.id, updatedAt]
-      );
-      return this.eventCheckpoint(consumerId);
-    })();
+    const acknowledge = this.database.transaction(() => this.acknowledgeEventState(consumerId, eventId));
+    const checkpoint = acknowledge();
     return clone3(checkpoint);
   }
+  async acknowledgeEventAndEnqueueAgentInput(input) {
+    const deliver = this.database.transaction(() => {
+      const event = this.requireEvent(input.eventId);
+      const current = this.eventCheckpoint(input.consumerId);
+      if (event.sequence <= current.sequence) return { checkpoint: current };
+      this.requireAgent(input.agentId);
+      const enqueued = this.enqueueAgentInputState(input);
+      const checkpoint = this.acknowledgeEventState(input.consumerId, input.eventId);
+      return { checkpoint, enqueued };
+    });
+    return clone3(deliver());
+  }
+  acknowledgeEventState(consumerId, eventId) {
+    const event = this.requireEvent(eventId);
+    const current = this.eventCheckpoint(consumerId);
+    if (event.sequence <= current.sequence) return current;
+    if (event.sequence !== current.sequence + 1) {
+      throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+    }
+    const updatedAt = createTimestamp();
+    this.database.run(
+      `INSERT INTO runtime_event_consumers (consumer_id, sequence, event_id, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(consumer_id) DO UPDATE SET
+         sequence = excluded.sequence,
+         event_id = excluded.event_id,
+         updated_at = excluded.updated_at`,
+      [consumerId, event.sequence, event.id, updatedAt]
+    );
+    return this.eventCheckpoint(consumerId);
+  }
   insertMessage(message) {
     this.database.run(
       "INSERT INTO runtime_messages (id, agent_id, kind, payload_json, state, attempts, run_id, dead_letter_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
@@ -6071,7 +6452,6 @@ var SqliteRuntimeStateStore = class {
     return {
       id: row.id,
       sessionId: row.session_id,
-      ...row.factory_id ? { factoryId: row.factory_id } : {},
       state: row.state,
       createdAt: row.created_at,
       updatedAt: row.updated_at
@@ -6111,6 +6491,9 @@ var SqliteRuntimeStateStore = class {
       ...row.lease_id ? { leaseId: row.lease_id } : {},
       ...row.outcome_json ? { outcome: parse(row.outcome_json) } : {},
       ...row.suspension_reason ? { suspensionReason: row.suspension_reason } : {},
+      ...row.input_request_json ? { inputRequest: parse(row.input_request_json) } : {},
+      ...row.execution_state_json ? { executionState: parse(row.execution_state_json) } : {},
+      ...row.metadata_json ? { metadata: parse(row.metadata_json) } : {},
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
@@ -6235,8 +6618,8 @@ export {
   AgentRun,
   AgentRuntime,
   InMemoryRuntimeStateStore,
-  InMemorySessionProvider,
-  LocalJsonlSessionProvider,
+  InMemorySessionStore,
+  JsonlSessionStore,
   SqliteRuntimeStateStore,
   createCoreTools,
   createMessage