stitchkit 0.85.1 → 0.86.0

package/dist/agent-runtime.js

@@ -1,10 +1,5 @@
-import {
-  messageOf
-} from "./index-p13mwz16.js";
 import {
   ACTIVE_AGENT_RUN_STATES,
-  AcceptInputAndAssignRunSchema,
-  AcquireAgentRunSchema,
   AgentAdmissionReceiptSchema,
   AgentConversationMessagePageSchema,
   AgentConversationPageSchema,
@@ -13,43 +8,57 @@ import {
   AgentConversationPurgedError,
   AgentConversationSummarySchema,
   AgentHistoryMutationSchema,
-  AgentRecoverableDescriptorSchema,
-  AgentRecoverablePageSchema,
-  AgentRunViewSchema,
   AgentRuntimeHeadSchema,
-  AgentStoreAppliedSchema,
-  AgentStoreConflictSchema,
-  AgentStoreDuplicateSchema,
-  AgentStoreMutationResultSchema,
-  AgentStoreNotFoundSchema,
   AgentStoredRunSchema,
-  CheckpointRunAssistantSchema,
-  CommitRunTerminalSchema,
-  RecordRunOperationSchema,
-  RecoverAgentRunSchema,
-  ReplaceCompactedRangeSchema,
-  RequestRunInterruptSchema,
   createAgentRuntimeStore,
   createMemoryAgentRuntimeStore,
   purgeAgentConversation
-} from "./index-fq492hg0.js";
+} from "./index-hber83mk.js";
 import {
   AgentContextOverflowError,
+  AgentProviderStreamCutError,
   AgentRuntimeConflictError,
   AgentTokenCountSchema,
+  agentGoalStateSlot,
+  agentTodoStateSlot,
+  classifyProviderFailure,
   composeAgentPrompt,
   createAgentRuntime,
   createAgentRuntimeEventSink,
   createAgentSessionCoordinator,
+  createAgentStateSlotStore,
   createAgentToolFenceLifecycle,
   deferredToolCatalog,
+  defineStateSlot,
+  isToolResultFailure,
+  normalizeSdkUsage,
   projectAgentHistory,
   projectAgentHistoryDetailed,
+  recordAgentRetryDecision,
   registerDeferredToolCatalog,
   registerDeferredToolRepair,
+  renderAgentStateSlots,
   repairedSearchCall,
   selectAgentHistory
-} from "./index-jpp7jd1p.js";
+} from "./index-33xckd7h.js";
+import"./index-p13mwz16.js";
+import {
+  AgentAdmissionEventSchema,
+  AgentAttemptResetEventSchema,
+  AgentCheckpointEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentRunOperationEventSchema,
+  AgentRunStateEventSchema,
+  AgentRuntimeEventCursorSchema,
+  AgentRuntimeEventSchema,
+  AgentTerminalEventSchema,
+  AgentToolStatusEventSchema,
+  AgentTransientDeltaEventSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId
+} from "./index-hkm6wysp.js";
 import {
   AgentModelCapabilitySchema,
   AgentModelCatalogEntrySchema,
@@ -72,24 +81,34 @@ import {
   isCompleteAgentHistoryTurn
 } from "./index-y2s6h5bf.js";
 import {
-  createBoundedSinkManager
-} from "./index-wnfk50r0.js";
-import {
-  AgentAdmissionEventSchema,
-  AgentCheckpointEventSchema,
-  AgentReasoningDeltaEventSchema,
-  AgentReasoningEndEventSchema,
-  AgentReasoningStartEventSchema,
-  AgentRunOperationEventSchema,
-  AgentRunStateEventSchema,
-  AgentRuntimeEventCursorSchema,
-  AgentRuntimeEventSchema,
-  AgentTerminalEventSchema,
-  AgentToolStatusEventSchema,
-  AgentTransientDeltaEventSchema,
-  advanceAgentRuntimeEventCursor,
-  agentDurableEventId
-} from "./index-4hk633vz.js";
+  AcceptInputAndAssignRunSchema,
+  AcquireAgentRunSchema,
+  AgentConversationArchiveSchema,
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
+  AgentRunViewSchema,
+  AgentStoreAppliedSchema,
+  AgentStoreConflictSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventKindSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreMutationResultSchema,
+  AgentStoreNotFoundSchema,
+  AgentStoreTransitionSchema,
+  AppendAgentStoreEventSchema,
+  CheckpointRunAssistantSchema,
+  CommitRunTerminalSchema,
+  ReadAgentStoreEventsSchema,
+  RecordRunOperationSchema,
+  RecoverAgentRunSchema,
+  ReplaceCompactedRangeSchema,
+  RequestRunInterruptSchema,
+  canonicalAgentJson,
+  decodeAgentConversationArchive,
+  decodeAgentStoreEvent,
+  encodeAgentConversationArchive
+} from "./index-vfgb58nf.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentControlPartSchema,
@@ -125,21 +144,31 @@ import {
   AgentUsageSchema,
   AgentUsageValueSchema,
   runStateForTerminalReason
-} from "./index-x15ss2dx.js";
+} from "./index-p1b1y93x.js";
+import {
+  createBoundedSinkManager
+} from "./index-wnfk50r0.js";
+import {
+  AgentSandboxGradeSchema,
+  AgentSandboxRestrictionSchema,
+  missingSandboxRestrictions,
+  probeAgentProcessSandbox,
+  recordAgentSandboxProbe
+} from "./index-gskm1k5a.js";
 import {
   buildToolManifest,
   mountAgent
-} from "./index-3ds42w1w.js";
+} from "./index-1szetq6f.js";
 import"./index-3xnq72rz.js";
-import"./index-s4ckmrac.js";
+import"./index-rcgsnrr6.js";
 import {
   defineRuntimeTool
-} from "./index-dx9xehwt.js";
-import"./index-fwbkp2jn.js";
-import"./index-dggwnnjv.js";
+} from "./index-kc6h6hg0.js";
+import"./index-0vfdh685.js";
+import"./index-wn9cb82y.js";
 import"./index-vsbzgd7b.js";
 import"./index-f9mb610r.js";
-import"./index-mgtxfe6b.js";
+import"./index-r159gjwy.js";
 import"./index-cby4ar3v.js";
 import"./index-7zbps32p.js";
 import"./index-7evdsyez.js";
@@ -152,10 +181,501 @@ import {
 } from "./index-zcgf3gqf.js";
 import"./index-kzfs85xp.js";
 import {
-  executableAgentRuntimeTools,
-  isRecord
+  executableAgentRuntimeTools
 } from "./index-77fekveh.js";
 
