@rowan-agent/agent 0.9.3 → 0.9.5

package/dist/index.js

@@ -91,12 +91,12 @@ function buildPhaseDirectiveMessage(phase, output) {
   const parts = [];
   parts.push(`<phase_content name="${escapeXml(phase.name)}">`);
   parts.push(phase.content);
-  if (output.results && output.results.length > 0) {
+  if (output.results && output.results.length > 0 || output.instruction) {
     parts.push(`  <prev_phase_outputs>`);
     if (output.instruction) {
       parts.push(`    <instruction>${escapeXml(output.instruction)}</instruction>`);
     }
-    for (const r of output.results) {
+    for (const r of output.results ?? []) {
       parts.push(`    <phase name="${escapeXml(r.name)}">`);
       if (r.output !== void 0) {
         parts.push(jsonToXml(r.output, 3));
@@ -172,18 +172,24 @@ function buildPhaseEntry(p) {
 function buildRouteDescription(availablePhases) {
   const phasesBlock = buildStructuredSection("phase", [
     ...availablePhases.map(buildPhaseEntry),
-    { name: "stop", description: "Terminate the workflow and return final result to the user" }
+    {
+      name: "stop",
+      description: "Explicitly finish the current user request or task when no further user input is needed"
+    }
   ]);
   return [
-    "Route execution to one or more phases concurrently, or stop execution.",
+    "Route is optional. Omit it when the current reply should wait for more user input and remain in the current phase.",
     "",
     "Rules:",
-    "- `decision` lists phase executions; use phase 'stop' to terminate.",
+    "- Call route only to continue execution immediately in one or more phases, or to explicitly stop.",
+    "- `decision` lists phase executions; a single target equal to the current phase starts another iteration of that phase.",
+    "- `stop` means the current user request or task is complete and no further user input is needed; `stop` must be the only target.",
     "- Each target may include `phase`, `reason`, `payload`.",
     "- A phase may appear multiple times as independent execution instances.",
     "- `payload` MUST match the phase's `payload_schema`",
     "- `instruction` is optional shared guidance for all phases.",
     "- Executions are independent and concurrent; order is irrelevant.",
+    "- Do not call route in the same response as an ordinary tool; finish ordinary tools first.",
     "",
     "<available_phases>",
     phasesBlock,
@@ -202,12 +208,13 @@ function createRouteTool(availablePhases) {
   return {
     name: PhaseRouteTool,
     description: buildRouteDescription(availablePhases),
-    promptSnippet: "Route to next phase on completion.",
+    promptSnippet: "Route is optional: omit it to remain in the current phase and wait for user input; use it for immediate phase execution or an explicit stop.",
     promptGuidelines: [
-      "Call route immediately when the phase is complete."
+      "Do not call route together with ordinary tools.",
+      "Use route(stop) only when the current user request or task is complete and no further user input is needed."
     ],
     parameters: Type.Object({
-      decision: Type.Array(DecisionTarget, { description: "Phase executions to start" }),
+      decision: Type.Array(DecisionTarget, { description: "Phase executions to start", minItems: 1 }),
       instruction: Type.Optional(Type.String({ description: "Overall instruction, passed as context" }))
     }),
     // No-op: this tool is intercepted by phases, never executed via tool execution
@@ -220,29 +227,35 @@ function createRouteTool(availablePhases) {
   };
 }
 function extractRouteCall(toolCalls) {
-  const routeCall = toolCalls.find((t) => t.name === PhaseRouteTool);
-  if (!routeCall) return void 0;
+  const routeCalls = toolCalls.filter((t) => t.name === PhaseRouteTool);
+  if (routeCalls.length !== 1) return void 0;
+  const routeCall = routeCalls[0];
   let args;
   if (typeof routeCall.args === "string") {
     try {
-      args = JSON.parse(routeCall.args);
+      const parsed = JSON.parse(routeCall.args);
+      args = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     } catch {
-      return void 0;
+      return { decision: [{ phase: "" }] };
     }
   } else {
-    args = routeCall.args;
+    args = routeCall.args !== null && typeof routeCall.args === "object" ? routeCall.args : {};
   }
   const decisionRaw = args.decision;
   let decision = [];
   if (Array.isArray(decisionRaw)) {
     decision = decisionRaw.map((d) => {
-      const obj = d;
+      const obj = d !== null && typeof d === "object" ? d : {};
       return {
-        phase: typeof obj?.phase === "string" ? obj.phase : "stop",
+        // Empty phase is an invalid target sentinel. Never coerce malformed
+        // input to stop: only an explicit, valid stop target may terminate.
+        phase: typeof obj.phase === "string" ? obj.phase : "",
         reason: typeof obj?.reason === "string" ? obj.reason : void 0,
         payload: obj?.payload
       };
     });
+  } else if (decisionRaw !== void 0) {
+    decision = [{ phase: "" }];
   }
   return {
     decision,
@@ -765,6 +778,15 @@ function contentBlocksToMessageContent(blocks) {
   });
 }
 
+// src/loop/types.ts
+var DEFAULT_MAX_ATTEMPTS = 16;
+function validateMaxAttempts(value) {
+  if (value !== void 0 && (!Number.isInteger(value) || value <= 0)) {
+    throw new TypeError("maxAttempts must be a positive integer.");
+  }
+  return value;
+}
+
 // src/loop/errors.ts
 var EmptyResponseError = class extends Error {
   code = "empty_response";
@@ -882,7 +904,7 @@ async function collectStreamResult(input) {
       doneResponse = event.response;
       stopReason = event.response?.stopReason;
       const contentBlocks2 = lastPartial?.contentBlocks ?? [];
-      const hasContent2 = contentBlocks2.length > 0 || (event.response?.content?.length ?? 0) > 0;
+      const hasContent2 = contentBlocks2.length > 0 || (event.response?.content?.length ?? 0) > 0 || (event.response?.toolCalls?.length ?? 0) > 0;
       const shouldStoreContentParts = contentBlocks2.some((block) => block.type !== "text");
       if (activeMessageId && hasContent2 && shouldStoreContentParts) {
         input.message.replaceContent(activeMessageId, contentBlocksToMessageContent(contentBlocks2));
@@ -905,7 +927,7 @@ async function collectStreamResult(input) {
   if (activeMessageId) {
     await input.message.end(activeMessageId);
   }
-  const hasContent = (lastPartial?.contentBlocks?.length ?? 0) > 0 || (doneResponse?.content?.length ?? 0) > 0;
+  const hasContent = (lastPartial?.contentBlocks?.length ?? 0) > 0 || (doneResponse?.content?.length ?? 0) > 0 || (doneResponse?.toolCalls?.length ?? 0) > 0;
   if (!hasContent && stopReason !== "error" && stopReason !== "aborted") {
     throw new EmptyResponseError();
   }
@@ -1497,7 +1519,7 @@ function createDefaultPhase() {
     filePath: "",
     baseDir: "",
     skills: [],
-    content: "Execute tasks using current context.\nNo planning. No evaluation.\nRoute to next phase or stop when done."
+    content: "Execute tasks using current context.\nNo planning. No evaluation.\nOmit route when more user input is needed. Use route for immediate phase execution, or route(stop) only when the current user request or task is complete and no further user input is needed."
   };
 }
 
@@ -1821,6 +1843,31 @@ function applyFirstDecision(route, output) {
   if (first.reason) output.routeReason = first.reason;
   if (first.payload !== void 0) output.payload = normalizePayload(first.payload);
 }
+function resolveRouteDecision(route, registry) {
+  if (!route || route.decision.length === 0) return void 0;
+  const requestedCount = route.decision.length;
+  const hasStop = route.decision.some(({ phase }) => phase === "stop");
+  if (hasStop) {
+    if (requestedCount !== 1) return void 0;
+    return { ...route, requestedCount };
+  }
+  const decision = route.decision.filter(({ phase }) => registry.phases.has(phase));
+  if (decision.length === 0) return void 0;
+  return { ...route, decision, requestedCount };
+}
+function resolveModelRouteDecision(toolCalls, registry) {
+  return resolveRouteDecision(toolCalls ? extractRouteCall(toolCalls) : void 0, registry);
+}
+function resolveHookRouteDecision(output, registry) {
+  if (output.route === void 0 || output.route === "continue") return void 0;
+  return resolveRouteDecision({
+    decision: [{
+      phase: output.route,
+      ...output.routeReason ? { reason: output.routeReason } : {},
+      ...output.payload === void 0 ? {} : { payload: output.payload }
+    }]
+  }, registry);
+}
 function injectPhaseContent(phase, output, messages, mirror) {
   try {
     const phaseContent = phase.filePath ? readPhaseContent(phase) : phase.content ?? phase.description ?? "";
@@ -1952,12 +1999,13 @@ function createToolResultContent(result) {
     }
   ];
 }
-function createRouteToolResultContent(toolCall) {
+function createRouteToolResultContent(toolCall, error) {
   return [
     {
       type: "tool_result",
       toolUseId: toolCall.id,
-      content: '{"ok": true}'
+      content: error ? JSON.stringify({ ok: false, error }) : '{"ok": true}',
+      ...error ? { isError: true } : {}
     }
   ];
 }
@@ -1967,7 +2015,6 @@ async function executePhaseWithModel(ctx) {
   );
   let output = {
     message: "",
-    route: "stop",
     phase: ctx.phase.name,
     toolCalls: []
   };
@@ -1979,15 +2026,24 @@ async function executePhaseWithModel(ctx) {
     const collected = await ctx.execution.invokeModel(roundContext);
     output = {
       message: collected.text,
-      route: "stop",
       phase: ctx.phase.name,
-      toolCalls: collected.toolCalls
+      // A route decision sharing a model response with an ordinary Tool is
+      // rejected for this round. Keep ordinary calls visible so they can run,
+      // but do not let the route escape the error/re-decision boundary.
+      toolCalls: collected.toolCalls.some((candidate) => candidate.name === PhaseRouteTool) && collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? collected.toolCalls.filter((candidate) => candidate.name !== PhaseRouteTool) : collected.toolCalls
     };
     for (const toolCall of collected.toolCalls) {
       if (toolCall.name !== PhaseRouteTool) continue;
-      const messageId = ctx.messageManager.start("tool", createRouteToolResultContent(toolCall), {
-        phase: ctx.phase.name
-      });
+      const messageId = ctx.messageManager.start(
+        "tool",
+        createRouteToolResultContent(
+          toolCall,
+          collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? "Route must be called separately after ordinary tools finish; this route decision was ignored." : void 0
+        ),
+        {
+          phase: ctx.phase.name
+        }
+      );
       await ctx.messageManager.end(messageId);
     }
     const executableToolCalls = collected.toolCalls.filter(
@@ -2019,6 +2075,7 @@ async function startPhaseLoop(config, state) {
   return runPhaseLoop(config, state, registry);
 }
 async function runPhaseLoop(config, state, registry) {
+  const maxAttempts = validateMaxAttempts(config.maxAttempts) ?? DEFAULT_MAX_ATTEMPTS;
   const resumingSuspendedRun = state.status === "suspended" && Boolean(state.currentPhase);
   let currentPhaseId = resumingSuspendedRun ? state.currentPhase : registry.entryPhaseId;
   let isContinuing = resumingSuspendedRun ? state.continuation?.isContinuing ?? true : false;
@@ -2030,6 +2087,53 @@ async function runPhaseLoop(config, state, registry) {
   let previousPhaseInputMsgId;
   let previousResults = resumingSuspendedRun ? state.continuation?.previousResults?.map((result) => ({ ...result })) ?? [] : [];
   let pendingInstruction = resumingSuspendedRun ? state.continuation?.pendingInstruction : void 0;
+  const awaitInput = async (prompt, resumeAsContinuing) => {
+    if (!config.waitForInput) return void 0;
+    const preAbort = LoopGuard.checkAbort(config.signal);
+    if (preAbort.stopReason !== "none") {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
+      return {
+        type: "completed",
+        result: await completeRun(config, state, createOutcome.aborted())
+      };
+    }
+    const requestedAt = createTimestamp();
+    const inputRequest = {
+      phase: currentPhaseId,
+      prompt,
+      requestedAt
+    };
+    state.currentPhase = currentPhaseId;
+    state.status = "suspended";
+    state.attempt = 0;
+    state.continuation = {
+      isContinuing: resumeAsContinuing,
+      previousPayload,
+      previousResults: previousResults.map((result) => ({ ...result })),
+      pendingInstruction,
+      previousPhaseMessageId: previousPhaseMsgId
+    };
+    const userMessages = await config.waitForInput(state, inputRequest);
+    state.status = "running";
+    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 {
+        type: "completed",
+        result: await completeRun(config, state, createOutcome.aborted())
+      };
+    }
+    for (const message of userMessages) {
+      config.context.messages.push(message);
+    }
+    return { type: "continued" };
+  };
   while (currentPhaseId) {
     const availablePhases = [];
     for (const [, phase2] of registry.phases) {
@@ -2043,6 +2147,19 @@ async function runPhaseLoop(config, state, registry) {
       previousPhaseInputMsgId = void 0;
       return completeRun(config, state, createOutcome.aborted());
     }
+    if (state.attempt >= maxAttempts) {
+      const input = await awaitInput(
+        `The autonomous Phase execution limit (${maxAttempts}) was reached. Provide input to continue.`,
+        false
+      );
+      if (input?.type === "completed") return input.result;
+      if (input?.type === "continued") {
+        isContinuing = false;
+        continue;
+      }
+      throw new Error("Phase execution reached maxAttempts but waitForInput is unavailable.");
+    }
+    state.attempt++;
     state.metrics.iterations++;
     if (needsCompaction(config.context.messages)) {
       const compacted = compactMessages(config.context.messages);
@@ -2143,13 +2260,9 @@ async function runPhaseLoop(config, state, registry) {
     }
     const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
     let output = await executePhase(runtime);
-    let routeDecision;
-    if (output.toolCalls && output.toolCalls.length > 0) {
-      routeDecision = extractRouteCall(output.toolCalls);
-      if (routeDecision) {
-        applyFirstDecision(routeDecision, output);
-      }
-    }
+    let modelRouteDecision = resolveModelRouteDecision(output.toolCalls, registry);
+    let routeDecision = modelRouteDecision;
+    if (routeDecision) applyFirstDecision(routeDecision, output);
     if (config.afterPhase) {
       const extAfter = await config.afterPhase(currentPhaseId, output);
       if (extAfter.abort) {
@@ -2161,52 +2274,30 @@ async function runPhaseLoop(config, state, registry) {
       }
       if (extAfter.retry && (phase.run || phase.factory)) {
         output = await executePhase(runtime);
-        routeDecision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
+        modelRouteDecision = resolveModelRouteDecision(output.toolCalls, registry);
+        routeDecision = modelRouteDecision;
         if (routeDecision) applyFirstDecision(routeDecision, output);
       }
       if (extAfter.output) {
+        const hookHasRoute = extAfter.output.route !== void 0;
         output = extAfter.output;
+        if (hookHasRoute) {
+          routeDecision = resolveHookRouteDecision(output, registry);
+        } else if (phase.run || phase.factory) {
+          output = { ...output, route: "stop" };
+          routeDecision = void 0;
+        } else {
+          routeDecision = modelRouteDecision;
+          if (routeDecision) applyFirstDecision(routeDecision, output);
+        }
       }
     }
-    const routeToolAvailable = phaseContext.tools.some((tool) => tool.name === PhaseRouteTool);
-    const routeRequired = !phase.target && !phase.run && !phase.factory && routeToolAvailable && registry.phases.size > 1;
-    if (routeRequired && !routeDecision) {
-      if (config.waitForInput) {
-        const preAbort = LoopGuard.checkAbort(config.signal);
-        if (preAbort.stopReason !== "none") {
-          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();
-        const inputRequest = {
-          phase: currentPhaseId,
-          prompt: output.message,
-          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") {
-          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);
-        }
+    if (phase.run || phase.factory) {
+      if (output.route === void 0 && !routeDecision) output = { ...output, route: "stop" };
+    } else if (!phase.target && output.route === void 0 && !routeDecision) {
+      const input = await awaitInput(output.message, true);
+      if (input?.type === "completed") return input.result;
+      if (input?.type === "continued") {
         isContinuing = true;
         continue;
       }
@@ -2220,7 +2311,7 @@ async function runPhaseLoop(config, state, registry) {
       isContinuing = true;
       continue;
     }
-    if (routeDecision && routeDecision.decision.length > 1) {
+    if (routeDecision && routeDecision.requestedCount > 1) {
       const contextSnapshot = snapshotMessages(config.context.messages);
       const parallelTasks = /* @__PURE__ */ new Map();
       const instanceIds = buildInstanceIds(routeDecision.decision.map((t) => t.phase));
@@ -2239,6 +2330,7 @@ async function runPhaseLoop(config, state, registry) {
           registry,
           pt,
           payload,
+          routeDecision.instruction,
           context,
           availablePhases,
           instanceId,
@@ -2251,7 +2343,7 @@ async function runPhaseLoop(config, state, registry) {
       }
       const successfulResults = await waitForBackgroundTasks(parallelTasks);
       previousResults = successfulResults.map((r) => ({ name: r.instanceId, output: r.payload }));
-      pendingInstruction = routeDecision.instruction;
+      pendingInstruction = void 0;
       const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
         removePhaseMessage(config.context.messages, previousPhaseMsgId);
@@ -2294,6 +2386,7 @@ async function runPhaseLoop(config, state, registry) {
     });
     previousPayload = output.payload;
     previousResults = output.payload !== void 0 ? [{ name: phase.name, output: output.payload }] : [];
+    pendingInstruction = phase.target ? void 0 : routeDecision?.instruction;
     currentPhaseId = targetPhaseId;
   }
   throw new Error("Phase machine exited without a stop or abort transition.");
@@ -2548,10 +2641,10 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
     }
   };
 }
-async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
+async function executeParallelPhase(config, state, registry, phase, payload, instruction, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const allTools = buildToolsWithRouting(config, availablePhases);
-  const phaseTools = selectPhaseTools(allTools, phase.tools);
+  const phaseTools = selectPhaseTools(allTools, phase.tools, false);
   const phaseSkills = mergeSkills(config.context.skills, phase.skills);
   const systemPrompt = config.context.systemPrompt;
   const phaseContext = {
@@ -2578,7 +2671,10 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   const messageManager = createMessageManager({ messages }, config.onMessage, config.onMessageDelta);
   const phaseMsgId = injectPhaseContent(
     phase,
-    { results: payload !== void 0 ? [{ name: sourcePhaseId, output: payload }] : [] },
+    {
+      instruction,
+      results: payload !== void 0 ? [{ name: sourcePhaseId, output: payload }] : []
+    },
     messages
   );
   const toolExecutionManager = createToolExecutionManager();
@@ -2590,8 +2686,8 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
   return { instanceId, phaseId: phase.name, payload: resultPayload, content: output.message };
 }
-function selectPhaseTools(candidates, names) {
-  const routing = candidates.filter(({ name }) => name === PhaseRouteTool);
+function selectPhaseTools(candidates, names, includeRouting = true) {
+  const routing = includeRouting ? candidates.filter(({ name }) => name === PhaseRouteTool) : [];
   const ordinary = candidates.filter(({ name }) => name !== PhaseRouteTool);
   return [...selectNamedResources(ordinary, names, "Tool"), ...routing];
 }
@@ -2895,7 +2991,7 @@ function normalizeUserInput(input) {
   return normalized;
 }
 function isAssistantMessage(value) {
-  return isRecord3(value) && hasOnlyKeys(value, ["id", "agentId", "runId", "role", "content", "metadata", "sequenceWithinRun", "createdAt", "interrupted"]) && typeof value.id === "string" && typeof value.agentId === "string" && typeof value.runId === "string" && value.role === "assistant" && Number.isInteger(value.sequenceWithinRun) && value.sequenceWithinRun >= 0 && typeof value.createdAt === "string" && isAssistantContent(value.content) && (value.metadata === void 0 || isMetadata(value.metadata)) && (value.interrupted === void 0 || typeof value.interrupted === "boolean");
+  return isRecord3(value) && hasOnlyKeys(value, ["id", "agentId", "runId", "messageRevision", "role", "content", "metadata", "sequenceWithinRun", "createdAt", "interrupted"]) && typeof value.id === "string" && typeof value.agentId === "string" && typeof value.runId === "string" && value.role === "assistant" && (value.messageRevision === void 0 || Number.isInteger(value.messageRevision) && value.messageRevision >= 0) && Number.isInteger(value.sequenceWithinRun) && value.sequenceWithinRun >= 0 && typeof value.createdAt === "string" && isAssistantContent(value.content) && (value.metadata === void 0 || isMetadata(value.metadata)) && (value.interrupted === void 0 || typeof value.interrupted === "boolean");
 }
 function isToolResult(value) {
   if (!isRecord3(value) || !isJsonValue(value.content) || typeof value.ok !== "boolean") return false;
@@ -3040,6 +3136,7 @@ function validateConfigResolution(agentId, value) {
   throw new Error(`Config Provider returned an invalid resolution for Agent ${agentId}.`);
 }
 function snapshotConfig(config) {
+  validateMaxAttempts(config.maxAttempts);
   if (isAgentConfiguration(config)) return snapshotConfiguration(config);
   const definition = Object.freeze({
     ...config.definition,
@@ -3193,6 +3290,7 @@ var ConfigCommandService = class {
     const reserved = await this.store.reserveAgent({
       idempotencyKey: input.idempotencyKey,
       ...input.metadata === void 0 ? {} : { metadata: input.metadata },
+      ...input.historySeed === void 0 ? {} : { historySeed: input.historySeed },
       configIdentity: input.config.identity
     });
     if (reserved.activatedAt && reserved.currentConfigToken) return reserved.id;
@@ -4999,6 +5097,7 @@ function adaptExtensionTool2(input) {
 
 // src/runtime/configuration-snapshot.ts
 function resolveConfigurationSnapshot(registry, input) {
+  validateMaxAttempts(input.maxAttempts);
   const resolved = registry.resolveView(input.resourceView);
   const base = resolved.agents.find(({ name }) => name === input.definition.name);
   if (!base) {
@@ -5179,6 +5278,7 @@ var AgentRuntime = class _AgentRuntime {
     return this.commands.createAgent({
       config,
       ...options.metadata === void 0 ? {} : { metadata: options.metadata },
+      ...options.historySeed === void 0 ? {} : { historySeed: options.historySeed },
       idempotencyKey: options.idempotencyKey ?? crypto.randomUUID()
     });
   }
@@ -5196,6 +5296,23 @@ var AgentRuntime = class _AgentRuntime {
     }
     await this.owned.deleteAgent(input);
   }
+  async revise(agentId, input) {
+    this.assertOpen();
+    const result = await this.owned.reviseMessage({ agentId, ...input });
+    for (const runId of result.invalidatedRunIds) {
+      const execution = this.executions.get(runId);
+      if (execution) {
+        execution.controller.abort();
+        this.transientEvents.clear(runId, execution.executionId);
+      }
+    }
+    void this.pump();
+    return result;
+  }
+  async compact(input = {}) {
+    this.assertOpen();
+    return this.owned.compact(input);
+  }
   async start(agentId, input, options) {
     this.assertOpen();
     const agent = await this.requireAgent(agentId);
@@ -5249,6 +5366,10 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     return this.owned.snapshotRun(runId);
   }
+  async history(agentId) {
+    this.assertOpen();
+    return this.owned.history(agentId);
+  }
   async respond(runId, input) {
     this.assertOpen();
     const snapshot = await this.owned.snapshotRun(runId);
@@ -5762,6 +5883,11 @@ function normalizePhaseRegistry(registry) {
   if (registry?.phases.has(DEFAULT_PHASE_ID) && registry.phases.get(DEFAULT_PHASE_ID)?.filePath !== "") {
     throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${DEFAULT_PHASE_ID}".`);
   }
+  for (const [name] of registry?.phases ?? []) {
+    if (name === "stop" || name === "continue") {
+      throw new TypeError(`Configured Phase name "${name}" is reserved by Rowan routing controls.`);
+    }
+  }
   return {
     phases: new Map([
       [DEFAULT_PHASE_ID, createDefaultPhase()],
@@ -5793,6 +5919,7 @@ function deferred2() {
 }
 
 // src/runtime/durable-store.ts
+import { createHash } from "crypto";
 var InMemoryStore = class _InMemoryStore {
   incarnation;
   agents = /* @__PURE__ */ new Map();
@@ -5802,12 +5929,14 @@ var InMemoryStore = class _InMemoryStore {
   events = [];
   idempotency = /* @__PURE__ */ new Map();
   operationReceipts = /* @__PURE__ */ new Map();
+  historySeeds = /* @__PURE__ */ new Map();
   consumerCheckpoints = /* @__PURE__ */ new Map();
   nextAgentSequence = /* @__PURE__ */ new Map();
   nextReadySequence = /* @__PURE__ */ new Map();
   owner;
   ownerEpoch = 0;
   eventSequence = 0;
+  retentionFloor = 1;
   constructor(options = {}) {
     this.incarnation = options.incarnation ?? createId("store");
   }
@@ -5820,10 +5949,12 @@ var InMemoryStore = class _InMemoryStore {
     store.events.push(...clone(state.events));
     for (const [key, receipt] of state.idempotency) store.idempotency.set(key, clone(receipt));
     for (const [key, receipt] of state.operationReceipts) store.operationReceipts.set(key, clone(receipt));
+    for (const [agentId, messages] of state.historySeeds ?? []) store.historySeeds.set(agentId, clone(messages));
     for (const [consumerId, cursor] of state.consumerCheckpoints ?? []) store.consumerCheckpoints.set(consumerId, cursor);
     for (const [agentId, sequence] of state.nextAgentSequence) store.nextAgentSequence.set(agentId, sequence);
     for (const [agentId, sequence] of state.nextReadySequence) store.nextReadySequence.set(agentId, sequence);
     store.eventSequence = state.eventSequence;
+    store.retentionFloor = Math.max(1, state.retentionFloor ?? 1);
     store.ownerEpoch = Math.max(
       0,
       ...state.runs.map((run) => run.execution?.ownerEpoch ?? 0)
@@ -5840,7 +5971,9 @@ var InMemoryStore = class _InMemoryStore {
       events: this.events,
       idempotency: [...this.idempotency.entries()],
       operationReceipts: [...this.operationReceipts.entries()],
+      historySeeds: [...this.historySeeds.entries()],
       consumerCheckpoints: [...this.consumerCheckpoints.entries()],
+      retentionFloor: this.retentionFloor,
       nextAgentSequence: [...this.nextAgentSequence.entries()],
       nextReadySequence: [...this.nextReadySequence.entries()],
       eventSequence: this.eventSequence
@@ -5916,7 +6049,8 @@ var InMemoryStore = class _InMemoryStore {
     const scope = createIdempotencyScope("create_agent", input.idempotencyKey);
     const payload = canonicalJson({
       ...input.metadata === void 0 ? {} : { metadata: input.metadata },
-      ...input.configIdentity === void 0 ? {} : { configIdentity: input.configIdentity }
+      ...input.configIdentity === void 0 ? {} : { configIdentity: input.configIdentity },
+      ...input.historySeed === void 0 ? {} : { historySeed: input.historySeed }
     });
     const replay = this.replay(scope, payload);
     if (replay) return clone(replay);
@@ -5928,6 +6062,7 @@ var InMemoryStore = class _InMemoryStore {
       updatedAt: timestamp
     };
     this.agents.set(agent.id, agent);
+    if (input.historySeed && input.historySeed.length > 0) this.historySeeds.set(agent.id, materializeHistorySeed(agent.id, input.historySeed));
     this.nextAgentSequence.set(agent.id, 0);
     this.nextReadySequence.set(agent.id, 0);
     this.writeReceipt(scope, payload, agent);
@@ -5975,6 +6110,7 @@ var InMemoryStore = class _InMemoryStore {
     this.agents.delete(agent.id);
     this.nextAgentSequence.delete(agent.id);
     this.nextReadySequence.delete(agent.id);
+    this.historySeeds.delete(agent.id);
     for (const run of runs) this.runs.delete(run.id);
     for (const [messageId, message] of this.messages) {
       if (runIds.has(message.runId)) this.messages.delete(messageId);
@@ -5992,6 +6128,140 @@ var InMemoryStore = class _InMemoryStore {
       if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) this.operationReceipts.delete(key);
     }
   }
+  reviseMessage(lease, input) {
+    this.assertOwner(lease);
+    if (!Number.isInteger(input.expectedMessageRevision) || input.expectedMessageRevision < 0) {
+      throw new TypeError("expectedMessageRevision must be a non-negative integer");
+    }
+    if (typeof input.operationId !== "string" || input.operationId.length === 0) throw new TypeError("operationId must be non-empty");
+    const normalized = normalizeUserInput({ content: input.content });
+    const operationKey = `revise_message:${input.agentId}:${input.operationId}`;
+    const operationPayload = canonicalJson([
+      input.messageId,
+      input.expectedMessageRevision,
+      normalized,
+      input.effectDigestConfirmation ?? null
+    ]);
+    const replay = this.replayOperation(operationKey, operationPayload);
+    if (replay) return clone(replay);
+    const agent = this.requireAgent(input.agentId);
+    const seed = this.historySeeds.get(agent.id) ?? [];
+    const original = this.messages.get(input.messageId) ?? seed.find(({ id }) => id === input.messageId);
+    if (!original || original.agentId !== agent.id || original.role !== "user") {
+      throw new RuntimeError("message_revision_conflict", {
+        agentId: agent.id,
+        messageId: input.messageId,
+        expected: input.expectedMessageRevision,
+        actual: -1
+      });
+    }
+    const actualRevision = original.messageRevision ?? 0;
+    if (actualRevision !== input.expectedMessageRevision) {
+      throw new RuntimeError("message_revision_conflict", {
+        agentId: agent.id,
+        messageId: input.messageId,
+        expected: input.expectedMessageRevision,
+        actual: actualRevision
+      });
+    }
+    const targetRun = this.runs.get(original.runId);
+    const isSeedMessage = !targetRun && seed.some(({ id }) => id === original.id);
+    if (!targetRun && !isSeedMessage) {
+      throw new RuntimeError("message_revision_conflict", {
+        agentId: agent.id,
+        messageId: input.messageId,
+        expected: input.expectedMessageRevision,
+        actual: actualRevision
+      });
+    }
+    const targetAgentSequence = targetRun?.agentSequence ?? -1;
+    const affectedRuns = [...this.runs.values()].filter((run) => run.agentId === agent.id && run.agentSequence >= targetAgentSequence).sort((left, right) => left.agentSequence - right.agentSequence);
+    const affectedRunIds = affectedRuns.map((run) => run.id);
+    const affectedRunSet = new Set(affectedRunIds);
+    const affectedTools = [...this.toolCalls.values()].filter((toolCall) => affectedRunSet.has(toolCall.runId)).sort((left, right) => String(left.id).localeCompare(String(right.id)));
+    const effectDigest = affectedTools.length > 0 ? digestToolEffects(affectedTools) : void 0;
+    if (effectDigest && input.effectDigestConfirmation !== effectDigest) {
+      throw new RuntimeError("tool_effect_confirmation_required", {
+        agentId: agent.id,
+        messageId: input.messageId,
+        effectDigest,
+        toolCallIds: affectedTools.map((toolCall) => toolCall.id)
+      });
+    }
+    const timestamp = createTimestamp();
+    const replacementRun = {
+      id: createId("run"),
+      agentId: agent.id,
+      agentSequence: this.nextSequence(agent.id),
+      readySequence: this.nextReady(agent.id),
+      revision: 0,
+      state: "queued",
+      input: targetInput(normalized, original.metadata),
+      initialMessageId: original.id,
+      ...(targetRun?.pinnedConfigToken ?? this.agents.get(agent.id)?.currentConfigToken) === void 0 ? {} : { pinnedConfigToken: targetRun?.pinnedConfigToken ?? this.agents.get(agent.id)?.currentConfigToken },
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    for (const run of affectedRuns) {
+      const previousState = run.state;
+      run.invalidatedBy = { messageId: original.id, messageRevision: actualRevision + 1 };
+      if (run.state === "running" || run.state === "queued" || run.state === "input_required") {
+        if (run.state === "running") {
+          const openToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running"));
+          for (const toolCall of openToolCalls) this.interruptToolCall(run, toolCall, "Run superseded by Message revision.");
+        } else {
+          delete run.openInputRequest;
+          delete run.checkpoint;
+        }
+        delete run.execution;
+        run.state = "cancelled";
+        run.cancellationReason = "Run superseded by Message revision.";
+        run.revision += 1;
+        run.updatedAt = timestamp;
+        this.appendTransition(run, previousState, "cancelled", void 0, void 0, void 0, void 0, run.cancellationReason);
+      } else {
+        run.revision += 1;
+        run.updatedAt = timestamp;
+      }
+    }
+    for (const [messageId, message] of this.messages) {
+      if (!affectedRunSet.has(message.runId)) continue;
+      if (message.runId !== original.runId || message.sequenceWithinRun > original.sequenceWithinRun) this.messages.delete(messageId);
+    }
+    if (isSeedMessage) {
+      const targetIndex = seed.findIndex(({ id }) => id === original.id);
+      if (targetIndex >= 0) this.historySeeds.set(agent.id, seed.slice(0, targetIndex));
+    }
+    const revisedMessage = {
+      ...clone(original),
+      runId: replacementRun.id,
+      content: userInputContent(normalized),
+      messageRevision: actualRevision + 1,
+      sequenceWithinRun: 0,
+      createdAt: timestamp
+    };
+    this.messages.set(revisedMessage.id, revisedMessage);
+    this.runs.set(replacementRun.id, replacementRun);
+    this.appendTransition(replacementRun, null, "queued");
+    this.events.push({
+      ...this.baseEvent(replacementRun),
+      kind: "message_revised",
+      message: revisedMessage,
+      previousRevision: actualRevision,
+      invalidatedRunIds: affectedRunIds,
+      targetRunId: original.runId,
+      cutoffSequenceWithinRun: original.sequenceWithinRun
+    });
+    const result = {
+      message: clone(revisedMessage),
+      replacementRun: clone(replacementRun),
+      invalidatedRunIds: affectedRunIds,
+      affectedToolCallIds: affectedTools.map((toolCall) => toolCall.id),
+      ...effectDigest === void 0 ? {} : { effectDigest }
+    };
+    this.writeOperationReceipt(operationKey, operationPayload, result);
+    return clone(result);
+  }
   createRun(lease, input) {
     this.assertOwner(lease);
     this.requireAgent(input.agentId);
@@ -6039,7 +6309,7 @@ var InMemoryStore = class _InMemoryStore {
     }
     if (!run.pinnedConfigToken && input.configToken) run.pinnedConfigToken = input.configToken;
     let message;
-    if (!run.checkpoint) {
+    if (!run.checkpoint && !run.initialMessageId) {
       const userInput = normalizeUserInput(run.input);
       message = {
         id: input.messageId ?? createId("msg"),
@@ -6064,7 +6334,7 @@ var InMemoryStore = class _InMemoryStore {
     run.updatedAt = createTimestamp();
     if (message) this.appendMessage(run, message);
     this.appendTransition(run, "queued", "running");
-    const result = { run: clone(run), execution: clone(execution), history: this.history(run.agentId, run.agentSequence) };
+    const result = { run: clone(run), execution: clone(execution), history: this.activeHistory(run.agentId, run.agentSequence) };
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
@@ -6459,7 +6729,10 @@ var InMemoryStore = class _InMemoryStore {
   }
   listEvents(lease, input = {}) {
     this.assertOwner(lease);
-    const after = input.after ? this.parseCursor(input.after) : 0;
+    const after = input.after ? this.parseCursor(input.after) : this.retentionFloor - 1;
+    if (input.after && after < this.retentionFloor - 1) {
+      throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "expired" });
+    }
     if (after > this.eventSequence) {
       throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "beyond_waterline" });
     }
@@ -6476,11 +6749,72 @@ var InMemoryStore = class _InMemoryStore {
   advanceConsumerCheckpoint(lease, input) {
     this.assertOwner(lease);
     const next = this.parseCursor(input.cursor);
+    if (next < this.retentionFloor - 1) {
+      throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "expired" });
+    }
     if (next > this.eventSequence) throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "beyond_waterline" });
     const previous = this.consumerCheckpoints.get(input.consumerId);
     if (previous !== void 0 && next <= this.parseCursor(previous)) return;
     this.consumerCheckpoints.set(input.consumerId, input.cursor);
   }
+  compact(lease, input = {}) {
+    this.assertOwner(lease);
+    const retentionMs = input.retentionMs ?? 7 * 24 * 60 * 60 * 1e3;
+    if (!Number.isFinite(retentionMs) || retentionMs < 0) {
+      throw new TypeError("retentionMs must be a non-negative finite number");
+    }
+    const now = input.now === void 0 ? Date.now() : Date.parse(input.now);
+    if (!Number.isFinite(now)) throw new TypeError("now must be an ISO timestamp");
+    const cutoff = now - retentionMs;
+    const checkpointSequences = [...this.consumerCheckpoints.values()].map((cursor) => this.parseCursor(cursor));
+    const consumerFloor = checkpointSequences.length > 0 ? Math.min(...checkpointSequences) : this.eventSequence;
+    const blockedRunIds = /* @__PURE__ */ new Set();
+    for (const run of this.runs.values()) {
+      if (run.state === "running") blockedRunIds.add(run.id);
+    }
+    for (const tool of this.toolCalls.values()) {
+      if (tool.state === "pending" || tool.state === "running" || tool.state === "indeterminate") {
+        blockedRunIds.add(tool.runId);
+      }
+    }
+    let deleteThrough = this.retentionFloor - 1;
+    for (const event of this.events) {
+      const sequence = this.parseCursor(event.cursor);
+      if (sequence < this.retentionFloor) continue;
+      if (sequence > consumerFloor) break;
+      if (Date.parse(event.createdAt) > cutoff || blockedRunIds.has(event.runId)) break;
+      const eventRun = this.runs.get(event.runId);
+      if (!eventRun || eventRun.invalidatedBy === void 0 || !["completed", "failed", "cancelled"].includes(eventRun.state) || Date.parse(eventRun.updatedAt) > cutoff) break;
+      deleteThrough = sequence;
+    }
+    const deletedEvents = deleteThrough >= this.retentionFloor ? this.events.filter((event) => this.parseCursor(event.cursor) <= deleteThrough) : [];
+    if (deleteThrough >= this.retentionFloor) {
+      this.events.splice(0, this.events.length, ...this.events.filter((event) => this.parseCursor(event.cursor) > deleteThrough));
+      this.retentionFloor = deleteThrough + 1;
+      for (const [consumerId, cursor] of this.consumerCheckpoints) {
+        if (this.parseCursor(cursor) < this.retentionFloor - 1) {
+          this.consumerCheckpoints.delete(consumerId);
+        }
+      }
+    }
+    const activeMessageRunIds = new Set([...this.messages.values()].map((message) => message.runId));
+    const deletableRuns = [...this.runs.values()].filter((run) => run.invalidatedBy !== void 0 && ["completed", "failed", "cancelled"].includes(run.state) && Date.parse(run.updatedAt) <= cutoff && !activeMessageRunIds.has(run.id) && !blockedRunIds.has(run.id) && this.events.filter((event) => event.runId === run.id).every((event) => this.parseCursor(event.cursor) <= consumerFloor && Date.parse(event.createdAt) <= cutoff));
+    const deletedRunIds = deletableRuns.map((run) => run.id);
+    const deletedRunSet = new Set(deletedRunIds);
+    const deletedTools = [...this.toolCalls.values()].filter((tool) => deletedRunSet.has(tool.runId));
+    for (const runId of deletedRunIds) this.runs.delete(runId);
+    for (const [messageId, message] of this.messages) {
+      if (deletedRunSet.has(message.runId)) this.messages.delete(messageId);
+    }
+    for (const tool of deletedTools) this.toolCalls.delete(tool.id);
+    return {
+      deletedRunIds,
+      deletedToolCallIds: deletedTools.map((tool) => tool.id),
+      deletedEventCount: deletedEvents.length,
+      retentionFloor: `${this.incarnation}:${this.retentionFloor}`,
+      ...deletedRunIds.length === 0 && deletedEvents.length === 0 ? { skipped: "no_eligible_events" } : {}
+    };
+  }
   replay(scope, payload) {
     const key = encodeIdempotencyScope(this.incarnation, scope);
     const receipt = this.idempotency.get(key);
@@ -6578,8 +6912,16 @@ var InMemoryStore = class _InMemoryStore {
   messagesForRun(runId) {
     return [...this.messages.values()].filter((message) => message.runId === runId).sort((a, b) => a.sequenceWithinRun - b.sequenceWithinRun);
   }
-  history(agentId, beforeSequence) {
-    return clone([...this.runs.values()].filter((run) => run.agentId === agentId && run.agentSequence <= beforeSequence).sort((a, b) => a.agentSequence - b.agentSequence).flatMap((run) => this.messagesForRun(run.id)));
+  history(lease, agentId) {
+    this.assertOwner(lease);
+    this.requireAgent(agentId);
+    return this.activeHistory(agentId, Number.MAX_SAFE_INTEGER);
+  }
+  activeHistory(agentId, beforeSequence) {
+    return clone([
+      ...this.historySeeds.get(agentId) ?? [],
+      ...[...this.runs.values()].filter((run) => run.agentId === agentId && run.agentSequence <= beforeSequence).sort((a, b) => a.agentSequence - b.agentSequence).flatMap((run) => this.messagesForRun(run.id))
+    ].map((message) => ({ ...message, messageRevision: message.messageRevision ?? 0 })));
   }
   appendMessage(run, message) {
     this.events.push(this.baseEvent(run, {
@@ -6650,6 +6992,12 @@ var MemoryOwnedStore = class {
   async deleteAgent(input) {
     this.store.deleteAgent(this.lease, input);
   }
+  async reviseMessage(input) {
+    return this.store.reviseMessage(this.lease, input);
+  }
+  async compact(input) {
+    return this.store.compact(this.lease, input);
+  }
   async createRun(input) {
     return this.store.createRun(this.lease, input);
   }
@@ -6686,6 +7034,9 @@ var MemoryOwnedStore = class {
   async snapshotRun(runId) {
     return this.store.snapshotRun(this.lease, runId);
   }
+  async history(agentId) {
+    return this.store.history(this.lease, agentId);
+  }
   async listAgents() {
     return this.store.listAgents(this.lease);
   }
@@ -6733,6 +7084,41 @@ function userInputContent(input) {
 function userInputMetadata(input) {
   return typeof input === "string" ? void 0 : input.metadata;
 }
+function targetInput(input, metadata) {
+  const content = typeof input === "string" ? input : input.content;
+  return metadata === void 0 ? { content } : { content, metadata: clone(metadata) };
+}
+function materializeHistorySeed(agentId, source) {
+  const seedRunId = createId("seed");
+  const toolIds = /* @__PURE__ */ new Map();
+  return source.map((message, sequenceWithinRun) => {
+    const content = remapSeedContent(message.content, toolIds);
+    return {
+      ...clone(message),
+      id: createId("msg"),
+      agentId,
+      runId: seedRunId,
+      content,
+      messageRevision: message.messageRevision ?? 0,
+      sequenceWithinRun,
+      createdAt: createTimestamp()
+    };
+  });
+}
+function remapSeedContent(content, toolIds) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "tool_use" || part.type === "tool_result") {
+      const toolCallId = toolIds.get(part.toolCallId) ?? createId("tool");
+      toolIds.set(part.toolCallId, toolCallId);
+      return part.type === "tool_result" ? { ...part, toolCallId, result: clone(part.result) } : { ...part, toolCallId };
+    }
+    return clone(part);
+  });
+}
+function digestToolEffects(toolCalls) {
+  return createHash("sha256").update(canonicalJson(toolCalls)).digest("hex");
+}
 function assertToolValue(value, argument) {
   assertUtf8ByteLimit(canonicalJson(value), TOOL_VALUE_JSON_BYTES, argument);
 }
@@ -6740,8 +7126,9 @@ function assertToolValue(value, argument) {
 // src/runtime/sqlite-durable-store.ts
 import { Database } from "bun:sqlite";
 var SCHEMA_ID = "rowan.agent.runtime";
-var SCHEMA_VERSION = "1";
+var SCHEMA_VERSION = "2";
 var SCHEMA_VALUE = `${SCHEMA_ID}:${SCHEMA_VERSION}`;
+var RETENTION_FLOOR_KEY = "retention_floor";
 var STATE_ROW = 1;
 var CURRENT_TABLES = /* @__PURE__ */ new Set([
   "runtime_meta",
@@ -6909,6 +7296,9 @@ var SqliteStore = class {
   async deleteAgent(lease, input) {
     return this.invoke(lease, (store, current) => store.deleteAgent(current, input));
   }
+  async reviseMessage(lease, input) {
+    return this.invoke(lease, (store, current) => store.reviseMessage(current, input));
+  }
   async createRun(lease, input) {
     return this.invoke(lease, (store, current) => store.createRun(current, input));
   }
@@ -6945,6 +7335,9 @@ var SqliteStore = class {
   async snapshotRun(lease, runId) {
     return this.invoke(lease, (store, current) => store.snapshotRun(current, runId), false);
   }
+  async history(lease, agentId) {
+    return this.invoke(lease, (store, current) => store.history(current, agentId), false);
+  }
   async listAgents(lease) {
     return this.invoke(lease, (store, current) => store.listAgents(current), false);
   }
@@ -6955,15 +7348,19 @@ var SqliteStore = class {
     this.assertOpen();
     return this.readTransaction(() => {
       this.requireMatchingOwner(lease, true);
-      const after = input.after ? parseEventCursor(lease, input.after) : 0;
+      const retentionRow = this.database.query(
+        "SELECT value FROM runtime_meta WHERE key = ?"
+      ).get(RETENTION_FLOOR_KEY);
+      const retentionFloor = Math.max(1, Number(retentionRow?.value ?? "1"));
+      const after = input.after ? parseEventCursor(lease, input.after) : retentionFloor - 1;
+      if (input.after && after < retentionFloor - 1) {
+        throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "expired" });
+      }
       if (input.after) {
         const latest = this.database.query(
-          "SELECT payload_json FROM run_events ORDER BY sequence DESC LIMIT 1"
+          "SELECT max(sequence) AS sequence FROM run_events"
         ).get();
-        const waterline = latest ? parseEventCursor(
-          lease,
-          JSON.parse(latest.payload_json).cursor
-        ) : 0;
+        const waterline = latest.sequence ?? 0;
         if (after > waterline) {
           throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "beyond_waterline" });
         }
@@ -6981,6 +7378,15 @@ var SqliteStore = class {
   async advanceConsumerCheckpoint(lease, input) {
     return this.invoke(lease, (store, current) => store.advanceConsumerCheckpoint(current, input));
   }
+  async compact(lease, input = {}) {
+    this.assertOpen();
+    const result = this.invoke(lease, (store, current) => store.compact(current, input));
+    if (result.deletedEventCount > 0 || result.deletedRunIds.length > 0) {
+      this.database.run("PRAGMA wal_checkpoint(PASSIVE)");
+      this.database.run("PRAGMA incremental_vacuum");
+    }
+    return result;
+  }
   async renewOwner(lease, leaseMs) {
     this.assertOpen();
     assertOwnerInput(lease.ownerId, leaseMs);
@@ -7033,6 +7439,7 @@ var SqliteStore = class {
           if (sql) this.database.run(sql);
         }
         this.database.run("INSERT INTO runtime_meta (key, value) VALUES (?, ?)", ["schema_version", SCHEMA_VALUE]);
+        this.database.run("INSERT INTO runtime_meta (key, value) VALUES (?, ?)", [RETENTION_FLOOR_KEY, "1"]);
         const state = new InMemoryStore();
         this.database.run("INSERT INTO runtime_owner (singleton, epoch) VALUES (?, ?)", [STATE_ROW, 0]);
         this.database.run("INSERT INTO runtime_state (singleton, state_json) VALUES (?, ?)", [STATE_ROW, JSON.stringify(state.exportState())]);
@@ -7081,6 +7488,10 @@ var SqliteStore = class {
   }
   persistState(state) {
     this.writeState(state);
+    this.database.run(
+      "INSERT INTO runtime_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+      [RETENTION_FLOOR_KEY, String(Math.max(1, state.retentionFloor ?? 1))]
+    );
     for (const table of ["consumer_checkpoints", "idempotency", "run_events", "messages", "input_requests", "tool_calls", "runs", "agents"]) {
       this.database.run(`DELETE FROM ${table}`);
     }
@@ -7199,6 +7610,12 @@ var SqliteOwnedStore = class {
   deleteAgent(input) {
     return this.store.deleteAgent(this.lease, input);
   }
+  reviseMessage(input) {
+    return this.store.reviseMessage(this.lease, input);
+  }
+  compact(input) {
+    return this.store.compact(this.lease, input);
+  }
   createRun(input) {
     return this.store.createRun(this.lease, input);
   }
@@ -7235,6 +7652,9 @@ var SqliteOwnedStore = class {
   snapshotRun(runId) {
     return this.store.snapshotRun(this.lease, runId);
   }
+  history(agentId) {
+    return this.store.history(this.lease, agentId);
+  }
   listAgents() {
     return this.store.listAgents(this.lease);
   }