@rowan-agent/agent 0.9.2 → 0.9.4

package/dist/index.d.ts

@@ -778,6 +778,8 @@ type MessageBase = Readonly<{
     id: MessageId;
     agentId: AgentId;
     runId: RunId;
+    /** Monotonic active revision. Omitted on legacy/initial messages and read as 0. */
+    messageRevision?: number;
     metadata?: Metadata;
     sequenceWithinRun: number;
     createdAt: string;
@@ -789,6 +791,7 @@ type UserMessage = MessageBase & Readonly<{
 type AssistantMessage = MessageBase & Readonly<{
     role: "assistant";
     content: AssistantContent;
+    interrupted?: boolean;
 }>;
 type ToolMessage = MessageBase & Readonly<{
     role: "tool";
@@ -887,6 +890,14 @@ type MessageCommitted = DurableEventBase & Readonly<{
     kind: "message_committed";
     message: Message;
 }>;
+type MessageRevised = DurableEventBase & Readonly<{
+    kind: "message_revised";
+    message: UserMessage;
+    previousRevision: number;
+    invalidatedRunIds: readonly RunId[];
+    targetRunId: RunId;
+    cutoffSequenceWithinRun: number;
+}>;
 type RunStateChanged = DurableEventBase & (Readonly<{
     kind: "run_state_changed";
     from: null;
@@ -985,7 +996,7 @@ type ToolStateChanged = DurableEventBase & (Readonly<{
         state: "indeterminate";
     }>;
 }>);
-type DurableRunEvent = MessageCommitted | RunStateChanged | ToolStateChanged;
+type DurableRunEvent = MessageCommitted | MessageRevised | RunStateChanged | ToolStateChanged;
 type MessageDelta = Readonly<{
     kind: "message_delta";
     durability: "transient";
@@ -1264,6 +1275,7 @@ type UserInput = string | Readonly<{
     content: UserContent;
     metadata?: Metadata;
 }>;
+type HistorySeed = readonly Message[];
 type ToolInvocationContext = Readonly<{
     agentId: AgentId;
     runId: RunId;
@@ -1342,6 +1354,11 @@ type AgentRecord = Readonly<{
     activatedAt?: string;
     updatedAt: string;
 }>;
+type AgentDeletionRequest = Readonly<{
+    agentId: AgentId;
+    expectedRunIds: readonly RunId[];
+    confirmation: "conversation-delete-v1";
+}>;
 type ExecutionToken = Readonly<{
     runId: RunId;
     ownerEpoch: number;
@@ -1396,6 +1413,11 @@ type RunRecord = Readonly<{
     revision: number;
     state: RunState;
     input: UserInput;
+    initialMessageId?: MessageId;
+    invalidatedBy?: Readonly<{
+        messageId: MessageId;
+        messageRevision: number;
+    }>;
     metadata?: Metadata;
     pinnedConfigToken?: ConfigToken;
     checkpoint?: ExecutionCheckpoint;
@@ -1407,6 +1429,22 @@ type RunRecord = Readonly<{
     createdAt: string;
     updatedAt: string;
 }>;
+type MessageRevisionResult = Readonly<{
+    message: UserMessage & Readonly<{
+        messageRevision: number;
+    }>;
+    replacementRun: RunRecord;
+    invalidatedRunIds: readonly RunId[];
+    affectedToolCallIds: readonly ToolCallId[];
+    effectDigest?: string;
+}>;
+type RetentionResult = Readonly<{
+    deletedRunIds: readonly RunId[];
+    deletedToolCallIds: readonly ToolCallId[];
+    deletedEventCount: number;
+    retentionFloor: EventCursor;
+    skipped?: "active_consumers" | "no_eligible_events";
+}>;
 type AgentSummary = Readonly<{
     id: AgentId;
     metadata?: Metadata;
@@ -1514,6 +1552,7 @@ interface OwnedStore {
         idempotencyKey: string;
         metadata?: Metadata;
         configIdentity?: string;
+        historySeed?: HistorySeed;
     }): Promise<AgentRecord>;
     activateAgent(agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
     updateAgentConfigToken(input: {
@@ -1522,6 +1561,19 @@ interface OwnedStore {
         configIdentity?: string;
         idempotencyKey: string;
     }): Promise<AgentRecord>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    reviseMessage(input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
     createRun(input: {
         agentId: AgentId;
         input: UserInput;
@@ -1600,8 +1652,10 @@ interface OwnedStore {
         runId: RunId;
         expectedRevision?: number;
         reason?: string;
+        output?: AssistantMessage;
     }): Promise<RunRecord>;
     snapshotRun(runId: RunId): Promise<RunSnapshot>;
+    history(agentId: AgentId): Promise<readonly Message[]>;
     listAgents(): Promise<readonly AgentRecord[]>;
     listRuns(input?: {
         agentId?: AgentId;
@@ -1666,15 +1720,29 @@ interface AgentRuntime$1 {
     createAgent(config: AgentConfigRequest, options?: {
         idempotencyKey?: string;
         metadata?: Metadata;
+        historySeed?: HistorySeed;
     }): Promise<AgentId>;
     updateAgentConfig(agentId: AgentId, config: AgentConfigRequest, options: {
         idempotencyKey: string;
     }): Promise<void>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    revise(agentId: AgentId, input: {
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
     start(agentId: AgentId, input: UserInput, options: {
         idempotencyKey: string;
         metadata?: Metadata;
     }): Promise<AgentRun>;
     run(runId: RunId): AgentRun;
+    history(agentId: AgentId): Promise<readonly Message[]>;
     listAgents(input?: {
         after?: AgentListCursor;
         limit?: number;
@@ -1706,6 +1774,9 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private readonly storeIncarnation;
     private readonly activeAgents;
     private readonly executions;
+    private readonly executionDone;
+    private readonly cancellationRequested;
+    private readonly cancellationReasons;
     private readonly consumers;
     private readonly transientEvents;
     private readonly resources;
@@ -1728,10 +1799,29 @@ declare class AgentRuntime implements AgentRuntime$1 {
     createAgent(config: AgentConfigRequest, options?: {
         idempotencyKey?: string;
         metadata?: Metadata;
+        historySeed?: HistorySeed;
     }): Promise<AgentId>;
     updateAgentConfig(agentId: AgentId, config: AgentConfigRequest, options: {
         idempotencyKey: string;
     }): Promise<void>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    revise(agentId: AgentId, input: {
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<Readonly<{
+        deletedRunIds: readonly RunId[];
+        deletedToolCallIds: readonly ToolCallId[];
+        deletedEventCount: number;
+        retentionFloor: EventCursor;
+        skipped?: "active_consumers" | "no_eligible_events";
+    }>>;
     start(agentId: AgentId, input: UserInput, options: {
         idempotencyKey: string;
         metadata?: Metadata;
@@ -1756,6 +1846,7 @@ declare class AgentRuntime implements AgentRuntime$1 {
     }): Promise<DurableConsumer>;
     close(): Promise<void>;
     snapshot(runId: RunId): Promise<RunSnapshot>;
+    history(agentId: AgentId): Promise<readonly Message[]>;
     respond(runId: RunId, input: {
         requestId: InputRequestId;
         input: UserInput;
@@ -1794,7 +1885,9 @@ type InMemoryStoreState = Readonly<{
     events: readonly DurableRunEvent[];
     idempotency: readonly (readonly [string, IdempotencyReceipt])[];
     operationReceipts: readonly (readonly [string, IdempotencyReceipt])[];
+    historySeeds?: readonly (readonly [AgentId, readonly Message[]])[];
     consumerCheckpoints: readonly (readonly [string, EventCursor])[];
+    retentionFloor?: number;
     nextAgentSequence: readonly (readonly [AgentId, number])[];
     nextReadySequence: readonly (readonly [AgentId, number])[];
     eventSequence: number;
@@ -1808,12 +1901,14 @@ declare class InMemoryStore implements DurableStore {
     private readonly events;
     private readonly idempotency;
     private readonly operationReceipts;
+    private readonly historySeeds;
     private readonly consumerCheckpoints;
     private readonly nextAgentSequence;
     private readonly nextReadySequence;
     private owner?;
     private ownerEpoch;
     private eventSequence;
+    private retentionFloor;
     constructor(options?: {
         incarnation?: string;
     });
@@ -1832,6 +1927,7 @@ declare class InMemoryStore implements DurableStore {
         idempotencyKey: string;
         metadata?: Metadata;
         configIdentity?: string;
+        historySeed?: HistorySeed;
     }): AgentRecord;
     activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): AgentRecord;
     updateAgentConfigToken(lease: OwnerLease, input: {
@@ -1840,6 +1936,15 @@ declare class InMemoryStore implements DurableStore {
         configIdentity?: string;
         idempotencyKey: string;
     }): AgentRecord;
+    deleteAgent(lease: OwnerLease, input: AgentDeletionRequest): void;
+    reviseMessage(lease: OwnerLease, input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): MessageRevisionResult;
     createRun(lease: OwnerLease, input: {
         agentId: AgentId;
         input: UserInput;
@@ -1925,6 +2030,7 @@ declare class InMemoryStore implements DurableStore {
         runId: RunId;
         expectedRevision?: number;
         reason?: string;
+        output?: AssistantMessage;
     }): RunRecord;
     snapshotRun(lease: OwnerLease, runId: RunId): RunSnapshot;
     listAgents(lease: OwnerLease): readonly AgentRecord[];
@@ -1940,6 +2046,10 @@ declare class InMemoryStore implements DurableStore {
         consumerId: string;
         cursor: EventCursor;
     }): void;
+    compact(lease: OwnerLease, input?: {
+        now?: string;
+        retentionMs?: number;
+    }): RetentionResult;
     private replay;
     private writeReceipt;
     private replayOperation;
@@ -1956,7 +2066,8 @@ declare class InMemoryStore implements DurableStore {
     private nextReady;
     private nextMessageSequence;
     private messagesForRun;
-    private history;
+    history(lease: OwnerLease, agentId: AgentId): readonly Message[];
+    private activeHistory;
     private appendMessage;
     private appendTransition;
     private appendToolTransition;
@@ -1979,6 +2090,7 @@ declare class SqliteStore implements DurableStore {
         idempotencyKey: string;
         metadata?: Metadata;
         configIdentity?: string;
+        historySeed?: HistorySeed;
     }): Promise<AgentRecord>;
     activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
     updateAgentConfigToken(lease: OwnerLease, input: {
@@ -1987,6 +2099,15 @@ declare class SqliteStore implements DurableStore {
         configIdentity?: string;
         idempotencyKey: string;
     }): Promise<AgentRecord>;
+    deleteAgent(lease: OwnerLease, input: AgentDeletionRequest): Promise<void>;
+    reviseMessage(lease: OwnerLease, input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
     createRun(lease: OwnerLease, input: {
         agentId: AgentId;
         input: UserInput;
@@ -2072,8 +2193,10 @@ declare class SqliteStore implements DurableStore {
         runId: RunId;
         expectedRevision?: number;
         reason?: string;
+        output?: AssistantMessage;
     }): Promise<RunRecord>;
     snapshotRun(lease: OwnerLease, runId: RunId): Promise<RunSnapshot>;
+    history(lease: OwnerLease, agentId: AgentId): Promise<readonly Message[]>;
     listAgents(lease: OwnerLease): Promise<readonly AgentRecord[]>;
     listRuns(lease: OwnerLease, input?: {
         agentId?: AgentId;
@@ -2087,6 +2210,10 @@ declare class SqliteStore implements DurableStore {
         consumerId: string;
         cursor: EventCursor;
     }): Promise<void>;
+    compact(lease: OwnerLease, input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
     renewOwner(lease: OwnerLease, leaseMs: number): Promise<OwnerLease>;
     sealAndReleaseOwner(lease: OwnerLease): Promise<void>;
     private invoke;
@@ -2125,7 +2252,7 @@ declare class InMemoryConfigProvider implements ConfigProvider {
 }
 declare function brandConfigToken(raw: unknown): ConfigToken;
 
-type RuntimeErrorCode = "invalid_argument" | "runtime_closed" | "runtime_already_owned" | "runtime_ownership_lost" | "agent_not_found" | "run_not_found" | "run_state_conflict" | "input_request_conflict" | "idempotency_conflict" | "configuration_unavailable" | "checkpoint_incompatible" | "consumer_already_active" | "invalid_cursor" | "store_unavailable" | "unsupported_store_version";
+type RuntimeErrorCode = "invalid_argument" | "runtime_closed" | "runtime_already_owned" | "runtime_ownership_lost" | "agent_not_found" | "run_not_found" | "run_state_conflict" | "message_revision_conflict" | "tool_effect_confirmation_required" | "input_request_conflict" | "idempotency_conflict" | "configuration_unavailable" | "checkpoint_incompatible" | "consumer_already_active" | "invalid_cursor" | "store_unavailable" | "unsupported_store_version";
 type RuntimeErrorDetails = {
     invalid_argument: Readonly<{
         argument: string;
@@ -2153,6 +2280,18 @@ type RuntimeErrorDetails = {
         expected: readonly RunState[];
         actual: RunState;
     }>;
+    message_revision_conflict: Readonly<{
+        agentId: AgentId;
+        messageId: MessageId;
+        expected: number;
+        actual: number;
+    }>;
+    tool_effect_confirmation_required: Readonly<{
+        agentId: AgentId;
+        messageId: MessageId;
+        effectDigest: string;
+        toolCallIds: readonly ToolCallId[];
+    }>;
     input_request_conflict: Readonly<{
         runId: RunId;
         requestId: InputRequestId;
@@ -2184,7 +2323,7 @@ type RuntimeErrorDetails = {
     }>;
     invalid_cursor: Readonly<{
         cursorType: "agent_list" | "run_list" | "event";
-        reason: "malformed" | "wrong_store" | "wrong_collection" | "filter_mismatch" | "beyond_waterline";
+        reason: "malformed" | "wrong_store" | "wrong_collection" | "filter_mismatch" | "beyond_waterline" | "expired";
     }>;
     store_unavailable: Readonly<{
         operation: string;
@@ -2260,4 +2399,4 @@ declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): Fro
 
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-export { type AfterToolCall, type AgentConfig, type AgentConfigRequest, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentResources, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type CoreToolContext, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecutionIdentity, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, materializeConfigurationSnapshot, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+export { type AfterToolCall, type AgentConfig, type AgentConfigRequest, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentResources, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type CoreToolContext, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecutionIdentity, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, materializeConfigurationSnapshot, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

package/dist/index.js

@@ -2879,6 +2879,14 @@ function isImage(value) {
 function isUserContent(value) {
   return typeof value === "string" || Array.isArray(value) && value.every((part) => isText(part) || isImage(part));
 }
+function isAssistantContent(value) {
+  return typeof value === "string" || Array.isArray(value) && value.every((part) => {
+    if (isText(part)) return true;
+    if (!isRecord3(part)) return false;
+    if (part.type === "thinking") return typeof part.thinking === "string" && (part.signature === void 0 || typeof part.signature === "string");
+    return part.type === "tool_use" && typeof part.toolCallId === "string" && typeof part.name === "string" && isJsonValue(part.input);
+  });
+}
 function normalizeUserInput(input) {
   const normalized = typeof input === "string" ? { content: input } : input;
   if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata"]) || !isUserContent(normalized.content)) throw new TypeError("input must contain only valid UserContent");
@@ -2886,6 +2894,9 @@ function normalizeUserInput(input) {
   assertJsonValue(normalized, "input");
   return normalized;
 }
+function isAssistantMessage(value) {
+  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;
   const expected = value.ok ? ["content", "ok"] : ["content", "error", "ok"];
@@ -3182,6 +3193,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;
@@ -3402,18 +3414,23 @@ function projectModelContext(input) {
     ...input.context.phases ? { phases: input.context.phases } : {}
   };
 }
-function projectAssistantMessage(message, agentId, runId, sequenceWithinRun) {
+function projectAssistantMessage(message, agentId, runId, sequenceWithinRun, options = {}) {
   return {
     id: message.id,
     agentId,
     runId,
     role: "assistant",
-    content: durableAssistantContent(message.content),
+    content: options.interrupted ? durableInterruptedAssistantContent(message.content) : durableAssistantContent(message.content),
     sequenceWithinRun,
     createdAt: message.createdAt,
-    ...message.metadata ? { metadata: message.metadata } : {}
+    ...message.metadata ? { metadata: message.metadata } : {},
+    ...options.interrupted ? { interrupted: true } : {}
   };
 }
+function durableInterruptedAssistantContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((part) => part.type === "text").map((part) => ({ type: "text", text: part.text }));
+}
 function projectMessage(message) {
   switch (message.role) {
     case "user":
@@ -5103,6 +5120,9 @@ var AgentRuntime = class _AgentRuntime {
   storeIncarnation;
   activeAgents = /* @__PURE__ */ new Set();
   executions = /* @__PURE__ */ new Map();
+  executionDone = /* @__PURE__ */ new Map();
+  cancellationRequested = /* @__PURE__ */ new Set();
+  cancellationReasons = /* @__PURE__ */ new Map();
   consumers = /* @__PURE__ */ new Map();
   transientEvents = new TransientRunEventHub();
   resources;
@@ -5160,6 +5180,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()
     });
   }
@@ -5167,6 +5188,33 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     await this.commands.updateAgentConfig({ agentId, config, idempotencyKey: options.idempotencyKey });
   }
+  async deleteAgent(input) {
+    this.assertOpen();
+    const runs = await this.owned.listRuns({ agentId: input.agentId });
+    for (const run of runs) {
+      if (["queued", "running", "input_required"].includes(run.state)) {
+        await this.cancel(run.id, "Conversation deleted.");
+      }
+    }
+    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);
@@ -5220,6 +5268,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);
@@ -5231,6 +5283,14 @@ var AgentRuntime = class _AgentRuntime {
   }
   async cancel(runId, reason) {
     this.assertOpen();
+    const done = this.executionDone.get(runId);
+    if (done) {
+      this.cancellationRequested.add(runId);
+      this.cancellationReasons.set(runId, reason ?? "Agent run stopped.");
+      this.executions.get(runId)?.controller.abort();
+      await done;
+      return boundaryFromSnapshot(await this.owned.snapshotRun(runId));
+    }
     const snapshot = await this.owned.snapshotRun(runId);
     await this.owned.cancelRun({ runId, expectedRevision: snapshot.revision, ...reason === void 0 ? {} : { reason } });
     const active = this.executions.get(runId);
@@ -5252,8 +5312,12 @@ var AgentRuntime = class _AgentRuntime {
           if (execution) this.transientEvents.clear(next.id, execution.executionId);
           this.activeAgents.delete(next.agentId);
           this.executions.delete(next.id);
+          this.cancellationRequested.delete(next.id);
+          this.cancellationReasons.delete(next.id);
+          this.executionDone.delete(next.id);
           void this.pump();
         });
+        this.executionDone.set(next.id, task);
         void task;
       }
     } catch (error) {
@@ -5311,6 +5375,7 @@ var AgentRuntime = class _AgentRuntime {
       executionRevision = claim.run.revision;
       const controller = new AbortController();
       this.executions.set(run.id, { controller, executionId });
+      if (this.cancellationRequested.has(run.id)) controller.abort();
       const config = resolvedConfig;
       const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner);
       let toolQueue = Promise.resolve();
@@ -5399,6 +5464,18 @@ var AgentRuntime = class _AgentRuntime {
           }
         }
       });
+      if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
+        const output = latestAssistant(run, result.messages, claim.history.length, true);
+        const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
+        await this.owned.cancelRun({
+          runId: run.id,
+          expectedRevision: executionRevision,
+          reason,
+          ...output && hasVisibleAssistantText(output) ? { output } : {}
+        });
+        this.transientEvents.clear(run.id, claim.execution.executionId);
+        return;
+      }
       if (result.type === "input_required") {
         const prompt = promptMessage(run, result.request.prompt, result.messages.length);
         await this.owned.commitInputRequired({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, requestId: createId("input"), phase: result.request.phase, prompt, checkpoint: result.checkpoint });
@@ -5417,6 +5494,14 @@ var AgentRuntime = class _AgentRuntime {
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
+        if (this.cancellationRequested.has(run.id)) {
+          await this.owned.cancelRun({
+            runId: run.id,
+            expectedRevision: executionRevision,
+            reason: this.cancellationReasons.get(run.id) ?? "Agent run stopped."
+          }).catch(() => void 0);
+          return;
+        }
         await this.owned.commitOutcome({
           runId: run.id,
           execution: claim.execution,
@@ -5663,10 +5748,13 @@ var DurableRun = class {
 function promptMessage(run, prompt, sequence) {
   return { id: createId("msg"), agentId: run.agentId, runId: run.id, role: "assistant", content: prompt, sequenceWithinRun: sequence, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
-function latestAssistant(run, messages, sequence) {
+function latestAssistant(run, messages, sequence, interrupted = false) {
   const message = [...messages].reverse().find((candidate) => candidate.role === "assistant");
   if (!message) return void 0;
-  return projectAssistantMessage(message, run.agentId, run.id, sequence);
+  return projectAssistantMessage(message, run.agentId, run.id, sequence, { interrupted });
+}
+function hasVisibleAssistantText(message) {
+  return typeof message.content === "string" ? message.content.length > 0 : message.content.some((part) => part.type === "text" && part.text.length > 0);
 }
 function durableOutcome(outcome) {
   return {
@@ -5728,6 +5816,7 @@ function deferred2() {
 }
 
 // src/runtime/durable-store.ts
+import { createHash } from "crypto";
 var InMemoryStore = class _InMemoryStore {
   incarnation;
   agents = /* @__PURE__ */ new Map();
@@ -5737,12 +5826,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");
   }
@@ -5755,10 +5846,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)
@@ -5775,7 +5868,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
@@ -5851,7 +5946,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);
@@ -5863,6 +5959,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);
@@ -5890,6 +5987,178 @@ var InMemoryStore = class _InMemoryStore {
     this.writeReceipt(scope, payload, agent);
     return clone(agent);
   }
+  deleteAgent(lease, input) {
+    this.assertOwner(lease);
+    if (input.confirmation !== "conversation-delete-v1") {
+      throw new TypeError("Agent deletion requires the conversation deletion confirmation token");
+    }
+    const agent = this.requireAgent(input.agentId);
+    const runs = [...this.runs.values()].filter((run) => run.agentId === agent.id);
+    const expected = new Set(input.expectedRunIds.map(String));
+    const actual = new Set(runs.map((run) => String(run.id)));
+    if (expected.size !== actual.size || [...actual].some((runId) => !expected.has(runId))) {
+      throw new RuntimeError("run_state_conflict", {
+        runId: runs[0]?.id ?? input.expectedRunIds[0] ?? "unknown",
+        expected: [],
+        actual: "cancelled"
+      });
+    }
+    const runIds = new Set(runs.map((run) => run.id));
+    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);
+    }
+    for (const [toolCallId, toolCall] of this.toolCalls) {
+      if (runIds.has(toolCall.runId)) this.toolCalls.delete(toolCallId);
+    }
+    for (let index = this.events.length - 1; index >= 0; index -= 1) {
+      if (this.events[index].agentId === agent.id) this.events.splice(index, 1);
+    }
+    for (const [key] of this.idempotency) {
+      if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) this.idempotency.delete(key);
+    }
+    for (const [key] of this.operationReceipts) {
+      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);
@@ -5937,7 +6206,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"),
@@ -5962,7 +6231,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;
   }
@@ -6258,11 +6527,16 @@ var InMemoryStore = class _InMemoryStore {
   cancelRun(lease, input) {
     this.assertOwner(lease);
     const operationKey = `cancel:${input.runId}:${input.expectedRevision ?? "current"}`;
-    const operationPayload = canonicalJson(input.reason ?? null);
+    const operationPayload = canonicalJson([input.reason ?? null, input.output ?? null]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
     const run = this.requireRun(input.runId);
     if (input.expectedRevision !== void 0) this.assertRevision(run, input.expectedRevision);
+    if (input.output !== void 0) {
+      if (!isAssistantMessage(input.output) || input.output.agentId !== run.agentId || input.output.runId !== run.id || input.output.interrupted !== true) {
+        throw new TypeError("cancelled output must be an interrupted AssistantMessage from this Run");
+      }
+    }
     if (["completed", "failed", "cancelled"].includes(run.state)) {
       const result2 = clone(run);
       if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result2);
@@ -6272,6 +6546,11 @@ var InMemoryStore = class _InMemoryStore {
     const activeToolCalls = run.execution ? [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running")) : [];
     const indeterminateToolCallIds = activeToolCalls.filter((toolCall) => toolCall.state === "running").map((toolCall) => toolCall.id);
     for (const toolCall of activeToolCalls) this.interruptToolCall(run, toolCall, input.reason ?? "The Run was cancelled.");
+    if (input.output && (typeof input.output.content === "string" ? input.output.content.length > 0 : input.output.content.length > 0)) {
+      const output = { ...clone(input.output), sequenceWithinRun: this.nextMessageSequence(run.id) };
+      this.messages.set(output.id, output);
+      this.appendMessage(run, output);
+    }
     if (indeterminateToolCallIds.length > 0) {
       const failure = {
         code: "tool_indeterminate",
@@ -6347,7 +6626,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" });
     }
@@ -6364,11 +6646,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);
@@ -6466,8 +6809,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, {
@@ -6535,6 +6886,15 @@ var MemoryOwnedStore = class {
   async updateAgentConfigToken(input) {
     return this.store.updateAgentConfigToken(this.lease, input);
   }
+  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);
   }
@@ -6571,6 +6931,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);
   }
@@ -6618,6 +6981,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);
 }
@@ -6625,8 +7023,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",
@@ -6791,6 +7190,12 @@ var SqliteStore = class {
   async updateAgentConfigToken(lease, input) {
     return this.invoke(lease, (store, current) => store.updateAgentConfigToken(current, input));
   }
+  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));
   }
@@ -6827,6 +7232,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);
   }
@@ -6837,24 +7245,28 @@ 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" });
         }
         if (after === waterline) return [];
       }
       const rows = this.database.query(
-        "SELECT payload_json FROM run_events ORDER BY sequence LIMIT -1 OFFSET ?"
-      ).all(after);
-      return rows.map((row) => JSON.parse(row.payload_json));
+        "SELECT payload_json FROM run_events ORDER BY sequence"
+      ).all();
+      return rows.map((row) => JSON.parse(row.payload_json)).filter((event) => parseEventCursor(lease, event.cursor) > after);
     });
   }
   async openConsumer(lease, consumerId) {
@@ -6863,6 +7275,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);
@@ -6915,6 +7336,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())]);
@@ -6963,6 +7385,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}`);
     }
@@ -7078,6 +7504,15 @@ var SqliteOwnedStore = class {
   updateAgentConfigToken(input) {
     return this.store.updateAgentConfigToken(this.lease, input);
   }
+  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);
   }
@@ -7114,6 +7549,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);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "license": "MIT",
   "repository": {
     "type": "git",