@rowan-agent/agent 0.6.1 → 0.6.2

package/README.md

@@ -136,9 +136,9 @@ dead-lettered.
 
 ### Process Recovery
 
-Runtime startup recovers abandoned Leases into durable queued work without
-constructing Agent Bindings. The host supplies its current executable resources
-when it reconstructs an Agent:
+Runtime startup and periodic recovery return expired Leases to durable queued
+work without disturbing unexpired Leases owned by another process. The host
+supplies its current executable resources when it reconstructs an Agent:
 
 ```ts
 const runtime = await AgentRuntime.start({ stateStore, sessionProvider });
@@ -337,17 +337,17 @@ const tools = createCoreTools({
   bashTimeoutMs?,      // default: 30s
   maxBashOutputBytes?, // default: 64KB
 });
-// Returns: read, write, edit, bash
+// Returns: read, bash, edit, write
 ```
 
 ### Built-in Tools
 
 | Tool | Description | Parameters |
 |------|-------------|------------|
-| `read` | Reads a text file within the workspace | `path` (required), `maxBytes?`, `type?` ("skill" \| "phase" \| "markdown" \| "code" \| "file") |
-| `write` | Writes content to a file, creating parent directories as needed | `path` (required), `content` (required) |
-| `edit` | Replaces exact `oldText` with `newText` in a file | `path` (required), `oldText` (required), `newText` (required), `replaceAll?` |
-| `bash` | Runs a bash command within the workspace | `command` (required), `cwd?`, `timeoutMs?`, `maxOutputBytes?` |
+| `read` | Reads a file, optionally by line range | `path` (required), `offset?`, `limit?` |
+| `bash` | Runs a bash command in the workspace | `command` (required), `timeout?` (seconds) |
+| `edit` | Applies exact replacements, including multiple disjoint edits in one call | `path` (required), `edits[]` (each with `oldText` and `newText`) |
+| `write` | Creates or overwrites a file | `path` (required), `content` (required) |
 
 ### Custom Tools
 

package/dist/index.d.ts

@@ -1420,6 +1420,7 @@ declare class AgentRuntime {
     private runningRuns;
     private pumping;
     private nextWorkerId;
+    private leaseRecoveryTimer;
     private stopped;
     private constructor();
     static start(options: AgentRuntimeOptions): Promise<AgentRuntime>;
@@ -1443,6 +1444,8 @@ declare class AgentRuntime {
     private registerEventConsumer;
     listEvents(cursor?: RuntimeEventCursor): Promise<RuntimeEvent[]>;
     private recover;
+    private startLeaseRecovery;
+    private recoverExpiredLeases;
     private scheduleQueuedRuns;
     private attachAgent;
     private submitAgentInput;

package/dist/index.js

@@ -776,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();
@@ -906,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",
@@ -945,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 = [];
@@ -984,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({
@@ -1016,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") {
@@ -1029,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
       });
     }
   };
@@ -1046,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);
@@ -1062,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}.`
       });
     }
   };
@@ -1132,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({
@@ -1155,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], {
@@ -1182,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}.`
           }
@@ -1210,9 +1214,9 @@ function createCoreTools(input = {}) {
   const context = createCoreToolContext(input);
   return [
     createReadTool(context),
-    createWriteTool(context),
+    createBashTool(context),
     createEditTool(context),
-    createBashTool(context)
+    createWriteTool(context)
   ];
 }
 
@@ -1403,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 {
@@ -1539,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)
@@ -1561,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)
     );
@@ -1603,6 +1640,7 @@ async function runPhaseLoop(config, state, registry) {
   }
   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) {
@@ -1613,7 +1651,9 @@ 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++;
@@ -1672,13 +1712,17 @@ async function runPhaseLoop(config, state, registry) {
       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",
@@ -1696,13 +1740,32 @@ async function runPhaseLoop(config, state, registry) {
     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;
     }
@@ -1720,7 +1783,9 @@ async function runPhaseLoop(config, state, registry) {
       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)) {
@@ -1740,7 +1805,9 @@ 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());
         }
         const requestedAt = createTimestamp();
@@ -1768,7 +1835,9 @@ async function runPhaseLoop(config, state, registry) {
         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) {
@@ -1779,7 +1848,9 @@ async function runPhaseLoop(config, state, registry) {
       }
       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") {
@@ -1822,7 +1893,9 @@ async function runPhaseLoop(config, state, registry) {
       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;
@@ -1839,13 +1912,17 @@ async function runPhaseLoop(config, state, registry) {
     }
     if (nextRoute === "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));
     }
     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({
@@ -1961,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 {
@@ -4689,6 +4773,7 @@ var AgentRuntime = class _AgentRuntime {
   runningRuns = 0;
   pumping = false;
   nextWorkerId = 0;
+  leaseRecoveryTimer;
   stopped = false;
   constructor(options) {
     this.stateStore = options.stateStore;
@@ -4724,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);
@@ -4766,6 +4852,10 @@ var AgentRuntime = class _AgentRuntime {
   async stop() {
     if (this.stopped) return;
     this.stopped = true;
+    if (this.leaseRecoveryTimer) {
+      clearInterval(this.leaseRecoveryTimer);
+      this.leaseRecoveryTimer = void 0;
+    }
     let suspendedAgents;
     try {
       suspendedAgents = new Set(
@@ -4943,13 +5033,26 @@ var AgentRuntime = class _AgentRuntime {
     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);
     }
     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"] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
     "build": "tsup && bun scripts/check-public-interface.ts"
   },
   "dependencies": {
-    "@rowan-agent/models": "0.6.1",
+    "@rowan-agent/models": "0.6.2",
     "jiti": "2.7.0",
     "typebox": "^1.0.0"
   },