+// src/agent-runtime/child-tools.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/agent-tool.ts
+function defineAgentTool(definition) {
+  return {
+    ...definition,
+    handler: (context) => definition.handler(context)
+  };
+}
+
+// src/agent-runtime/children.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var AgentChildBudgetSchema = z.object({
+  usd: z.number().positive().optional(),
+  tokens: z.int().positive().optional(),
+  milliseconds: z.int().positive().optional()
+}).strict();
+var AgentChildStateSchema = z.enum([
+  "spawned",
+  "running",
+  "finished",
+  "stopped",
+  "lost"
+]);
+var AgentChildRecordSchema = z.object({
+  parentConversationId: z.string().min(1),
+  childConversationId: z.string().min(1),
+  seedUptoSeq: z.int().nonnegative(),
+  state: AgentChildStateSchema,
+  budget: AgentChildBudgetSchema,
+  usage: z.object({
+    tokens: z.int().nonnegative(),
+    usd: z.number().nonnegative(),
+    milliseconds: z.int().nonnegative()
+  }).strict(),
+  resultReference: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).strict();
+var ChildRowSchema = z.object({
+  parent_conversation_id: z.string(),
+  child_conversation_id: z.string(),
+  seed_upto_seq: z.int().nonnegative(),
+  state: AgentChildStateSchema,
+  budget_payload: z.string(),
+  usage_payload: z.string(),
+  result_reference: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+function parseChild(raw) {
+  const row = ChildRowSchema.parse(raw);
+  return AgentChildRecordSchema.parse({
+    parentConversationId: row.parent_conversation_id,
+    childConversationId: row.child_conversation_id,
+    seedUptoSeq: row.seed_upto_seq,
+    state: row.state,
+    budget: JSON.parse(row.budget_payload),
+    usage: JSON.parse(row.usage_payload),
+    ...row.result_reference && { resultReference: row.result_reference },
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  });
+}
+function usageNumbers(usage) {
+  const inputTokens = usage.inputTokens.value;
+  const outputTokens = usage.outputTokens.value;
+  return {
+    ...inputTokens !== undefined && outputTokens !== undefined ? { tokens: inputTokens + outputTokens } : {},
+    ...usage.cost?.currency === "USD" && usage.cost.value !== undefined ? { usd: usage.cost.value } : {}
+  };
+}
+function createSqliteAgentChildManager(input) {
+  const now = input.now ?? (() => new Date);
+  const database = input.sqlite.database;
+  const store = input.sqlite.store;
+  const handles = new Map;
+  const settlements = new Map;
+  const currentState = (childConversationId) => {
+    const raw = database.prepare("SELECT state FROM stitchkit_agent_runtime_children WHERE child_conversation_id = ?").get(childConversationId);
+    return raw === null || raw === undefined ? undefined : AgentChildStateSchema.parse(raw.state);
+  };
+  const isLive = (childConversationId) => {
+    const state = currentState(childConversationId);
+    return state === "spawned" || state === "running";
+  };
+  const settleable = (childConversationId) => {
+    const state = currentState(childConversationId);
+    return state === undefined || state === "spawned" || state === "running";
+  };
+  const STOP_BOUND_MS = 1e4;
+  const bounded = async (work, fallback) => {
+    let timer;
+    try {
+      return await Promise.race([
+        Promise.resolve(work),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(fallback), STOP_BOUND_MS);
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+  const listChildren = (parentConversationId) => database.prepare(`
+        SELECT parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+          budget_payload, usage_payload, result_reference, created_at, updated_at
+        FROM stitchkit_agent_runtime_children
+        WHERE parent_conversation_id = ? ORDER BY created_at, child_conversation_id
+      `).all(parentConversationId).map(parseChild);
+  const updateState = async (record, state, resultReference, details = {}) => {
+    const updatedAt = now().toISOString();
+    const payload = {
+      childConversationId: record.childConversationId,
+      state,
+      ...resultReference && { resultReference },
+      ...details
+    };
+    const childPayload = {
+      parentConversationId: record.parentConversationId,
+      state,
+      ...resultReference && { resultReference },
+      ...details
+    };
+    const write = (audience) => input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+            UPDATE stitchkit_agent_runtime_children
+            SET state = ?, result_reference = ?, updated_at = ? WHERE child_conversation_id = ?
+          `).run(state, resultReference ?? null, updatedAt, record.childConversationId);
+      if (audience === "both") {
+        await scope.appendEvent({
+          conversationId: record.parentConversationId,
+          kind: "child/state",
+          occurredAt: updatedAt,
+          payload
+        });
+      }
+      if (audience !== "row") {
+        await scope.appendEvent({
+          conversationId: record.childConversationId,
+          kind: "child/state",
+          occurredAt: updatedAt,
+          payload: childPayload
+        });
+      }
+    });
+    try {
+      await write("both");
+    } catch (error) {
+      if (!(error instanceof AgentConversationPurgedError))
+        throw error;
+      try {
+        await write("child");
+      } catch (inner) {
+        if (!(inner instanceof AgentConversationPurgedError))
+          throw inner;
+        await write("row");
+      }
+    }
+  };
+  const spawnChild = async (request) => {
+    const requestedBudget = AgentChildBudgetSchema.parse(request.budget);
+    const remaining = input.remainingBudget ? AgentChildBudgetSchema.parse(await input.remainingBudget(request.parentConversationId)) : undefined;
+    const bounded2 = (requested, available) => {
+      if (requested === undefined)
+        return available;
+      if (available === undefined)
+        return requested;
+      return Math.min(requested, available);
+    };
+    const usd = bounded2(requestedBudget.usd, remaining?.usd);
+    const tokens = bounded2(requestedBudget.tokens, remaining?.tokens);
+    const milliseconds = bounded2(requestedBudget.milliseconds, remaining?.milliseconds);
+    const budget = AgentChildBudgetSchema.parse({
+      ...usd !== undefined && { usd },
+      ...tokens !== undefined && { tokens },
+      ...milliseconds !== undefined && { milliseconds }
+    });
+    const events = [];
+    let cursor = 1;
+    for (;; ) {
+      const page = await store.readEvents({
+        conversationId: request.parentConversationId,
+        fromSeq: cursor,
+        ...request.seedUptoSeq !== undefined && { toSeq: request.seedUptoSeq },
+        limit: 1000
+      });
+      events.push(...page.items);
+      if (page.nextSeq === undefined)
+        break;
+      cursor = page.nextSeq;
+    }
+    const seedUptoSeq = events.at(-1)?.seq ?? 0;
+    const childConversationId = request.childConversationId ?? randomUUID();
+    const createdAt = now().toISOString();
+    const record = AgentChildRecordSchema.parse({
+      parentConversationId: request.parentConversationId,
+      childConversationId,
+      seedUptoSeq,
+      state: "spawned",
+      budget,
+      usage: { tokens: 0, usd: 0, milliseconds: 0 },
+      createdAt,
+      updatedAt: createdAt
+    });
+    const seedArchive = encodeAgentConversationArchive({
+      format: "stitchkit.agent-conversation",
+      formatVersion: 1,
+      conversationId: request.parentConversationId,
+      events,
+      projections: [],
+      spills: []
+    });
+    const handle = await input.spawn({
+      parentConversationId: record.parentConversationId,
+      childConversationId,
+      seedArchive,
+      childInput: request.childInput,
+      budget
+    });
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_children (
+            parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+            budget_payload, usage_payload, result_reference, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
+        `).run(record.parentConversationId, record.childConversationId, record.seedUptoSeq, record.state, JSON.stringify(record.budget), JSON.stringify(record.usage), createdAt, createdAt);
+      await scope.appendEvent({
+        conversationId: record.parentConversationId,
+        kind: "child/spawned",
+        occurredAt: createdAt,
+        payload: { childConversationId, seedUptoSeq, budget }
+      });
+    });
+    handles.set(childConversationId, handle);
+    await updateState(record, "running");
+    const settlement = handle.result.then(async (result) => {
+      handles.delete(childConversationId);
+      if (settleable(childConversationId)) {
+        await updateState(record, "finished", result.resultReference);
+      }
+    }, async () => {
+      handles.delete(childConversationId);
+      if (settleable(childConversationId))
+        await updateState(record, "stopped");
+    });
+    settlements.set(childConversationId, settlement);
+    return { ...record, state: "running", updatedAt: now().toISOString() };
+  };
+  const recordStepUsage = async (request) => {
+    const raw = database.prepare(`
+        SELECT parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+          budget_payload, usage_payload, result_reference, created_at, updated_at
+        FROM stitchkit_agent_runtime_children WHERE child_conversation_id = ?
+      `).get(request.childConversationId);
+    if (raw === null || raw === undefined)
+      throw new TypeError("Unknown child conversation");
+    const record = parseChild(raw);
+    const measured = usageNumbers(request.usage);
+    if (record.budget.tokens !== undefined && measured.tokens === undefined) {
+      throw new TypeError("Cannot enforce child token budget without measured token usage");
+    }
+    if (record.budget.usd !== undefined && measured.usd === undefined) {
+      throw new TypeError("Cannot enforce child USD budget without USD usage");
+    }
+    const usage = {
+      tokens: record.usage.tokens + (measured.tokens ?? 0),
+      usd: record.usage.usd + (measured.usd ?? 0),
+      milliseconds: record.usage.milliseconds + request.elapsedMs
+    };
+    const updatedAt = now().toISOString();
+    const overrun = {
+      tokens: Math.max(0, usage.tokens - (record.budget.tokens ?? Number.POSITIVE_INFINITY)),
+      usd: Math.max(0, usage.usd - (record.budget.usd ?? Number.POSITIVE_INFINITY)),
+      milliseconds: Math.max(0, usage.milliseconds - (record.budget.milliseconds ?? Number.POSITIVE_INFINITY))
+    };
+    const stop = record.budget.tokens !== undefined && usage.tokens >= record.budget.tokens || record.budget.usd !== undefined && usage.usd >= record.budget.usd || record.budget.milliseconds !== undefined && usage.milliseconds >= record.budget.milliseconds;
+    const handle = handles.get(request.childConversationId);
+    let enforced = false;
+    if (stop && handle) {
+      enforced = await bounded(Promise.resolve().then(() => handle.stopPolicy("child-budget")).then(() => true, () => false), false);
+    }
+    const payload = {
+      childConversationId: record.childConversationId,
+      state: "running",
+      usage,
+      overrun,
+      ...stop && { policyName: "child-budget", enforced }
+    };
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare("UPDATE stitchkit_agent_runtime_children SET usage_payload = ?, updated_at = ? WHERE child_conversation_id = ?").run(JSON.stringify(usage), updatedAt, request.childConversationId);
+      await scope.appendEvent({
+        conversationId: record.parentConversationId,
+        kind: "child/state",
+        occurredAt: updatedAt,
+        payload
+      });
+      await scope.appendEvent({
+        conversationId: record.childConversationId,
+        kind: "child/state",
+        occurredAt: updatedAt,
+        payload: { parentConversationId: record.parentConversationId, ...payload }
+      });
+    });
+    return { stop, enforced, ...stop && { policyName: "child-budget" }, overrun };
+  };
+  const stopChildren = async (parentConversationId) => {
+    const records = listChildren(parentConversationId).filter((record) => record.state === "spawned" || record.state === "running");
+    await Promise.all(records.map(async (record) => {
+      const startedAt = performance.now();
+      const handle = handles.get(record.childConversationId);
+      const reachable = handle ? handle.reachable ? await bounded(handle.reachable(), false) : true : false;
+      if (!reachable) {
+        if (isLive(record.childConversationId)) {
+          await updateState(record, "lost", undefined, {
+            stopDurationMs: Math.max(0, performance.now() - startedAt)
+          });
+        }
+        return;
+      }
+      await bounded(Promise.resolve(handle?.stopPolicy("parent-stopped")).then(() => true), false);
+      if (!isLive(record.childConversationId))
+        return;
+      await updateState(record, "stopped", undefined, {
+        stopDurationMs: Math.max(0, performance.now() - startedAt)
+      });
+    }));
+  };
+  const activeChild = (parentConversationId, childConversationId) => {
+    const child = listChildren(parentConversationId).find((record) => record.childConversationId === childConversationId);
+    if (!child)
+      throw new TypeError("Unknown child conversation for this parent");
+    if (child.state !== "running" && child.state !== "spawned") {
+      throw new TypeError("Child conversation is not active");
+    }
+    const handle = handles.get(childConversationId);
+    if (!handle)
+      throw new TypeError("Child host handle is unavailable");
+    return { child, handle };
+  };
+  const sendMessage = async (parentConversationId, childConversationId, message) => {
+    const { handle } = activeChild(parentConversationId, childConversationId);
+    if (!handle.sendMessage)
+      throw new TypeError("Child host does not support messages");
+    await handle.sendMessage(message);
+    await store.appendEvent({
+      conversationId: parentConversationId,
+      kind: "child/state",
+      payload: { childConversationId, action: "message-sent" }
+    });
+  };
+  const interruptChild = async (parentConversationId, childConversationId) => {
+    const { child, handle } = activeChild(parentConversationId, childConversationId);
+    const startedAt = performance.now();
+    await handle.stopPolicy("parent-interrupt");
+    await updateState(child, "stopped", undefined, {
+      policyName: "parent-interrupt",
+      stopDurationMs: Math.max(0, performance.now() - startedAt)
+    });
+  };
+  const waitChild = async (childConversationId) => {
+    await settlements.get(childConversationId);
+  };
+  return {
+    spawnChild,
+    listChildren,
+    recordStepUsage,
+    stopChildren,
+    sendMessage,
+    interruptChild,
+    waitChild
+  };
+}
+function agentChildBudgetStopPolicy(input) {
+  let stepsSeen = 0;
+  let lastBoundary = performance.now();
+  return {
+    name: "child-budget",
+    when: async ({ steps }) => {
+      const step = steps.at(-1);
+      if (!step || steps.length <= stepsSeen)
+        return false;
+      stepsSeen = steps.length;
+      const elapsedMs = Math.max(0, performance.now() - lastBoundary);
+      lastBoundary = performance.now();
+      const usage = normalizeSdkUsage(step.usage);
+      const cost = input.cost?.({ usage: step.usage });
+      const boundary = await input.manager.recordStepUsage({
+        childConversationId: input.childConversationId,
+        usage: { ...usage, ...cost && { cost } },
+        elapsedMs
+      });
+      return boundary.stop;
+    }
+  };
+}
+
+// src/agent-runtime/child-tools.ts
+function childTool(manager, fork) {
+  return defineAgentTool({
+    name: fork ? "subagent_fork" : "subagent",
+    description: fork ? "Run a child conversation seeded from the parent through one exact event sequence." : "Run a child conversation seeded from the current durable parent history.",
+    identity: {
+      serviceName: "agent-children",
+      action: fork ? "fork" : "spawn",
+      method: "POST"
+    },
+    input: z2.object({
+      parentConversationId: z2.string().min(1),
+      childInput: z2.json(),
+      budget: AgentChildBudgetSchema,
+      seedUptoSeq: z2.int().positive().optional()
+    }).strict(),
+    output: z2.object({
+      childConversationId: z2.string(),
+      state: z2.string(),
+      resultReference: z2.string().optional()
+    }),
+    transports: ["AGENT"],
+    handler: async ({ input }) => {
+      if (fork && input.seedUptoSeq === undefined) {
+        throw new TypeError("subagent_fork requires seedUptoSeq");
+      }
+      const child = await manager.spawnChild({
+        parentConversationId: input.parentConversationId,
+        childInput: input.childInput,
+        budget: input.budget,
+        ...input.seedUptoSeq !== undefined && { seedUptoSeq: input.seedUptoSeq }
+      });
+      await manager.waitChild(child.childConversationId);
+      const finished = manager.listChildren(input.parentConversationId).find((record) => record.childConversationId === child.childConversationId);
+      if (!finished)
+        throw new Error("Child record disappeared after settlement");
+      return {
+        childConversationId: finished.childConversationId,
+        state: finished.state,
+        ...finished.resultReference && { resultReference: finished.resultReference }
+      };
+    }
+  });
+}
+function createAgentChildTools(manager) {
+  return [
+    childTool(manager, false),
+    childTool(manager, true),
+    defineAgentTool({
+      name: "list_agents",
+      description: "List the durable child graph for one parent conversation.",
+      identity: { serviceName: "agent-children", action: "list", method: "GET" },
+      input: z2.object({ parentConversationId: z2.string().min(1) }).strict(),
+      output: z2.object({ children: z2.array(AgentChildRecordSchema) }),
+      transports: ["AGENT"],
+      handler: ({ input }) => ({
+        children: [...manager.listChildren(input.parentConversationId)]
+      })
+    }),
+    defineAgentTool({
+      name: "send_message",
+      description: "Send one follow-up input to an active child conversation.",
+      identity: { serviceName: "agent-children", action: "message", method: "POST" },
+      input: z2.object({
+        parentConversationId: z2.string().min(1),
+        childConversationId: z2.string().min(1),
+        input: z2.json()
+      }).strict(),
+      output: z2.object({ sent: z2.literal(true) }),
+      transports: ["AGENT"],
+      handler: async ({ input }) => {
+        await manager.sendMessage(input.parentConversationId, input.childConversationId, input.input);
+        return { sent: true };
+      }
+    }),
+    defineAgentTool({
+      name: "interrupt_agent",
+      description: "Stop one active child conversation at a durable policy boundary.",
+      identity: { serviceName: "agent-children", action: "interrupt", method: "POST" },
+      input: z2.object({
+        parentConversationId: z2.string().min(1),
+        childConversationId: z2.string().min(1)
+      }).strict(),
+      output: z2.object({ interrupted: z2.literal(true) }),
+      transports: ["AGENT"],
+      handler: async ({ input }) => {
+        await manager.interruptChild(input.parentConversationId, input.childConversationId);
+        return { interrupted: true };
+      }
+    })
+  ];
+}
 // src/agent-runtime/compaction.ts
 function groupProviderTurns(messages, evidencePolicy) {
   const turns = [];
@@ -261,24 +781,24 @@ function structuredCompaction(config) {
   };
 }
 // src/agent-runtime/deferred-tool-types.ts
-import { z } from "zod";
-var DeferredAgentToolSearchInputSchema = z.object({
-  query: z.string().min(1).describe("An exact tool name, or words describing the tool. Matched as one phrase first, then word by word."),
-  reason: z.enum(["inactive_call"]).optional()
+import { z as z3 } from "zod";
+var DeferredAgentToolSearchInputSchema = z3.object({
+  query: z3.string().min(1).describe("An exact tool name, or words describing the tool. Matched as one phrase first, then word by word."),
+  reason: z3.enum(["inactive_call"]).optional()
 });
-var DeferredAgentToolMatchSchema = z.object({
-  name: z.string(),
-  description: z.string()
+var DeferredAgentToolMatchSchema = z3.object({
+  name: z3.string(),
+  description: z3.string()
 });
-var DeferredAgentToolReceiptSchema = z.object({
-  schemaVersion: z.literal(1),
-  kind: z.literal("stitchkit.deferred-tool-selection"),
-  status: z.enum(["SELECTED", "SEARCH_REQUIRED", "NO_MATCH", "SELECTION_REFUSED"]),
-  runId: z.string(),
-  surfaceKey: z.string(),
-  selected: z.array(z.string()),
-  matches: z.array(DeferredAgentToolMatchSchema),
-  truncated: z.boolean()
+var DeferredAgentToolReceiptSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  kind: z3.literal("stitchkit.deferred-tool-selection"),
+  status: z3.enum(["SELECTED", "SEARCH_REQUIRED", "NO_MATCH", "SELECTION_REFUSED"]),
+  runId: z3.string(),
+  surfaceKey: z3.string(),
+  selected: z3.array(z3.string()),
+  matches: z3.array(DeferredAgentToolMatchSchema),
+  truncated: z3.boolean()
 }).superRefine((receipt, context) => {
   const selected = receipt.status === "SELECTED" || receipt.status === "SEARCH_REQUIRED";
   if (selected !== receipt.selected.length > 0) {
@@ -634,39 +1154,209 @@ function createDeferredAgentToolSurface(config) {
     }
   };
 }
+// src/agent-runtime/event-search.ts
+import { z as z4 } from "zod";
+var AgentEventSearchResultSchema = z4.object({
+  conversationId: z4.string().min(1),
+  seq: z4.int().positive(),
+  occurredAt: z4.string(),
+  snippet: z4.string()
+}).strict();
+var SearchRowSchema = z4.object({
+  conversation_id: z4.string(),
+  event_seq: z4.int().positive(),
+  occurred_at: z4.string(),
+  snippet: z4.string()
+});
+function literalFtsQuery(query) {
+  return `"${query.replaceAll('"', '""')}"`;
+}
+function createSqliteAgentEventSearch(input) {
+  return async (request) => {
+    if (request.query.trim().length === 0)
+      throw new TypeError("Event search query must not be empty");
+    const limit = Math.min(request.limit ?? 20, 200);
+    const target = request.conversationId ?? (input.authorizeConversation ? undefined : request.requestingConversationId);
+    const values = [literalFtsQuery(request.query)];
+    const targetClause = target ? "AND f.conversation_id = ?" : "";
+    if (target)
+      values.push(target);
+    const sinceClause = request.since ? "AND f.occurred_at >= ?" : "";
+    if (request.since)
+      values.push(z4.iso.datetime({ offset: true }).parse(request.since));
+    const page = limit * 4;
+    const candidatesFrom = (offset2) => input.database.prepare(`
+          SELECT f.conversation_id, f.event_seq, f.occurred_at,
+            snippet(stitchkit_agent_runtime_events_fts, 3, '[', ']', ' … ', 24) AS snippet
+          FROM stitchkit_agent_runtime_events_fts AS f
+          WHERE stitchkit_agent_runtime_events_fts MATCH ? ${targetClause} ${sinceClause}
+          ORDER BY bm25(stitchkit_agent_runtime_events_fts), f.occurred_at DESC, f.rowid
+          LIMIT ? OFFSET ?
+        `).all(...values, page, offset2).map((row) => SearchRowSchema.parse(row));
+    const authorization = new Map;
+    const results = [];
+    let offset = 0;
+    let candidates = candidatesFrom(offset);
+    while (candidates.length > 0 && results.length < limit) {
+      for (const row of candidates) {
+        if (row.conversation_id !== request.requestingConversationId) {
+          let allowed = authorization.get(row.conversation_id);
+          if (allowed === undefined) {
+            allowed = input.authorizeConversation ? await input.authorizeConversation({
+              requestingConversationId: request.requestingConversationId,
+              targetConversationId: row.conversation_id
+            }) : false;
+            authorization.set(row.conversation_id, allowed);
+          }
+          if (!allowed)
+            continue;
+        }
+        results.push(AgentEventSearchResultSchema.parse({
+          conversationId: row.conversation_id,
+          seq: row.event_seq,
+          occurredAt: row.occurred_at,
+          snippet: row.snippet
+        }));
+        if (results.length === limit)
+          break;
+      }
+      offset += page;
+      candidates = results.length < limit ? candidatesFrom(offset) : [];
+    }
+    return results;
+  };
+}
+// src/agent-runtime/event-search-tools.ts
+import { z as z5 } from "zod";
+function createAgentEventSearchTools(input) {
+  const EventAddressSchema = z5.object({ conversationId: z5.string(), seq: z5.int().positive() }).strict();
+  const EventOutputSchema = z5.object({
+    conversationId: z5.string(),
+    seq: z5.int().positive(),
+    kind: z5.string(),
+    occurredAt: z5.string(),
+    payload: z5.json()
+  }).strict();
+  const readExact = async (address) => {
+    if (address.conversationId !== input.conversationId) {
+      const allowed = await input.authorizeConversation?.({
+        requestingConversationId: input.conversationId,
+        targetConversationId: address.conversationId
+      });
+      if (!allowed)
+        throw new TypeError("Event address is outside the authorized conversation");
+    }
+    const page = await input.store.readEvents({
+      conversationId: address.conversationId,
+      fromSeq: address.seq,
+      toSeq: address.seq,
+      limit: 1
+    });
+    const event = page.items[0];
+    if (!event || event.seq !== address.seq)
+      throw new TypeError("Unknown event address");
+    return {
+      conversationId: event.conversationId,
+      seq: event.seq,
+      kind: event.kind,
+      occurredAt: event.occurredAt,
+      payload: event.payload
+    };
+  };
+  return [
+    defineAgentTool({
+      name: "session_search",
+      description: "Search authorized durable conversation events and return exact addresses.",
+      identity: { serviceName: "agent-events", action: "search", method: "POST" },
+      input: z5.object({
+        query: z5.string().min(1),
+        conversationId: z5.string().min(1).optional(),
+        since: z5.iso.datetime({ offset: true }).optional(),
+        limit: z5.int().positive().max(200).optional()
+      }).strict(),
+      output: z5.object({ results: z5.array(AgentEventSearchResultSchema) }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => ({
+        results: [
+          ...await input.search({
+            requestingConversationId: input.conversationId,
+            ...request
+          })
+        ]
+      })
+    }),
+    defineAgentTool({
+      name: "session_trace",
+      description: "Read a bounded contiguous slice of this conversation event trace.",
+      identity: { serviceName: "agent-events", action: "trace", method: "GET" },
+      input: z5.object({
+        fromSeq: z5.int().positive().optional(),
+        toSeq: z5.int().positive().optional(),
+        limit: z5.int().positive().max(1000).default(100)
+      }).strict(),
+      output: z5.object({ events: z5.array(EventOutputSchema), nextSeq: z5.number().optional() }),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const page = await input.store.readEvents({
+          conversationId: input.conversationId,
+          ...request
+        });
+        return {
+          events: page.items.map((event) => ({
+            conversationId: event.conversationId,
+            seq: event.seq,
+            kind: event.kind,
+            occurredAt: event.occurredAt,
+            payload: event.payload
+          })),
+          ...page.nextSeq !== undefined && { nextSeq: page.nextSeq }
+        };
+      }
+    }),
+    defineAgentTool({
+      name: "session_event",
+      description: "Read one durable event by exact conversation and sequence address.",
+      identity: { serviceName: "agent-events", action: "read", method: "GET" },
+      input: EventAddressSchema,
+      output: EventOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input: request }) => readExact(request)
+    })
+  ];
+}
 // src/agent-runtime/observability.ts
-import { z as z2 } from "zod";
-var AgentRunEventBaseSchema = z2.object({
-  schemaVersion: z2.literal(1),
+import { z as z6 } from "zod";
+var AgentRunEventBaseSchema = z6.object({
+  schemaVersion: z6.literal(1),
   eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
-  traceId: z2.string().min(1),
-  spanId: z2.string().min(1),
-  parentSpanId: z2.string().min(1).optional(),
+  traceId: z6.string().min(1),
+  spanId: z6.string().min(1),
+  parentSpanId: z6.string().min(1).optional(),
   state: AgentRunStateSchema,
-  modelId: z2.string().min(1).optional(),
-  durationMs: z2.number().nonnegative().optional(),
+  modelId: z6.string().min(1).optional(),
+  durationMs: z6.number().nonnegative().optional(),
   emittedAt: AgentTimestampSchema
 });
 var AgentRunStartedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z2.literal("run-started"),
-  queueWaitMs: z2.number().nonnegative().optional()
+  type: z6.literal("run-started"),
+  queueWaitMs: z6.number().nonnegative().optional()
 });
 var AgentStepFinishedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z2.literal("step-finished"),
-  step: z2.int().nonnegative(),
-  ttftMs: z2.number().nonnegative().optional(),
+  type: z6.literal("step-finished"),
+  step: z6.int().nonnegative(),
+  ttftMs: z6.number().nonnegative().optional(),
   usage: AgentUsageSchema
 });
 var AgentRunTerminalEventSchema = AgentRunEventBaseSchema.extend({
-  type: z2.literal("run-terminal"),
+  type: z6.literal("run-terminal"),
   terminalReason: AgentTerminalReasonSchema,
-  ttftMs: z2.number().nonnegative().optional(),
-  internalCause: z2.unknown().optional(),
+  ttftMs: z6.number().nonnegative().optional(),
+  internalCause: z6.unknown().optional(),
   usage: AgentUsageSchema
 });
-var AgentRunEventSchema = z2.discriminatedUnion("type", [
+var AgentRunEventSchema = z6.discriminatedUnion("type", [
   AgentRunStartedEventSchema,
   AgentStepFinishedEventSchema,
   AgentRunTerminalEventSchema
@@ -714,6 +1404,247 @@ function createAgentObservability(config) {
     close: (bound) => manager.close(bound)
   };
 }
+// src/agent-runtime/projections.ts
+import { z as z7 } from "zod";
+function defineAgentProjection(definition) {
+  if (definition.name.length === 0)
+    throw new TypeError("Projection name must not be empty");
+  if (!Number.isInteger(definition.version) || definition.version < 1) {
+    throw new TypeError("Projection version must be a positive integer");
+  }
+  definition.schema.parse(definition.initial());
+  return definition;
+}
+function createAgentProjectionRegistry(definitions) {
+  const registry = new Map;
+  for (const definition of definitions) {
+    const previous = registry.get(definition.name);
+    if (previous)
+      throw new TypeError(`Duplicate agent projection: ${definition.name}`);
+    registry.set(definition.name, definition);
+  }
+  return registry;
+}
+var ProjectionRowSchema = z7.object({
+  conversation_id: z7.string().optional(),
+  version: z7.int().positive(),
+  upto_seq: z7.int().nonnegative(),
+  payload: z7.string(),
+  updated_at: z7.string()
+});
+function projectionPayload(value) {
+  return JSON.parse(value);
+}
+function createSqliteAgentProjectionStore(input) {
+  const database = input.sqlite.database;
+  const store = input.sqlite.store;
+  const load = (conversationId, definition) => {
+    const raw = database.prepare(`
+        SELECT version, upto_seq, payload, updated_at
+        FROM stitchkit_agent_runtime_projections
+        WHERE conversation_id = ? AND name = ?
+      `).get(conversationId, definition.name);
+    if (raw === null || raw === undefined)
+      return;
+    const row = ProjectionRowSchema.parse(raw);
+    if (row.version !== definition.version)
+      return;
+    return {
+      name: definition.name,
+      version: row.version,
+      uptoSeq: row.upto_seq,
+      updatedAt: row.updated_at,
+      value: definition.schema.parse(projectionPayload(row.payload))
+    };
+  };
+  const advance = async (conversationId, definition) => {
+    const current = load(conversationId, definition);
+    let value = current?.value ?? definition.initial();
+    let uptoSeq = current?.uptoSeq ?? 0;
+    let cursor = uptoSeq + 1;
+    let updatedAt = current?.updatedAt ?? new Date(0).toISOString();
+    for (;; ) {
+      const page = await store.readEvents({
+        conversationId,
+        fromSeq: cursor,
+        limit: 1000
+      });
+      for (const event of page.items) {
+        value = definition.schema.parse(definition.fold(value, event));
+        uptoSeq = event.seq;
+        updatedAt = event.occurredAt;
+      }
+      if (page.nextSeq === undefined)
+        break;
+      cursor = page.nextSeq;
+    }
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_projections
+            (conversation_id, name, version, upto_seq, payload, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT (conversation_id, name) DO UPDATE SET
+            version = excluded.version,
+            upto_seq = excluded.upto_seq,
+            payload = excluded.payload,
+            updated_at = excluded.updated_at
+        `).run(conversationId, definition.name, definition.version, uptoSeq, JSON.stringify(value), updatedAt);
+    });
+    return { name: definition.name, version: definition.version, uptoSeq, updatedAt, value };
+  };
+  const list = (definition) => database.prepare(`
+        SELECT conversation_id, version, upto_seq, payload, updated_at
+        FROM stitchkit_agent_runtime_projections
+        WHERE name = ? AND version = ? ORDER BY updated_at DESC, conversation_id
+      `).all(definition.name, definition.version).map((raw) => {
+    const row = ProjectionRowSchema.parse(raw);
+    if (!row.conversation_id)
+      throw new TypeError("Projection list row has no conversation id");
+    return {
+      conversationId: row.conversation_id,
+      projection: {
+        name: definition.name,
+        version: row.version,
+        uptoSeq: row.upto_seq,
+        updatedAt: row.updated_at,
+        value: definition.schema.parse(projectionPayload(row.payload))
+      }
+    };
+  });
+  return { load, advance, list };
+}
+var ConversationCardSchema = z7.object({
+  eventCount: z7.int().nonnegative(),
+  lastKind: z7.string().optional(),
+  lastOccurredAt: z7.string().optional()
+});
+var agentConversationCardProjection = defineAgentProjection({
+  name: "conversation-card",
+  version: 1,
+  schema: ConversationCardSchema,
+  initial: () => ({ eventCount: 0 }),
+  fold: (state, event) => ({
+    eventCount: state.eventCount + 1,
+    lastKind: event.kind,
+    lastOccurredAt: event.occurredAt
+  })
+});
+var StateSlotsProjectionSchema = z7.record(z7.string(), z7.json());
+var agentStateSlotsProjection = defineAgentProjection({
+  name: "state-slots",
+  version: 1,
+  schema: StateSlotsProjectionSchema,
+  initial: () => ({}),
+  fold: (state, event) => {
+    if (event.kind !== "state/set")
+      return state;
+    const payload = z7.object({ name: z7.string().min(1), value: z7.json() }).passthrough().parse(event.payload);
+    return { ...state, [payload.name]: payload.value };
+  }
+});
+var ScheduleSummarySchema = z7.object({
+  scheduled: z7.int().nonnegative(),
+  fired: z7.int().nonnegative(),
+  cancelled: z7.int().nonnegative(),
+  late: z7.int().nonnegative()
+});
+var agentScheduleSummaryProjection = defineAgentProjection({
+  name: "schedule-summary",
+  version: 1,
+  schema: ScheduleSummarySchema,
+  initial: () => ({ scheduled: 0, fired: 0, cancelled: 0, late: 0 }),
+  fold: (state, event) => {
+    if (event.kind === "schedule/set")
+      return { ...state, scheduled: state.scheduled + 1 };
+    if (event.kind === "schedule/fired")
+      return { ...state, fired: state.fired + 1 };
+    if (event.kind === "schedule/cancelled")
+      return { ...state, cancelled: state.cancelled + 1 };
+    if (event.kind === "schedule/late")
+      return { ...state, late: state.late + 1 };
+    return state;
+  }
+});
+var RuntimeSummarySchema = z7.object({
+  eventCount: z7.int().nonnegative(),
+  lastSeq: z7.int().nonnegative(),
+  lastKind: z7.string().optional(),
+  lastOccurredAt: z7.string().optional(),
+  lastModelId: z7.string().optional()
+}).strict();
+var agentSummaryProjection = defineAgentProjection({
+  name: "summary",
+  version: 1,
+  schema: RuntimeSummarySchema,
+  initial: () => ({ eventCount: 0, lastSeq: 0 }),
+  fold: (state, event) => {
+    const request = event.kind === "provider/request" ? z7.object({ modelId: z7.string().optional() }).passthrough().safeParse(event.payload) : undefined;
+    return {
+      eventCount: state.eventCount + 1,
+      lastSeq: event.seq,
+      lastKind: event.kind,
+      lastOccurredAt: event.occurredAt,
+      ...request?.success && request.data.modelId ? { lastModelId: request.data.modelId } : state.lastModelId ? { lastModelId: state.lastModelId } : {}
+    };
+  }
+});
+var RuntimeUsageSchema = z7.object({
+  inputTokens: z7.number().nonnegative(),
+  outputTokens: z7.number().nonnegative(),
+  cost: z7.number().nonnegative(),
+  sources: z7.array(z7.string())
+}).strict();
+var agentUsageProjection = defineAgentProjection({
+  name: "usage",
+  version: 1,
+  schema: RuntimeUsageSchema,
+  initial: () => ({ inputTokens: 0, outputTokens: 0, cost: 0, sources: [] }),
+  fold: (state, event) => {
+    const parsed = z7.object({
+      inputTokens: z7.number().nonnegative().optional(),
+      outputTokens: z7.number().nonnegative().optional(),
+      cost: z7.number().nonnegative().optional(),
+      source: z7.string().min(1).optional()
+    }).passthrough().safeParse(event.payload);
+    if (!parsed.success)
+      return state;
+    const source = parsed.data.source;
+    return {
+      inputTokens: state.inputTokens + (parsed.data.inputTokens ?? 0),
+      outputTokens: state.outputTokens + (parsed.data.outputTokens ?? 0),
+      cost: state.cost + (parsed.data.cost ?? 0),
+      sources: source && !state.sources.includes(source) ? [...state.sources, source] : state.sources
+    };
+  }
+});
+var RuntimeOutlineSchema = z7.object({
+  requests: z7.array(z7.object({
+    seq: z7.int().positive(),
+    occurredAt: z7.string(),
+    runId: z7.string().optional()
+  }).strict())
+}).strict();
+var agentOutlineProjection = defineAgentProjection({
+  name: "outline",
+  version: 1,
+  schema: RuntimeOutlineSchema,
+  initial: () => ({ requests: [] }),
+  fold: (state, event) => {
+    if (event.kind !== "provider/request")
+      return state;
+    const payload = z7.object({ runId: z7.string().optional() }).passthrough().parse(event.payload);
+    return {
+      requests: [
+        ...state.requests,
+        {
+          seq: event.seq,
+          occurredAt: event.occurredAt,
+          ...payload.runId && { runId: payload.runId }
+        }
+      ]
+    };
+  }
+});
 // src/agent-runtime/protocol.ts
 function hasAgentTerminalOutput(input) {
   for (const part of input.message.parts) {
@@ -741,84 +1672,543 @@ function defineAgentProtocol(config) {
     }
   };
 }
-// src/agent-runtime/provider-failure.ts
-var BY_STATUS = {
-  402: "insufficient-credits",
-  404: "model-unavailable",
-  408: "timeout",
-  413: "context-overflow",
-  429: "rate-limited"
-};
-var BY_MESSAGE = [
-  [/insufficient|not enough credit|payment required|quota exceeded/i, "insufficient-credits"],
-  [/rate.?limit|too many requests|slow down/i, "rate-limited"],
-  [
-    /no endpoints found|model not found|unknown model|no allowed providers/i,
-    "model-unavailable"
-  ],
-  [/context length|maximum context|too many tokens|prompt is too long/i, "context-overflow"],
-  [/timed? ?out|deadline exceeded|etimedout/i, "timeout"],
-  [/abort|cancell?ed/i, "cancelled"]
-];
-var RETRYABLE = new Set([
-  "rate-limited",
-  "timeout",
-  "insufficient-credits"
-]);
-function statusOf(value) {
-  if (!isRecord(value))
+// src/agent-runtime/schedule-tools.ts
+import { z as z8 } from "zod";
+var ScheduledOutputSchema = z8.object({ scheduleId: z8.string(), nextAt: z8.string() }).strict();
+var ConversationInputSchema = z8.object({ conversationId: z8.string().min(1) }).strict();
+function createAgentScheduleTools(service) {
+  const schedule = async (request) => {
+    const result = await service.scheduleInput(request);
+    return { scheduleId: result.id, nextAt: result.nextAt };
+  };
+  return [
+    defineAgentTool({
+      name: "schedule_after",
+      description: "Schedule durable input after a relative delay.",
+      identity: { serviceName: "agent-schedules", action: "after", method: "POST" },
+      input: z8.object({
+        conversationId: z8.string().min(1),
+        input: z8.json(),
+        afterMs: z8.int().positive()
+      }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_at",
+      description: "Schedule durable input at an absolute timestamp with an explicit offset.",
+      identity: { serviceName: "agent-schedules", action: "at", method: "POST" },
+      input: z8.object({ conversationId: z8.string().min(1), input: z8.json(), at: z8.string().min(1) }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_every",
+      description: "Schedule recurring durable input in an explicit conversation timezone.",
+      identity: { serviceName: "agent-schedules", action: "every", method: "POST" },
+      input: z8.object({
+        conversationId: z8.string().min(1),
+        input: z8.json(),
+        everyMs: z8.int().positive(),
+        timeZone: z8.string().min(1)
+      }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_list",
+      description: "List durable schedules for one conversation.",
+      identity: { serviceName: "agent-schedules", action: "list", method: "GET" },
+      input: ConversationInputSchema,
+      output: z8.object({ schedules: z8.array(z8.json()) }).strict(),
+      transports: ["AGENT"],
+      handler: ({ input }) => ({
+        schedules: [...service.listSchedules(input.conversationId)]
+      })
+    }),
+    defineAgentTool({
+      name: "schedule_cancel",
+      description: "Cancel one durable deferred-input schedule.",
+      identity: { serviceName: "agent-schedules", action: "cancel", method: "POST" },
+      input: z8.object({ conversationId: z8.string().min(1), scheduleId: z8.string().min(1) }).strict(),
+      output: z8.object({ cancelled: z8.boolean() }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input }) => ({
+        cancelled: await service.cancelSchedule(input.conversationId, input.scheduleId)
+      })
+    })
+  ];
+}
+// src/agent-runtime/schedules.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { z as z9 } from "zod";
+var AgentScheduleSchema = z9.object({
+  id: z9.string().min(1),
+  conversationId: z9.string().min(1),
+  kind: z9.enum(["at", "after", "every"]),
+  nextAt: z9.iso.datetime({ offset: true }),
+  intervalMs: z9.int().positive().optional(),
+  timeZone: z9.string().min(1).optional(),
+  input: z9.json(),
+  state: z9.enum(["scheduled", "cancelled", "completed"]),
+  occurrence: z9.int().nonnegative(),
+  createdAt: z9.iso.datetime({ offset: true }),
+  updatedAt: z9.iso.datetime({ offset: true })
+}).strict();
+var ScheduleRowSchema = z9.object({
+  id: z9.string(),
+  conversation_id: z9.string(),
+  kind: z9.enum(["at", "after", "every"]),
+  next_at: z9.string(),
+  interval_ms: z9.number().int().positive().nullable(),
+  time_zone: z9.string().nullable(),
+  input_payload: z9.string(),
+  state: z9.enum(["scheduled", "cancelled", "completed"]),
+  occurrence: z9.int().nonnegative(),
+  created_at: z9.string(),
+  updated_at: z9.string()
+});
+function parseSchedule(raw) {
+  const row = ScheduleRowSchema.parse(raw);
+  return AgentScheduleSchema.parse({
+    id: row.id,
+    conversationId: row.conversation_id,
+    kind: row.kind,
+    nextAt: row.next_at,
+    ...row.interval_ms !== null && { intervalMs: row.interval_ms },
+    ...row.time_zone !== null && { timeZone: row.time_zone },
+    input: JSON.parse(row.input_payload),
+    state: row.state,
+    occurrence: row.occurrence,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  });
+}
+function createAgentScheduleService(input) {
+  const onError = input.onError ?? ((error) => {
+    console.error("[stitchkit] agent schedule tick failed", error);
+  });
+  const now = input.now ?? (() => new Date);
+  const database = input.sqlite.database;
+  const setTimer = input.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = input.clearTimer ?? clearTimeout;
+  let timer;
+  let closed = false;
+  const listSchedules = (conversationId) => database.prepare(`
+        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
+          input_payload, state, occurrence, created_at, updated_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE conversation_id = ? ORDER BY created_at, id
+      `).all(conversationId).map(parseSchedule);
+  const arm = () => {
+    if (timer)
+      clearTimer(timer);
+    if (closed)
+      return;
+    try {
+      armNext();
+    } catch (error) {
+      onError(error);
+    }
+  };
+  const armNext = () => {
+    const raw = database.prepare(`
+        SELECT MAX(next_at, COALESCE(claim_until, next_at)) AS due_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE state = 'scheduled' ORDER BY due_at, id LIMIT 1
+      `).get();
+    if (raw === null || raw === undefined || typeof raw.due_at !== "string")
+      return;
+    const delay = Math.max(0, new Date(raw.due_at).getTime() - now().getTime());
+    timer = setTimer(() => void tick(), Math.min(delay, 2147483647));
+  };
+  const owner = randomUUID2();
+  const CLAIM_MS = 60000;
+  let ticking;
+  const claim = (id, until, at) => input.sqlite.transaction(async (scope) => scope.database.prepare(`
+            UPDATE stitchkit_agent_runtime_schedules
+            SET claim_owner = ?, claim_until = ?, updated_at = ?
+            WHERE id = ? AND state = 'scheduled' AND (claim_until IS NULL OR claim_until < ?)
+          `).run(owner, until, at, id, at).changes === 1);
+  const runTick = async () => {
+    if (closed)
+      return;
+    const observedAt = now();
+    const due = database.prepare(`
+        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
+          input_payload, state, occurrence, created_at, updated_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE state = 'scheduled' AND next_at <= ? ORDER BY next_at, id
+      `).all(observedAt.toISOString()).map(parseSchedule);
+    for (const schedule of due) {
+      const at = observedAt.toISOString();
+      if (!await claim(schedule.id, new Date(observedAt.getTime() + CLAIM_MS).toISOString(), at)) {
+        continue;
+      }
+      const occurrence = schedule.occurrence + 1;
+      const lateByMs = Math.max(0, observedAt.getTime() - new Date(schedule.nextAt).getTime());
+      try {
+        await input.dispatch({
+          conversationId: schedule.conversationId,
+          idempotencyKey: `schedule:${schedule.id}:${occurrence}`,
+          input: schedule.input,
+          schedule: { id: schedule.id, occurrence, lateByMs }
+        });
+      } catch (error) {
+        await input.sqlite.transaction(async (scope) => {
+          scope.database.prepare(`
+              UPDATE stitchkit_agent_runtime_schedules
+              SET claim_owner = NULL, claim_until = NULL, updated_at = ?
+              WHERE id = ? AND claim_owner = ?
+            `).run(at, schedule.id, owner);
+          await scope.appendEvent({
+            conversationId: schedule.conversationId,
+            kind: "schedule/failed",
+            occurredAt: at,
+            payload: {
+              id: schedule.id,
+              occurrence,
+              message: error instanceof Error ? error.message : String(error)
+            }
+          });
+        });
+        continue;
+      }
+      let nextAt = schedule.nextAt;
+      if (schedule.kind === "every" && schedule.intervalMs) {
+        let next = new Date(schedule.nextAt).getTime() + schedule.intervalMs;
+        while (next <= observedAt.getTime())
+          next += schedule.intervalMs;
+        nextAt = new Date(next).toISOString();
+      }
+      const state = schedule.kind === "every" ? "scheduled" : "completed";
+      await input.sqlite.transaction(async (scope) => {
+        const settled = scope.database.prepare(`
+              UPDATE stitchkit_agent_runtime_schedules
+              SET state = ?, occurrence = ?, next_at = ?, updated_at = ?,
+                claim_owner = NULL, claim_until = NULL
+              WHERE id = ? AND state = 'scheduled' AND claim_owner = ?
+            `).run(state, occurrence, nextAt, at, schedule.id, owner).changes === 1;
+        if (lateByMs > 0) {
+          await scope.appendEvent({
+            conversationId: schedule.conversationId,
+            kind: "schedule/late",
+            occurredAt: at,
+            payload: { id: schedule.id, occurrence, lateByMs }
+          });
+        }
+        await scope.appendEvent({
+          conversationId: schedule.conversationId,
+          kind: "schedule/fired",
+          occurredAt: at,
+          payload: {
+            id: schedule.id,
+            occurrence,
+            lateByMs,
+            nextAt,
+            state: settled ? state : "cancelled"
+          }
+        });
+      });
+    }
+  };
+  const tick = () => {
+    if (ticking)
+      return ticking;
+    ticking = runTick().catch(onError).finally(() => {
+      ticking = undefined;
+      arm();
+    });
+    return ticking;
+  };
+  const scheduleInput = async (request) => {
+    const modes = [
+      request.at !== undefined,
+      request.afterMs !== undefined,
+      request.everyMs !== undefined
+    ];
+    if (modes.filter(Boolean).length !== 1)
+      throw new TypeError("Declare exactly one schedule mode");
+    if (request.everyMs !== undefined && !request.timeZone) {
+      throw new TypeError("Repeating schedules require an explicit timeZone");
+    }
+    if (request.timeZone) {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: request.timeZone }).format(new Date(0));
+      } catch {
+        throw new TypeError(`Unknown schedule timeZone: ${request.timeZone}`);
+      }
+    }
+    const observedAt = now();
+    const kind = request.at !== undefined ? "at" : request.afterMs !== undefined ? "after" : "every";
+    const intervalMs = request.everyMs;
+    const delay = request.afterMs ?? request.everyMs;
+    if (delay !== undefined && (!Number.isSafeInteger(delay) || delay < 1)) {
+      throw new TypeError("Schedule delay must be a positive safe integer");
+    }
+    const nextAt = request.at ? new Date(z9.iso.datetime({ offset: true }).parse(request.at)).toISOString() : new Date(observedAt.getTime() + (delay ?? 0)).toISOString();
+    const schedule = AgentScheduleSchema.parse({
+      id: randomUUID2(),
+      conversationId: request.conversationId,
+      kind,
+      nextAt,
+      ...intervalMs !== undefined && { intervalMs },
+      ...request.timeZone && { timeZone: request.timeZone },
+      input: z9.json().parse(request.input),
+      state: "scheduled",
+      occurrence: 0,
+      createdAt: observedAt.toISOString(),
+      updatedAt: observedAt.toISOString()
+    });
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_schedules (
+            id, conversation_id, kind, next_at, interval_ms, time_zone,
+            input_payload, state, occurrence, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, 'scheduled', 0, ?, ?)
+        `).run(schedule.id, schedule.conversationId, schedule.kind, schedule.nextAt, schedule.intervalMs ?? null, schedule.timeZone ?? null, JSON.stringify(schedule.input), schedule.createdAt, schedule.updatedAt);
+      await scope.appendEvent({
+        conversationId: schedule.conversationId,
+        kind: "schedule/set",
+        occurredAt: schedule.createdAt,
+        payload: { id: schedule.id, kind: schedule.kind, nextAt: schedule.nextAt }
+      });
+    });
+    arm();
+    return schedule;
+  };
+  const cancelSchedule = async (conversationId, id) => {
+    const observedAt = now().toISOString();
+    const changed = await input.sqlite.transaction(async (scope) => {
+      const count = scope.database.prepare(`
+          UPDATE stitchkit_agent_runtime_schedules SET state = 'cancelled', updated_at = ?
+          WHERE id = ? AND conversation_id = ? AND state = 'scheduled'
+        `).run(observedAt, id, conversationId).changes;
+      if (count > 0) {
+        await scope.appendEvent({
+          conversationId,
+          kind: "schedule/cancelled",
+          occurredAt: observedAt,
+          payload: { id }
+        });
+      }
+      return count;
+    });
+    if (changed > 0)
+      arm();
+    return changed > 0;
+  };
+  return {
+    scheduleInput,
+    cancelSchedule,
+    listSchedules,
+    tick,
+    start: arm,
+    close() {
+      closed = true;
+      if (timer)
+        clearTimer(timer);
+    }
+  };
+}
+// src/agent-runtime/spill.ts
+import { createHash, randomUUID as randomUUID3 } from "node:crypto";
+import { z as z10 } from "zod";
+var SpillRowSchema = z10.object({
+  payload: z10.instanceof(Uint8Array),
+  bytes: z10.int().nonnegative(),
+  authorization_payload: z10.string().nullable()
+});
+var SpillMetadataRowSchema = z10.object({
+  reference_id: z10.string(),
+  bytes: z10.int().nonnegative(),
+  created_at: z10.string()
+});
+function decodeAuthorization(value) {
+  if (value === null)
     return;
-  for (const key of ["statusCode", "status", "code"]) {
-    const candidate = value[key];
-    if (typeof candidate === "number" && candidate >= 400 && candidate < 600)
-      return candidate;
-  }
-  const nested = value.cause ?? value.response ?? value.error;
-  return nested === value ? undefined : statusOf(nested);
+  return JSON.parse(value);
 }
-function classifyProviderFailure(error) {
-  const status = statusOf(error);
-  const byStatus = status === undefined ? undefined : BY_STATUS[status];
-  if (byStatus) {
+function createSqliteAgentSpillStore(input) {
+  const now = input.now ?? (() => new Date);
+  const database = input.sqlite.database;
+  const authorization = (reference) => {
+    const raw = database.prepare(`
+        SELECT payload, bytes, authorization_payload
+        FROM stitchkit_agent_runtime_spills
+        WHERE reference_id = ? AND conversation_id = ?
+      `).get(reference, input.conversationId);
+    if (raw === null || raw === undefined)
+      throw new TypeError("Unknown spill reference");
+    return decodeAuthorization(SpillRowSchema.parse(raw).authorization_payload);
+  };
+  const write = async (request) => {
+    const reference = randomUUID3();
+    const createdAt = now();
+    const expiresAt = input.retentionMs ? new Date(createdAt.getTime() + input.retentionMs).toISOString() : null;
+    const sha256 = createHash("sha256").update(request.data).digest("hex");
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_spills (
+            reference_id, conversation_id, run_id, tool_call_id, media_type,
+            bytes, sha256, created_at, expires_at, payload, authorization_payload
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(reference, input.conversationId, input.runId ?? null, input.toolCallId ?? null, request.mediaType, request.data.byteLength, sha256, createdAt.toISOString(), expiresAt, request.data, request.authorization ? JSON.stringify(request.authorization) : null);
+      await scope.appendEvent({
+        conversationId: input.conversationId,
+        kind: "spill/created",
+        occurredAt: createdAt.toISOString(),
+        payload: { reference, bytes: request.data.byteLength, sha256 }
+      });
+    });
+    return { reference };
+  };
+  const read = async (request) => {
+    const raw = database.prepare(`
+        SELECT payload, bytes, authorization_payload
+        FROM stitchkit_agent_runtime_spills
+        WHERE reference_id = ? AND conversation_id = ?
+      `).get(request.reference, input.conversationId);
+    if (raw === null || raw === undefined)
+      throw new TypeError("Unknown spill reference");
+    const row = SpillRowSchema.parse(raw);
     return {
-      reason: byStatus,
-      status,
-      retryable: RETRYABLE.has(byStatus),
-      evidence: "status"
+      data: row.payload.slice(request.offset, request.offset + request.maxBytes),
+      totalBytes: row.bytes,
+      ...decodeAuthorization(row.authorization_payload) && {
+        authorization: decodeAuthorization(row.authorization_payload)
+      }
     };
-  }
-  const message = messageOf(error);
-  for (const [pattern, reason] of BY_MESSAGE) {
-    if (pattern.test(message)) {
-      return {
-        reason,
-        ...status !== undefined && { status },
-        retryable: RETRYABLE.has(reason),
-        evidence: "message"
-      };
+  };
+  const search = (request) => {
+    const raw = database.prepare(`
+        SELECT payload, bytes, authorization_payload
+        FROM stitchkit_agent_runtime_spills
+        WHERE reference_id = ? AND conversation_id = ?
+      `).get(request.reference, input.conversationId);
+    if (raw === null || raw === undefined)
+      throw new TypeError("Unknown spill reference");
+    const row = SpillRowSchema.parse(raw);
+    const matches = [];
+    new TextDecoder("utf-8", { fatal: true }).decode(row.payload).split(`
+`).forEach((text, index) => {
+      if (matches.length < request.maxMatches && text.includes(request.query)) {
+        matches.push({ line: index + 1, text });
+      }
+    });
+    return matches;
+  };
+  const cleanup = async () => {
+    const expired = database.prepare(`
+        SELECT reference_id, bytes, created_at
+        FROM stitchkit_agent_runtime_spills
+        WHERE conversation_id = ? AND expires_at IS NOT NULL AND expires_at <= ?
+        ORDER BY created_at, reference_id
+      `).all(input.conversationId, now().toISOString()).map((row) => SpillMetadataRowSchema.parse(row));
+    let bytes = 0;
+    for (const spill of expired) {
+      await input.sqlite.transaction(async (scope) => {
+        scope.database.prepare("DELETE FROM stitchkit_agent_runtime_spills WHERE reference_id = ?").run(spill.reference_id);
+        await scope.appendEvent({
+          conversationId: input.conversationId,
+          kind: "spill/deleted",
+          payload: { reference: spill.reference_id, bytes: spill.bytes }
+        });
+      });
+      bytes += spill.bytes;
     }
-  }
-  return {
-    reason: "unknown",
-    ...status !== undefined && { status },
-    retryable: false,
-    evidence: "none"
-  };
-}
-function isToolResultFailure(output) {
-  const parsed = typeof output === "string" ? parseJson(output) : output;
-  if (!isRecord(parsed))
-    return false;
-  if ("error" in parsed)
-    return true;
-  return isRecord(parsed.value) && "error" in parsed.value;
-}
-function parseJson(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return;
-  }
+    return { deleted: expired.length, bytes };
+  };
+  return { authorization, write, read, search, cleanup };
+}
+// src/agent-runtime/state-tools.ts
+import { z as z11 } from "zod";
+var GoalSchema = z11.object({
+  objective: z11.string().min(1),
+  status: z11.enum(["active", "complete", "blocked"])
+}).strict();
+var TodoItemSchema = z11.object({
+  step: z11.string().min(1),
+  status: z11.enum(["pending", "in_progress", "completed"])
+}).strict();
+function createAgentStateTools(input) {
+  const writeGoal = async (value) => {
+    const stored = await input.state.set({
+      conversationId: input.conversationId,
+      name: "goal",
+      value,
+      actor: "agent"
+    });
+    return GoalSchema.parse(stored.value);
+  };
+  return [
+    defineAgentTool({
+      name: "create_goal",
+      description: "Create the durable objective for this conversation.",
+      identity: { serviceName: "agent-state", action: "create-goal", method: "POST" },
+      input: z11.object({ objective: z11.string().min(1) }).strict(),
+      output: GoalSchema,
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        if (await input.state.get(input.conversationId, "goal")) {
+          throw new TypeError("A durable goal already exists for this conversation");
+        }
+        return writeGoal({ objective: request.objective, status: "active" });
+      }
+    }),
+    defineAgentTool({
+      name: "update_goal",
+      description: "Update the durable objective or lifecycle status.",
+      identity: { serviceName: "agent-state", action: "update-goal", method: "POST" },
+      input: z11.object({
+        objective: z11.string().min(1).optional(),
+        status: z11.enum(["active", "complete", "blocked"]).optional()
+      }).strict().refine((request) => request.objective !== undefined || request.status !== undefined, {
+        message: "At least one goal field must be supplied"
+      }),
+      output: GoalSchema,
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const current = await input.state.get(input.conversationId, "goal");
+        if (!current)
+          throw new TypeError("No durable goal exists for this conversation");
+        const goal = GoalSchema.parse(current.value);
+        return writeGoal({ ...goal, ...request });
+      }
+    }),
+    defineAgentTool({
+      name: "get_goal",
+      description: "Read the durable objective for this conversation.",
+      identity: { serviceName: "agent-state", action: "get-goal", method: "GET" },
+      input: z11.object({}).strict(),
+      output: z11.object({ goal: GoalSchema.optional() }).strict(),
+      transports: ["AGENT"],
+      handler: async () => {
+        const current = await input.state.get(input.conversationId, "goal");
+        return { ...current && { goal: GoalSchema.parse(current.value) } };
+      }
+    }),
+    defineAgentTool({
+      name: "todo_write",
+      description: "Replace the durable ordered work plan for this conversation.",
+      identity: { serviceName: "agent-state", action: "write-todo", method: "POST" },
+      input: z11.object({ items: z11.array(TodoItemSchema) }).strict(),
+      output: z11.object({ items: z11.array(TodoItemSchema) }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const stored = await input.state.set({
+          conversationId: input.conversationId,
+          name: "todo",
+          value: request,
+          actor: "agent"
+        });
+        return z11.object({ items: z11.array(TodoItemSchema) }).strict().parse(stored.value);
+      }
+    })
+  ];
 }
 export {
   validateAgentModelSnapshot,
@@ -827,36 +2217,69 @@ export {
   selectAgentHistory,
   searchAgentModelCatalog,
   runStateForTerminalReason,
+  renderAgentStateSlots,
+  recordAgentSandboxProbe,
+  recordAgentRetryDecision,
   purgeAgentConversation,
   projectAgentHistoryDetailed,
   projectAgentHistory,
+  probeAgentProcessSandbox,
+  missingSandboxRestrictions,
   isToolResultFailure,
   isAssistantHistoryEvidence,
   hasAgentTerminalOutput,
+  encodeAgentConversationArchive,
+  defineStateSlot,
   defineModelRegistry,
   defineAgentProtocol,
+  defineAgentProjection,
+  decodeAgentStoreEvent,
+  decodeAgentConversationArchive,
+  createSqliteAgentSpillStore,
+  createSqliteAgentProjectionStore,
+  createSqliteAgentEventSearch,
+  createSqliteAgentChildManager,
   createMemoryAgentRuntimeStore,
   createMemoryAgentModelSelectionStore,
   createDeferredAgentToolSurface,
   createAgentToolFenceLifecycle,
+  createAgentStateTools,
+  createAgentStateSlotStore,
   createAgentSessionCoordinator,
+  createAgentScheduleTools,
+  createAgentScheduleService,
   createAgentRuntimeStore,
   createAgentRuntimeEventSink,
   createAgentRuntime,
+  createAgentProjectionRegistry,
   createAgentObservability,
+  createAgentEventSearchTools,
+  createAgentChildTools,
   composeAgentPrompt,
   classifyProviderFailure,
+  canonicalAgentJson,
+  agentUsageProjection,
+  agentTodoStateSlot,
+  agentSummaryProjection,
+  agentStateSlotsProjection,
+  agentScheduleSummaryProjection,
+  agentOutlineProjection,
+  agentGoalStateSlot,
   agentDurableEventId,
+  agentConversationCardProjection,
+  agentChildBudgetStopPolicy,
   advanceAgentRuntimeEventCursor,
   RequestRunInterruptSchema,
   ReplaceCompactedRangeSchema,
   RecoverAgentRunSchema,
   RecordRunOperationSchema,
+  ReadAgentStoreEventsSchema,
   DeferredAgentToolSearchInputSchema,
   DeferredAgentToolReceiptSchema,
   DeferredAgentToolMatchSchema,
   CommitRunTerminalSchema,
   CheckpointRunAssistantSchema,
+  AppendAgentStoreEventSchema,
   AgentUsageValueSchema,
   AgentUsageSchema,
   AgentTransientDeltaEventSchema,
@@ -871,14 +2294,21 @@ export {
   AgentTerminalReasonSchema,
   AgentTerminalEventSchema,
   AgentStoredRunSchema,
+  AgentStoreTransitionSchema,
   AgentStoreNotFoundSchema,
   AgentStoreMutationResultSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreEventKindSchema,
+  AgentStoreEventEnvelopeSchema,
   AgentStoreDuplicateSchema,
   AgentStoreConflictSchema,
   AgentStoreAppliedSchema,
   AgentStepFinishedEventSchema,
   AgentSourcePartSchema,
   AgentSnapshotSchema,
+  AgentScheduleSchema,
+  AgentSandboxRestrictionSchema,
+  AgentSandboxGradeSchema,
   AgentRuntimeHeadSchema,
   AgentRuntimeEventSchema,
   AgentRuntimeEventCursorSchema,
@@ -904,6 +2334,7 @@ export {
   AgentReasoningPartSchema,
   AgentReasoningEndEventSchema,
   AgentReasoningDeltaEventSchema,
+  AgentProviderStreamCutError,
   AgentProviderEnvelopeSchema,
   AgentProvenanceSchema,
   AgentOpaquePartSchema,
@@ -925,6 +2356,7 @@ export {
   AgentJsonObjectSchema,
   AgentHistoryMutationSchema,
   AgentFilePartSchema,
+  AgentEventSearchResultSchema,
   AgentCostValueSchema,
   AgentConversationSummarySchema,
   AgentConversationPurgedError,
@@ -932,9 +2364,14 @@ export {
   AgentConversationPurgeInputSchema,
   AgentConversationPageSchema,
   AgentConversationMessagePageSchema,
+  AgentConversationArchiveSchema,
   AgentControlPartSchema,
   AgentContextOverflowError,
+  AgentChildStateSchema,
+  AgentChildRecordSchema,
+  AgentChildBudgetSchema,
   AgentCheckpointEventSchema,
+  AgentAttemptResetEventSchema,
   AgentAssistantPlaceholderSchema,
   AgentAdmissionReceiptSchema,
   AgentAdmissionEventSchema,