@deepagents/context 0.38.1 → 1.0.0

package/dist/index.js

@@ -163,7 +163,12 @@ function isFragment(data) {
   return typeof data === "object" && data !== null && "name" in data && ("data" in data || "codec" in data) && typeof data.name === "string";
 }
 function isFragmentObject(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
+  if (typeof data !== "object" || data === null) return false;
+  if (Array.isArray(data)) return false;
+  if (data instanceof Promise) return false;
+  if (Symbol.asyncIterator in data || Symbol.iterator in data) return false;
+  if (isFragment(data)) return false;
+  return true;
 }
 function isMessageFragment(fragment2) {
   return fragment2.type === "message";
@@ -236,7 +241,10 @@ function assistantText(content, options) {
 }
 
 // packages/context/src/lib/fragments/message/user.ts
-import { generateId as generateId2 } from "ai";
+import {
+  generateId as generateId2,
+  isStaticToolUIPart
+} from "ai";
 
 // packages/context/src/lib/renderers/abstract.renderer.ts
 import pluralize from "pluralize";
@@ -1130,7 +1138,56 @@ function isConditionalReminder(fragment2) {
 var SYSTEM_REMINDER_OPEN_TAG = "<system-reminder>";
 var SYSTEM_REMINDER_CLOSE_TAG = "</system-reminder>";
 function getReminderRanges(metadata) {
-  return metadata?.reminders ?? [];
+  return getReminderMetadataRecords(metadata).map((record) => ({
+    partIndex: record.partIndex,
+    start: record.start,
+    end: record.end
+  }));
+}
+function getReminderMetadataRecords(metadata) {
+  const reminders = metadata?.reminders;
+  if (!Array.isArray(reminders)) return [];
+  return reminders.filter(
+    (item) => isRecord(item) && typeof item.partIndex === "number" && typeof item.start === "number" && typeof item.end === "number"
+  );
+}
+function reminderTargetOf(record) {
+  return record.target === "tool-output" ? "tool-output" : "user";
+}
+function normalizeReminderTarget(target) {
+  if (target === void 0 || target === "user") return "user";
+  if (target === "tool-output") return "tool-output";
+  throw new Error(`Unsupported reminder target: ${String(target)}`);
+}
+function isConditionalReminderOptions(options) {
+  return options !== void 0 && "when" in options;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function normalizeImmediateReminderText(textOrFragment) {
+  if (isFragment(textOrFragment)) {
+    return new XmlRenderer().render([textOrFragment]);
+  }
+  if (typeof textOrFragment === "string") {
+    return textOrFragment;
+  }
+  return (ctx) => {
+    const resolved = textOrFragment(ctx);
+    if (isPromiseLike(resolved)) {
+      throw new Error("Async reminder text requires a when predicate");
+    }
+    return resolved;
+  };
+}
+function normalizeConditionalReminderText(textOrFragment) {
+  return isFragment(textOrFragment) ? new XmlRenderer().render([textOrFragment]) : textOrFragment;
+}
+function isOutputAvailableToolPart(part) {
+  return isStaticToolUIPart(part) && part.state === "output-available";
+}
+function isToolOutputReminderEnvelope(value) {
+  return isRecord(value) && typeof value.systemReminder === "string";
 }
 function stripTextByRanges(text, ranges) {
   if (ranges.length === 0) {
@@ -1159,17 +1216,44 @@ function stripTextByRanges(text, ranges) {
   return output.trimEnd();
 }
 function stripReminders(message2) {
-  const reminderRanges = getReminderRanges(
+  const reminderRecords = getReminderMetadataRecords(
     isRecord(message2.metadata) ? message2.metadata : void 0
   );
   const rangesByPartIndex = /* @__PURE__ */ new Map();
-  for (const range of reminderRanges) {
+  const toolRemindersByPartIndex = /* @__PURE__ */ new Map();
+  for (const range of reminderRecords) {
+    if (reminderTargetOf(range) === "tool-output") {
+      const records = toolRemindersByPartIndex.get(range.partIndex) ?? [];
+      records.push(range);
+      toolRemindersByPartIndex.set(range.partIndex, records);
+      continue;
+    }
     const partRanges = rangesByPartIndex.get(range.partIndex) ?? [];
     partRanges.push({ start: range.start, end: range.end });
     rangesByPartIndex.set(range.partIndex, partRanges);
   }
   const strippedParts = message2.parts.flatMap((part, partIndex) => {
     const clonedPart = { ...part };
+    const toolReminderRecords = toolRemindersByPartIndex.get(partIndex);
+    if (toolReminderRecords !== void 0 && isOutputAvailableToolPart(clonedPart)) {
+      if (typeof clonedPart.output === "string") {
+        return [
+          {
+            ...clonedPart,
+            output: stripTextByRanges(
+              clonedPart.output,
+              toolReminderRecords.map((record) => ({
+                start: record.start,
+                end: record.end
+              }))
+            )
+          }
+        ];
+      }
+      if (isToolOutputReminderEnvelope(clonedPart.output)) {
+        return [{ ...clonedPart, output: clonedPart.output.result }];
+      }
+    }
     const ranges = rangesByPartIndex.get(partIndex);
     if (clonedPart.type !== "text" || ranges === void 0) {
       return [clonedPart];
@@ -1239,6 +1323,7 @@ function applyInlineReminder(message2, value) {
   return {
     id: generateId2(),
     text: value,
+    target: "user",
     partIndex,
     start,
     end: start + reminderText.length,
@@ -1252,6 +1337,7 @@ function applyPartReminder(message2, value) {
   return {
     id: generateId2(),
     text: value,
+    target: "user",
     partIndex,
     start: 0,
     end: value.length,
@@ -1306,6 +1392,65 @@ function applyReminderToMessage(message2, item, ctx) {
   }
   return item.asPart ? applyPartReminder(message2, resolved.text) : applyInlineReminder(message2, resolved.text);
 }
+function findSingleOutputAvailableToolPart(message2) {
+  let match = null;
+  for (let partIndex = 0; partIndex < message2.parts.length; partIndex++) {
+    const part = message2.parts[partIndex];
+    if (!isOutputAvailableToolPart(part)) continue;
+    if (match) return null;
+    match = { partIndex, part };
+  }
+  return match;
+}
+function applyToolOutputRemindersToMessage(message2, reminders) {
+  if (reminders.length === 0) return [];
+  const target = findSingleOutputAvailableToolPart(message2);
+  if (!target) return [];
+  for (const reminder2 of reminders) {
+    if (reminder2.metadata) {
+      mergeMessageMetadata(message2, reminder2.metadata);
+    }
+  }
+  const added = [];
+  if (typeof target.part.output === "string") {
+    let output = target.part.output;
+    for (const reminder2 of reminders) {
+      const reminderText = formatTaggedReminder(reminder2.text);
+      const start = output.length;
+      output = `${output}${reminderText}`;
+      added.push({
+        id: generateId2(),
+        text: reminder2.text,
+        target: "tool-output",
+        partIndex: target.partIndex,
+        start,
+        end: start + reminderText.length,
+        mode: "tool-output"
+      });
+    }
+    message2.parts[target.partIndex] = {
+      ...target.part,
+      output
+    };
+    return added;
+  }
+  message2.parts[target.partIndex] = {
+    ...target.part,
+    output: {
+      result: target.part.output,
+      systemReminder: reminders.map((reminder2) => reminder2.text).join("\n")
+    }
+  };
+  return reminders.map((reminder2) => ({
+    id: generateId2(),
+    text: reminder2.text,
+    target: "tool-output",
+    partIndex: target.partIndex,
+    start: 0,
+    end: 0,
+    mode: "tool-output"
+  }));
+}
 function mergeReminderMetadata(message2, addedReminders) {
   if (addedReminders.length === 0) return;
   const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
@@ -1314,28 +1459,37 @@ function mergeReminderMetadata(message2, addedReminders) {
   message2.metadata = metadata;
 }
 function reminder(textOrFragment, options) {
-  const fromFragment2 = isFragment(textOrFragment);
-  const text = fromFragment2 ? new XmlRenderer().render([textOrFragment]) : textOrFragment;
-  if (typeof text === "string") {
-    assertReminderText(text);
-  }
-  const asPart = options?.asPart ?? false;
-  if (options && "when" in options && options.when) {
+  const target = normalizeReminderTarget(options?.target);
+  const asPart = target === "user" ? options?.asPart ?? false : false;
+  if (isConditionalReminderOptions(options)) {
+    const text2 = normalizeConditionalReminderText(textOrFragment);
+    if (typeof text2 === "string") {
+      assertReminderText(text2);
+    }
     return {
       name: "reminder",
       data: null,
       metadata: {
         reminder: {
-          text,
+          text: text2,
           when: options.when,
-          asPart
+          asPart,
+          target
         }
       }
     };
   }
+  if (target !== "user") {
+    throw new Error('Reminder target "tool-output" requires a when predicate');
+  }
+  const text = normalizeImmediateReminderText(textOrFragment);
+  if (typeof text === "string") {
+    assertReminderText(text);
+  }
   return {
     text,
-    asPart
+    asPart,
+    target
   };
 }
 function user(content, ...reminders) {
@@ -1402,27 +1556,27 @@ import {
 } from "ai";
 import chalk from "chalk";
 function createRepairToolCall(model, abortSignal) {
-  return async ({ toolCall, tools, inputSchema, error }) => {
+  return async ({ toolCall: toolCall2, tools, inputSchema, error }) => {
     if (NoSuchToolError.isInstance(error)) {
       return null;
     }
     console.log(
-      `Debug: ${chalk.yellow("RepairingToolCall")}: ${toolCall.toolName}`
+      `Debug: ${chalk.yellow("RepairingToolCall")}: ${toolCall2.toolName}`
     );
-    const tool3 = tools[toolCall.toolName];
+    const tool3 = tools[toolCall2.toolName];
     const { output } = await generateText({
       abortSignal,
       model,
       output: Output.object({ schema: tool3.inputSchema }),
       prompt: [
-        `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
-        JSON.stringify(toolCall.input),
+        `The model tried to call the tool "${toolCall2.toolName}" with the following inputs:`,
+        JSON.stringify(toolCall2.input),
         `The tool accepts the following schema:`,
-        JSON.stringify(inputSchema(toolCall)),
+        JSON.stringify(inputSchema(toolCall2)),
         "Please fix the inputs."
       ].join("\n")
     });
-    return { ...toolCall, input: JSON.stringify(output) };
+    return { ...toolCall2, input: JSON.stringify(output) };
   };
 }
 
@@ -1450,7 +1604,8 @@ var Agent = class _Agent {
       throw new Error(`Agent ${this.#options.name} is missing a model.`);
     }
     const { messages, systemPrompt } = await this.#options.context.resolve({
-      renderer: new XmlRenderer()
+      renderer: new XmlRenderer(),
+      sandbox: this.#options.sandbox
     });
     return generateText2({
       abortSignal: config?.abortSignal,
@@ -1470,10 +1625,10 @@ var Agent = class _Agent {
       ),
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
-        const toolCall = step.toolCalls.at(-1);
-        if (toolCall) {
+        const toolCall2 = step.toolCalls.at(-1);
+        if (toolCall2) {
           console.log(
-            `Debug: ${chalk2.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+            `Debug: ${chalk2.yellow("ToolCalled")}: ${toolCall2.toolName}(${JSON.stringify(toolCall2.input)})`
           );
         }
       }
@@ -1522,7 +1677,8 @@ var Agent = class _Agent {
       throw new Error(`Agent ${this.#options.name} is missing a model.`);
     }
     const { messages, systemPrompt } = await context.resolve({
-      renderer: new XmlRenderer()
+      renderer: new XmlRenderer(),
+      sandbox: this.#options.sandbox
     });
     const runId = generateId3();
     return streamText({
@@ -1544,10 +1700,10 @@ var Agent = class _Agent {
       experimental_context: contextVariables,
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
-        const toolCall = step.toolCalls.at(-1);
-        if (toolCall) {
+        const toolCall2 = step.toolCalls.at(-1);
+        if (toolCall2) {
           console.log(
-            `Debug: (${runId}) ${chalk2.bold.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+            `Debug: (${runId}) ${chalk2.bold.yellow("ToolCalled")}: ${toolCall2.toolName}(${JSON.stringify(toolCall2.input)})`
           );
         }
       }
@@ -1797,7 +1953,8 @@ function structuredOutput(options) {
         throw new Error(`structuredOutput is missing a model.`);
       }
       const { messages, systemPrompt } = await options.context.resolve({
-        renderer: new XmlRenderer()
+        renderer: new XmlRenderer(),
+        sandbox: options.sandbox
       });
       const result = await generateText2({
         abortSignal: config?.abortSignal,
@@ -1827,7 +1984,8 @@ function structuredOutput(options) {
         throw new Error(`structuredOutput is missing a model.`);
       }
       const { messages, systemPrompt } = await options.context.resolve({
-        renderer: new XmlRenderer()
+        renderer: new XmlRenderer(),
+        sandbox: options.sandbox
       });
       return streamText({
         abortSignal: config?.abortSignal,
@@ -1886,7 +2044,74 @@ import {
   generateId as generateId4,
   validateUIMessages
 } from "ai";
-import { mergeWith } from "lodash-es";
+
+// packages/context/src/lib/ui-message-guards.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUIMessage(value) {
+  return isRecord2(value) && typeof value.id === "string" && (value.role === "system" || value.role === "user" || value.role === "assistant") && Array.isArray(value.parts);
+}
+function isUserUIMessage(value) {
+  return isUIMessage(value) && value.role === "user";
+}
+function requireUIMessage(value, source) {
+  if (isUIMessage(value)) {
+    return value;
+  }
+  throw new Error(`${source} is not a UIMessage`);
+}
+function requireUserUIMessage(value, source) {
+  if (isUserUIMessage(value)) {
+    return value;
+  }
+  throw new Error(`${source} is not a user UIMessage`);
+}
+
+// packages/context/src/lib/chain-summary.ts
+var ChainSummaryBuilder = class {
+  #turn = 0;
+  #messageCount = 0;
+  #lastMessageAt;
+  #lastMessage;
+  #lastAssistantMessage;
+  #lastAssistantMessages = [];
+  ingestStored(msg) {
+    this.#messageCount++;
+    if (msg.name === "assistant") {
+      const message2 = requireUIMessage(
+        msg.data,
+        `Stored assistant message "${msg.id}"`
+      );
+      this.#lastAssistantMessage = message2;
+      this.#lastAssistantMessages.push(message2);
+      return;
+    }
+    if (msg.name !== "user") {
+      return;
+    }
+    this.#turn++;
+    this.#lastMessageAt = msg.createdAt;
+    this.#lastMessage = requireUIMessage(
+      msg.data,
+      `Stored user message "${msg.id}"`
+    );
+  }
+  ingestPending(fragment2) {
+    this.#messageCount++;
+    if (fragment2.name === "user") this.#turn++;
+  }
+  build() {
+    return {
+      turn: this.#turn,
+      messageCount: this.#messageCount,
+      lastMessageAt: this.#lastMessageAt,
+      lastMessage: this.#lastMessage,
+      lastAssistantMessage: this.#lastAssistantMessage,
+      lastAssistantMessages: this.#lastAssistantMessages
+    };
+  }
+};
 
 // packages/context/src/lib/estimate.ts
 import { encode } from "gpt-tokenizer";
@@ -2048,6 +2273,490 @@ async function estimate(modelId, renderer, ...fragments) {
   };
 }
 
+// packages/context/src/lib/resolvers/async-resolver.ts
+var AsyncResolver = class {
+  name = "AsyncResolver";
+  requiresSandbox = true;
+  canResolve(value) {
+    return typeof value === "function" && value.constructor.name === "AsyncFunction";
+  }
+  resolve(value, ctx) {
+    return value(ctx);
+  }
+};
+
+// packages/context/src/lib/resolvers/function-resolver.ts
+var FunctionResolver = class {
+  name = "FunctionResolver";
+  requiresSandbox = true;
+  canResolve(value) {
+    return typeof value === "function";
+  }
+  async resolve(value, ctx) {
+    const loader = value;
+    return loader(ctx);
+  }
+};
+
+// packages/context/src/lib/resolvers/generator-resolver.ts
+var DEFAULT_MAX_ITEMS = 1e4;
+var GENERATOR_CTOR_NAMES = /* @__PURE__ */ new Set([
+  "GeneratorFunction",
+  "AsyncGeneratorFunction"
+]);
+var GeneratorResolver = class {
+  name = "GeneratorResolver";
+  requiresSandbox = true;
+  #maxItems;
+  constructor(options = {}) {
+    this.#maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+  }
+  canResolve(value) {
+    return typeof value === "function" && GENERATOR_CTOR_NAMES.has(value.constructor.name);
+  }
+  async resolve(value, ctx) {
+    const iterable = value(ctx);
+    const collected = [];
+    if (isAsyncIterable(iterable)) {
+      for await (const chunk of iterable) {
+        pushLimited(collected, chunk, this.#maxItems, this.name);
+      }
+    } else {
+      for (const chunk of iterable) {
+        pushLimited(collected, chunk, this.#maxItems, this.name);
+      }
+    }
+    return collected;
+  }
+};
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function pushLimited(collected, chunk, maxItems, resolverName) {
+  if (collected.length >= maxItems) {
+    throw new Error(
+      `${resolverName}: generator yielded more than ${maxItems} items`
+    );
+  }
+  collected.push(chunk);
+}
+
+// packages/context/src/lib/resolvers/iterable-resolver.ts
+var DEFAULT_MAX_ITEMS2 = 1e4;
+function hasIterableProtocol(value) {
+  return Symbol.asyncIterator in value || Symbol.iterator in value;
+}
+function isBoxedPrimitive(value) {
+  return value instanceof String || value instanceof Number || value instanceof Boolean;
+}
+var IterableResolver = class {
+  name = "IterableResolver";
+  #maxItems;
+  constructor(options = {}) {
+    this.#maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS2;
+  }
+  canResolve(value) {
+    if (value === null || value === void 0) return false;
+    if (typeof value !== "object") return false;
+    if (Array.isArray(value)) return false;
+    if (value instanceof Promise) return false;
+    if (isBoxedPrimitive(value)) return false;
+    if (isFragment(value)) return false;
+    return hasIterableProtocol(value);
+  }
+  async resolve(value, _ctx) {
+    const iterable = value;
+    const collected = [];
+    if (isAsyncIterable2(iterable)) {
+      for await (const chunk of iterable) {
+        pushLimited2(collected, chunk, this.#maxItems, this.name);
+      }
+    } else {
+      for (const chunk of iterable) {
+        pushLimited2(collected, chunk, this.#maxItems, this.name);
+      }
+    }
+    return collected;
+  }
+};
+function isAsyncIterable2(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function pushLimited2(collected, chunk, maxItems, resolverName) {
+  if (collected.length >= maxItems) {
+    throw new Error(
+      `${resolverName}: iterable yielded more than ${maxItems} items`
+    );
+  }
+  collected.push(chunk);
+}
+
+// packages/context/src/lib/resolvers/promise-resolver.ts
+var PromiseResolver = class {
+  name = "PromiseResolver";
+  canResolve(value) {
+    return value instanceof Promise;
+  }
+  resolve(value, _ctx) {
+    return value;
+  }
+};
+
+// packages/context/src/lib/resolvers/loader-resolver.ts
+var FragmentLoaderResolver = class {
+  #resolvers;
+  #maxDepth;
+  constructor(resolvers, options = {}) {
+    this.#resolvers = resolvers;
+    this.#maxDepth = options.maxDepth ?? 10;
+  }
+  async resolve(fragments, ctx) {
+    await Promise.all(
+      fragments.map((f) => this.#walkFragment(f, ctx, 0, /* @__PURE__ */ new Set(), f.name))
+    );
+  }
+  async #walkFragment(fragment2, ctx, depth, ancestors, path5) {
+    if (!("data" in fragment2)) return;
+    fragment2.data = await this.#walkData(
+      fragment2.data,
+      ctx,
+      depth,
+      ancestors,
+      path5
+    );
+  }
+  async #walkData(value, ctx, depth, ancestors, path5) {
+    if (ctx.signal?.aborted) {
+      throw ctx.signal.reason ?? new Error("Resolver aborted");
+    }
+    if (depth > this.#maxDepth) {
+      throw new Error(
+        `Resolver recursion exceeded maxDepth=${this.#maxDepth} at fragment '${path5}'`
+      );
+    }
+    const handler = this.#resolvers.find((r) => r.canResolve(value));
+    if (handler) {
+      if (handler.requiresSandbox && !ctx.sandbox) {
+        throw new Error(
+          `Fragment '${path5}' is dispatched to ${handler.name}, which requires a sandbox; none was provided`
+        );
+      }
+      let resolved;
+      try {
+        resolved = await this.#raceWithSignal(
+          handler.resolve(value, ctx),
+          ctx.signal
+        );
+      } catch (cause) {
+        throw new Error(
+          `Async fragment '${path5}' failed in ${handler.name}: ${cause instanceof Error ? cause.message : String(cause)}`,
+          { cause }
+        );
+      }
+      return this.#walkData(resolved, ctx, depth + 1, ancestors, path5);
+    }
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (isFragment(value)) {
+      if (ancestors.has(value)) return void 0;
+      const childAncestors = new Set(ancestors);
+      childAncestors.add(value);
+      const childPath = `${path5}.${value.name}`;
+      await this.#walkFragment(
+        value,
+        ctx,
+        depth + 1,
+        childAncestors,
+        childPath
+      );
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (ancestors.has(value)) return void 0;
+      const childAncestors = new Set(ancestors);
+      childAncestors.add(value);
+      return Promise.all(
+        value.map(
+          (item) => this.#walkData(item, ctx, depth, childAncestors, path5)
+        )
+      );
+    }
+    if (isFragmentObject(value)) {
+      if (ancestors.has(value)) return void 0;
+      const childAncestors = new Set(ancestors);
+      childAncestors.add(value);
+      const out = {};
+      const entries = Object.entries(value);
+      const resolvedValues = await Promise.all(
+        entries.map(
+          ([, v]) => this.#walkData(v, ctx, depth, childAncestors, path5)
+        )
+      );
+      for (let i = 0; i < entries.length; i += 1) {
+        const [k] = entries[i];
+        const v = resolvedValues[i];
+        if (v !== void 0) out[k] = v;
+      }
+      return out;
+    }
+    return value;
+  }
+  #raceWithSignal(promise, signal) {
+    if (!signal) return promise;
+    if (signal.aborted) {
+      return Promise.reject(signal.reason ?? new Error("Resolver aborted"));
+    }
+    return new Promise((resolve4, reject) => {
+      const onAbort = () => reject(signal.reason ?? new Error("Resolver aborted"));
+      signal.addEventListener("abort", onAbort, { once: true });
+      promise.then(
+        (value) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve4(value);
+        },
+        (err) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        }
+      );
+    });
+  }
+};
+
+// packages/context/src/lib/resolvers/index.ts
+function defaultResolvers() {
+  return [
+    new AsyncResolver(),
+    new GeneratorResolver(),
+    new FunctionResolver(),
+    new PromiseResolver(),
+    new IterableResolver()
+  ];
+}
+
+// packages/context/src/lib/save/save-pipeline.ts
+var SavePipeline = class {
+  #engine;
+  #pending;
+  #fragments;
+  #shouldBranch = true;
+  constructor(engine, pending, fragments) {
+    this.#engine = engine;
+    this.#pending = pending;
+    this.#fragments = fragments;
+  }
+  async applyUpdateBranching(shouldBranch) {
+    this.#shouldBranch = shouldBranch;
+    if (!shouldBranch) return this;
+    for (const fragment2 of this.#pending) {
+      if (!fragment2.id) continue;
+      const existing = await this.#engine.store.getMessage(fragment2.id);
+      if (existing && existing.parentId) {
+        await this.#engine.rewindForUpdate(existing.parentId);
+        fragment2.id = crypto.randomUUID();
+        return this;
+      }
+    }
+    return this;
+  }
+  async evaluateReminders(handlers) {
+    const conditional = this.#fragments.filter(isConditionalReminder);
+    if (conditional.length === 0) return this;
+    const configsByTarget = /* @__PURE__ */ new Map();
+    for (const fragment2 of conditional) {
+      const config = fragment2.metadata.reminder;
+      const target = config.target;
+      const list = configsByTarget.get(target) ?? [];
+      list.push(config);
+      configsByTarget.set(target, list);
+    }
+    const chain = await this.#engine.getChainSummary();
+    const base = this.#engine.buildBaseWhenCtx(chain);
+    const sharedUserMessage = this.#encodePendingUserMessage();
+    for (const handler of handlers) {
+      const configs = configsByTarget.get(handler.target);
+      if (!configs || configs.length === 0) continue;
+      const prepared = handler.prepare({
+        pending: this.#pending,
+        base,
+        chain,
+        sharedUserMessage
+      });
+      if (!prepared) continue;
+      const whenResults = await Promise.all(
+        configs.map((config) => config.when(prepared.whenCtx))
+      );
+      const fired = configs.filter((_, i) => whenResults[i]);
+      if (fired.length === 0) continue;
+      const resolvedOrNull = await Promise.all(
+        fired.map((config) => resolveReminderAsync(config, prepared.whenCtx))
+      );
+      const matched = [];
+      for (let i = 0; i < resolvedOrNull.length; i++) {
+        const resolution = resolvedOrNull[i];
+        if (resolution)
+          matched.push({ config: fired[i], resolved: resolution });
+      }
+      if (matched.length === 0) continue;
+      handler.apply({
+        pending: this.#pending,
+        carrier: prepared.carrier,
+        fired: matched.map((m) => m.config),
+        resolved: matched.map((m) => m.resolved)
+      });
+    }
+    return this;
+  }
+  #encodePendingUserMessage() {
+    const fragmentIndex = this.#pending.findLastIndex(
+      (fragment3) => fragment3.name === "user"
+    );
+    if (fragmentIndex < 0) return void 0;
+    const fragment2 = this.#pending[fragmentIndex];
+    if (!fragment2.codec) return void 0;
+    return requireUserUIMessage(
+      fragment2.codec.encode(),
+      `Pending user fragment "${fragment2.name}"`
+    );
+  }
+  async persist() {
+    let parentId = this.#engine.getActiveBranch().headMessageId;
+    const now = Date.now();
+    for (const fragment2 of this.#pending) {
+      if (!fragment2.codec) {
+        throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
+      }
+      const msgId = fragment2.id ?? crypto.randomUUID();
+      let msgParentId = parentId;
+      if (!this.#shouldBranch && msgId === parentId) {
+        const existing = await this.#engine.store.getMessage(msgId);
+        if (existing) msgParentId = existing.parentId;
+      }
+      const messageData = {
+        id: msgId,
+        chatId: this.#engine.chatId,
+        parentId: msgParentId,
+        name: fragment2.name,
+        type: fragment2.type,
+        data: fragment2.codec.encode(),
+        createdAt: now
+      };
+      await this.#engine.store.addMessage(messageData);
+      parentId = messageData.id;
+    }
+    if (parentId === null) {
+      throw new Error(
+        "Pipeline persisted no messages but pending was not empty"
+      );
+    }
+    await this.#engine.commitHead(parentId);
+    return { headMessageId: parentId };
+  }
+};
+
+// packages/context/src/lib/save/tool-output-target-handler.ts
+var ToolOutputTargetHandler = class {
+  target = "tool-output";
+  prepare({
+    pending,
+    base,
+    chain,
+    sharedUserMessage
+  }) {
+    const fragmentIndex = pending.findLastIndex(
+      (fragment3) => fragment3.name === "assistant"
+    );
+    if (fragmentIndex < 0) return null;
+    const fragment2 = pending[fragmentIndex];
+    if (!fragment2.codec) return null;
+    const currentMessage = sharedUserMessage ?? chain.lastMessage;
+    if (!currentMessage) return null;
+    const message2 = requireUIMessage(
+      fragment2.codec.encode(),
+      `Pending assistant fragment "${fragment2.name}"`
+    );
+    if (!findSingleOutputAvailableToolPart(message2)) return null;
+    return {
+      whenCtx: {
+        ...base,
+        content: extractPlainText(currentMessage),
+        currentMessage,
+        lastAssistantMessage: message2,
+        lastAssistantMessages: [
+          ...chain.lastAssistantMessages ?? [],
+          message2
+        ]
+      },
+      carrier: { message: message2, fragmentIndex }
+    };
+  }
+  apply({ pending, carrier, resolved }) {
+    const reminders = resolved.map((resolution) => ({
+      text: resolution.text,
+      metadata: resolution.metadata
+    }));
+    const metadata = applyToolOutputRemindersToMessage(
+      carrier.message,
+      reminders
+    );
+    mergeReminderMetadata(carrier.message, metadata);
+    const originalId = pending[carrier.fragmentIndex].id;
+    const message2 = originalId ? { ...carrier.message, id: originalId } : carrier.message;
+    const updated = assistant(message2);
+    if (originalId) updated.id = originalId;
+    pending[carrier.fragmentIndex] = updated;
+  }
+};
+
+// packages/context/src/lib/save/user-target-handler.ts
+var UserTargetHandler = class {
+  target = "user";
+  prepare({
+    pending,
+    base,
+    chain
+  }) {
+    const fragmentIndex = pending.findLastIndex(
+      (fragment3) => fragment3.name === "user"
+    );
+    if (fragmentIndex < 0) return null;
+    const fragment2 = pending[fragmentIndex];
+    if (!fragment2.codec) return null;
+    const message2 = requireUserUIMessage(
+      fragment2.codec.encode(),
+      `Pending user fragment "${fragment2.name}"`
+    );
+    return {
+      whenCtx: {
+        ...base,
+        content: extractPlainText(message2),
+        currentMessage: message2,
+        lastAssistantMessage: chain.lastAssistantMessage,
+        lastAssistantMessages: chain.lastAssistantMessages
+      },
+      carrier: { message: message2, fragmentIndex },
+      sharedUserMessage: message2
+    };
+  }
+  apply({ pending, carrier, fired, resolved }) {
+    const reminders = resolved.map((resolution, i) => ({
+      text: resolution.text,
+      asPart: fired[i].asPart,
+      target: "user",
+      metadata: resolution.metadata
+    }));
+    const originalId = pending[carrier.fragmentIndex].id;
+    const message2 = requireUserUIMessage(
+      originalId ? { ...carrier.message, id: originalId } : carrier.message,
+      "Pending user reminder carrier"
+    );
+    const recreated = user(message2, ...reminders);
+    if (originalId) recreated.id = originalId;
+    pending[carrier.fragmentIndex] = recreated;
+  }
+};
+
 // packages/context/src/lib/store/sqlite.store.ts
 import { DatabaseSync } from "node:sqlite";
 
@@ -2593,6 +3302,55 @@ function estimateMessageContent(data) {
 function isLanguageModelUsage(value) {
   return typeof value === "object" && value !== null && "totalTokens" in value;
 }
+function addUsageValue(current, next) {
+  if (current === void 0 && next === void 0) {
+    return void 0;
+  }
+  return (current ?? 0) + (next ?? 0);
+}
+function mergeLanguageModelUsage(current, next) {
+  return {
+    inputTokens: addUsageValue(current?.inputTokens, next.inputTokens),
+    inputTokenDetails: {
+      noCacheTokens: addUsageValue(
+        current?.inputTokenDetails?.noCacheTokens,
+        next.inputTokenDetails?.noCacheTokens
+      ),
+      cacheReadTokens: addUsageValue(
+        current?.inputTokenDetails?.cacheReadTokens,
+        next.inputTokenDetails?.cacheReadTokens
+      ),
+      cacheWriteTokens: addUsageValue(
+        current?.inputTokenDetails?.cacheWriteTokens,
+        next.inputTokenDetails?.cacheWriteTokens
+      )
+    },
+    outputTokens: addUsageValue(current?.outputTokens, next.outputTokens),
+    outputTokenDetails: {
+      textTokens: addUsageValue(
+        current?.outputTokenDetails?.textTokens,
+        next.outputTokenDetails?.textTokens
+      ),
+      reasoningTokens: addUsageValue(
+        current?.outputTokenDetails?.reasoningTokens,
+        next.outputTokenDetails?.reasoningTokens
+      )
+    },
+    totalTokens: addUsageValue(current?.totalTokens, next.totalTokens),
+    reasoningTokens: addUsageValue(
+      current?.reasoningTokens,
+      next.reasoningTokens
+    ),
+    cachedInputTokens: addUsageValue(
+      current?.cachedInputTokens,
+      next.cachedInputTokens
+    ),
+    raw: next.raw ?? current?.raw
+  };
+}
+function isSkillPathMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.name === "string" && typeof value.description === "string" && typeof value.host === "string" && typeof value.sandbox === "string";
+}
 function isEmptyAssistantPlaceholder(message2) {
   return message2.role === "assistant" && message2.parts.length === 0;
 }
@@ -2610,6 +3368,7 @@ var ContextEngine = class _ContextEngine {
   #initialized = false;
   /** Initial metadata to merge on first initialization */
   #initialMetadata;
+  #loaderResolver;
   get #activeBranch() {
     if (!this.#branch) {
       throw new Error(
@@ -2633,6 +3392,9 @@ var ContextEngine = class _ContextEngine {
     this.#userId = options.userId;
     this.#branchName = "main";
     this.#initialMetadata = options.metadata;
+    this.#loaderResolver = new FragmentLoaderResolver(
+      options.resolvers ?? defaultResolvers()
+    );
   }
   /**
    * Initialize the chat and branch if they don't exist.
@@ -2739,39 +3501,16 @@ var ContextEngine = class _ContextEngine {
    */
   async #getChainContext() {
     await this.#ensureInitialized();
-    let turn = 0;
-    let messageCount = 0;
-    let lastMessageAt;
-    let lastMessage;
-    let lastAssistantMessage;
+    const builder = new ChainSummaryBuilder();
     if (this.#branch?.headMessageId) {
       const chain = await this.#store.getMessageChain(
         this.#branch.headMessageId
       );
-      for (const msg of chain) {
-        messageCount++;
-        if (msg.name === "assistant") {
-          lastAssistantMessage = msg.data;
-        }
-        if (msg.name !== "user") {
-          continue;
-        }
-        turn++;
-        lastMessageAt = msg.createdAt;
-        lastMessage = msg.data;
-      }
+      for (const msg of chain) builder.ingestStored(msg);
     }
-    for (const fragment2 of this.#pendingMessages) {
-      messageCount++;
-      if (fragment2.name === "user") turn++;
-    }
-    return {
-      turn,
-      messageCount,
-      lastMessageAt,
-      lastMessage,
-      lastAssistantMessage
-    };
+    for (const fragment2 of this.#pendingMessages)
+      builder.ingestPending(fragment2);
+    return builder.build();
   }
   async getTurnCount() {
     const { turn } = await this.#getChainContext();
@@ -2784,7 +3523,9 @@ var ContextEngine = class _ContextEngine {
         this.#branch.headMessageId
       );
       for (const msg of chain) {
-        if (msg.name === "user") return msg.data;
+        if (msg.name === "user") {
+          return requireUIMessage(msg.data, `Stored user message "${msg.id}"`);
+        }
       }
     }
     for (const fragment2 of this.#pendingMessages) {
@@ -2792,7 +3533,10 @@ var ContextEngine = class _ContextEngine {
       if (!fragment2.codec) {
         throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
       }
-      return fragment2.codec.encode();
+      return requireUIMessage(
+        fragment2.codec.encode(),
+        `Pending fragment "${fragment2.name}"`
+      );
     }
     return void 0;
   }
@@ -2835,7 +3579,7 @@ var ContextEngine = class _ContextEngine {
         this.#branch.headMessageId
       );
       for (const msg of chain) {
-        const data = msg.data;
+        const data = requireUIMessage(msg.data, `Stored message "${msg.id}"`);
         if (isEmptyAssistantPlaceholder(data)) continue;
         messages.push(data);
       }
@@ -2844,7 +3588,10 @@ var ContextEngine = class _ContextEngine {
       if (!fragment2.codec) {
         throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
       }
-      const encoded = fragment2.codec.encode();
+      const encoded = requireUIMessage(
+        fragment2.codec.encode(),
+        `Pending fragment "${fragment2.name}"`
+      );
       if (isEmptyAssistantPlaceholder(encoded)) continue;
       messages.push(encoded);
     }
@@ -2936,6 +3683,11 @@ var ContextEngine = class _ContextEngine {
    */
   async resolve(options) {
     await this.#ensureInitialized();
+    await this.#loaderResolver.resolve(this.#fragments, {
+      sandbox: options.sandbox,
+      context: this,
+      signal: options.signal
+    });
     const systemPrompt = options.renderer.render(this.#renderableFragments);
     const messages = await this.getMessages();
     return { systemPrompt, messages };
@@ -2959,114 +3711,61 @@ var ContextEngine = class _ContextEngine {
     if (this.#pendingMessages.length === 0) {
       return { headMessageId: this.#branch?.headMessageId ?? void 0 };
     }
-    const shouldBranch = options?.branch ?? true;
-    if (shouldBranch) {
-      for (const fragment2 of this.#pendingMessages) {
-        if (fragment2.id) {
-          const existing = await this.#store.getMessage(fragment2.id);
-          if (existing && existing.parentId) {
-            await this.#rewindForUpdate(existing.parentId);
-            fragment2.id = crypto.randomUUID();
-            break;
-          }
+    const pipeline = new SavePipeline(
+      this.#asSavePipelineEngine(),
+      this.#pendingMessages,
+      this.#fragments
+    );
+    await pipeline.applyUpdateBranching(options?.branch ?? true);
+    await pipeline.evaluateReminders(this.#reminderHandlers);
+    const result = await pipeline.persist();
+    this.#pendingMessages = [];
+    return result;
+  }
+  #reminderHandlers = [
+    new UserTargetHandler(),
+    new ToolOutputTargetHandler()
+  ];
+  #asSavePipelineEngine() {
+    return {
+      store: this.#store,
+      chatId: this.#chatId,
+      branchName: this.#branchName,
+      getActiveBranch: () => ({
+        id: this.#activeBranch.id,
+        headMessageId: this.#activeBranch.headMessageId
+      }),
+      commitHead: async (headMessageId) => {
+        await this.#store.updateBranchHead(
+          this.#activeBranch.id,
+          headMessageId
+        );
+        this.#activeBranch.headMessageId = headMessageId;
+      },
+      rewindForUpdate: (parentId) => this.#rewindForUpdate(parentId),
+      getChainSummary: () => this.#getChainContext(),
+      buildBaseWhenCtx: (chain) => {
+        const rawUsage = this.#chatData?.metadata?.usage;
+        const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
+        const elapsed = chain.lastMessageAt !== void 0 ? Date.now() - chain.lastMessageAt : void 0;
+        const chatData = this.#chatData;
+        if (!chatData) {
+          throw new Error(
+            "ContextEngine must be initialized before reminders run"
+          );
         }
+        return {
+          turn: chain.turn,
+          messageCount: chain.messageCount,
+          lastMessageAt: chain.lastMessageAt,
+          lastMessage: chain.lastMessage,
+          chat: chatData,
+          usage,
+          branch: this.#branchName,
+          elapsed
+        };
       }
-    }
-    const conditionalReminders = this.#fragments.filter(isConditionalReminder);
-    if (conditionalReminders.length > 0) {
-      let lastUserIndex = -1;
-      for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
-        if (this.#pendingMessages[i].name === "user") {
-          lastUserIndex = i;
-          break;
-        }
-      }
-      if (lastUserIndex >= 0) {
-        const lastUserFragment = this.#pendingMessages[lastUserIndex];
-        if (lastUserFragment.codec) {
-          const {
-            turn,
-            messageCount,
-            lastMessageAt,
-            lastMessage,
-            lastAssistantMessage
-          } = await this.#getChainContext();
-          const original = lastUserFragment.codec.encode();
-          const plainText = extractPlainText(original);
-          const rawUsage = this.#chatData?.metadata?.usage;
-          const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
-          const elapsed = lastMessageAt !== void 0 ? Date.now() - lastMessageAt : void 0;
-          const whenCtx = {
-            turn,
-            content: plainText,
-            lastMessageAt,
-            lastMessage,
-            currentMessage: original,
-            chat: this.#chatData,
-            usage,
-            branch: this.#branchName,
-            elapsed,
-            messageCount,
-            lastAssistantMessage
-          };
-          const configs = conditionalReminders.map(
-            (it) => it.metadata.reminder
-          );
-          const whenResults = await Promise.all(
-            configs.map((it) => it.when(whenCtx))
-          );
-          const firedReminders = configs.filter((_, i) => whenResults[i]);
-          if (firedReminders.length > 0) {
-            const resolvedOrNull = await Promise.all(
-              firedReminders.map((it) => resolveReminderAsync(it, whenCtx))
-            );
-            const reminders = resolvedOrNull.flatMap((resolved, i) => {
-              if (!resolved) return [];
-              return [
-                {
-                  text: resolved.text,
-                  asPart: firedReminders[i].asPart,
-                  metadata: resolved.metadata
-                }
-              ];
-            });
-            const recreated = user(original, ...reminders);
-            recreated.id = lastUserFragment.id;
-            this.#pendingMessages[lastUserIndex] = recreated;
-          }
-        }
-      }
-    }
-    let parentId = this.#activeBranch.headMessageId;
-    const now = Date.now();
-    for (const fragment2 of this.#pendingMessages) {
-      if (!fragment2.codec) {
-        throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
-      }
-      const msgId = fragment2.id ?? crypto.randomUUID();
-      let msgParentId = parentId;
-      if (!shouldBranch && msgId === parentId) {
-        const existing = await this.#store.getMessage(msgId);
-        if (existing) {
-          msgParentId = existing.parentId;
-        }
-      }
-      const messageData = {
-        id: msgId,
-        chatId: this.#chatId,
-        parentId: msgParentId,
-        name: fragment2.name,
-        type: fragment2.type,
-        data: fragment2.codec.encode(),
-        createdAt: now
-      };
-      await this.#store.addMessage(messageData);
-      parentId = messageData.id;
-    }
-    await this.#store.updateBranchHead(this.#activeBranch.id, parentId);
-    this.#activeBranch.headMessageId = parentId;
-    this.#pendingMessages = [];
-    return { headMessageId: this.#activeBranch.headMessageId ?? void 0 };
+    };
   }
   /**
    * Estimate token count and cost for the full context.
@@ -3082,6 +3781,11 @@ var ContextEngine = class _ContextEngine {
    */
   async estimate(modelId, options = {}) {
     await this.#ensureInitialized();
+    await this.#loaderResolver.resolve(this.#fragments, {
+      sandbox: options.sandbox,
+      context: this,
+      signal: options.signal
+    });
     const renderer = options.renderer ?? new XmlRenderer();
     const registry = getModelsRegistry();
     await registry.load();
@@ -3354,13 +4058,9 @@ var ContextEngine = class _ContextEngine {
   async trackUsage(usage) {
     await this.#ensureInitialized();
     const freshChatData = await this.#store.getChat(this.#chatId);
-    const currentUsage = freshChatData?.metadata?.usage ?? {};
-    const updatedUsage = mergeWith(
-      {},
-      currentUsage,
-      usage,
-      (a, b) => typeof a === "number" || typeof b === "number" ? (a ?? 0) + (b ?? 0) : void 0
-    );
+    const storedUsage = freshChatData?.metadata?.usage;
+    const currentUsage = isLanguageModelUsage(storedUsage) ? storedUsage : void 0;
+    const updatedUsage = mergeLanguageModelUsage(currentUsage, usage);
     this.#chatData = await this.#store.updateChat(this.#chatId, {
       metadata: {
         ...freshChatData?.metadata,
@@ -3415,8 +4115,9 @@ var ContextEngine = class _ContextEngine {
    */
   getSkillMounts() {
     for (const fragment2 of this.#fragments) {
-      if (fragment2.name === "available_skills" && fragment2.metadata?.mounts) {
-        return { mounts: fragment2.metadata.mounts };
+      const mounts = fragment2.metadata?.mounts;
+      if (fragment2.name === "available_skills" && Array.isArray(mounts) && mounts.every(isSkillPathMapping)) {
+        return { mounts };
       }
     }
     return { mounts: [] };
@@ -3443,7 +4144,11 @@ var ContextEngine = class _ContextEngine {
   async inspect(options) {
     await this.#ensureInitialized();
     const { renderer } = options;
-    const estimateResult = await this.estimate(options.modelId, { renderer });
+    const estimateResult = await this.estimate(options.modelId, {
+      renderer,
+      sandbox: options.sandbox,
+      signal: options.signal
+    });
     const rendered = renderer.render(this.#renderableFragments);
     const persistedMessages = [];
     if (this.#branch?.headMessageId) {
@@ -4515,6 +5220,32 @@ function or(...predicates) {
 function not(predicate) {
   return async (ctx) => !await predicate(ctx);
 }
+function withinLastN(n, predicate) {
+  return async (ctx) => {
+    if (n <= 0) return false;
+    const candidates = (ctx.lastAssistantMessages ?? []).slice(-n);
+    for (const message2 of candidates) {
+      if (await predicate({ ...ctx, lastAssistantMessage: message2 })) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function everyOfLastN(n, predicate) {
+  return async (ctx) => {
+    if (n <= 0) return false;
+    const history = ctx.lastAssistantMessages ?? [];
+    if (history.length < n) return false;
+    const candidates = history.slice(-n);
+    for (const message2 of candidates) {
+      if (!await predicate({ ...ctx, lastAssistantMessage: message2 })) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
 
 // packages/context/src/lib/fragments/reminders/content-predicates.ts
 function contentMatches(topics, options) {
@@ -4540,6 +5271,37 @@ function contentPattern(pattern) {
   };
 }
 
+// packages/context/src/lib/fragments/reminders/message-predicates.ts
+function assertCountSpec(spec) {
+  const hasEq = spec.eq !== void 0;
+  const hasRange = spec.gte !== void 0 || spec.lte !== void 0;
+  if (!hasEq && !hasRange) {
+    throw new Error("CountSpec must include at least one of gte/lte/eq");
+  }
+  if (hasEq && hasRange) {
+    throw new Error("CountSpec.eq cannot be combined with gte/lte");
+  }
+}
+function checkCount(count, spec) {
+  if (spec.eq !== void 0) return count === spec.eq;
+  if (spec.gte !== void 0 && count < spec.gte) return false;
+  if (spec.lte !== void 0 && count > spec.lte) return false;
+  return true;
+}
+function lastAssistantLength(spec) {
+  assertCountSpec(spec);
+  return (ctx) => {
+    const message2 = ctx.lastAssistantMessage;
+    const text = message2 ? extractPlainText(message2) : "";
+    return checkCount(text.length, spec);
+  };
+}
+
+// packages/context/src/lib/fragments/reminders/temporal/elapsed.ts
+function elapsedExceeds(ms) {
+  return (ctx) => (ctx.elapsed ?? 0) >= ms;
+}
+
 // packages/context/src/lib/fragments/reminders/temporal/predicates.ts
 var LOCALE_METADATA_KEY = "locale";
 function getLocaleFromMessage(message2) {
@@ -4811,6 +5573,73 @@ function temporalReminder(options) {
   ];
 }
 
+// packages/context/src/lib/fragments/reminders/tool-predicates.ts
+import { isStaticToolUIPart as isStaticToolUIPart2 } from "ai";
+var COMPLETED_STATES = /* @__PURE__ */ new Set([
+  "input-available",
+  "output-available",
+  "output-error"
+]);
+function matchesName(spec, name) {
+  return typeof spec === "function" ? spec(name) : spec === name;
+}
+function toolNameOf(part) {
+  return part.type.slice("tool-".length);
+}
+function toolPartsOf(message2) {
+  if (!message2) return [];
+  return message2.parts.filter(isStaticToolUIPart2);
+}
+function toolCall(options) {
+  return (ctx) => {
+    const parts = toolPartsOf(ctx.lastAssistantMessage);
+    return parts.some((part) => {
+      if (options.state) {
+        if (part.state !== options.state) return false;
+      } else if (!COMPLETED_STATES.has(part.state)) {
+        return false;
+      }
+      if (options.name !== void 0 && !matchesName(options.name, toolNameOf(part))) {
+        return false;
+      }
+      if (options.input && !options.input(part.input)) {
+        return false;
+      }
+      if (options.output) {
+        if (part.state !== "output-available") return false;
+        if (!options.output(part.output))
+          return false;
+      }
+      if (options.errorText) {
+        if (part.state !== "output-error") return false;
+        const text = part.errorText ?? "";
+        if (!options.errorText(text)) return false;
+      }
+      return true;
+    });
+  };
+}
+function toolCalled(name) {
+  return toolCall({ name });
+}
+function toolFailed(name) {
+  return toolCall({ name, state: "output-error" });
+}
+function anyToolCalled() {
+  return (ctx) => toolPartsOf(ctx.lastAssistantMessage).some(
+    (part) => COMPLETED_STATES.has(part.state)
+  );
+}
+function toolCallCount(name, spec) {
+  assertCountSpec(spec);
+  return (ctx) => {
+    const count = toolPartsOf(ctx.lastAssistantMessage).filter(
+      (part) => COMPLETED_STATES.has(part.state) && matchesName(name, toolNameOf(part))
+    ).length;
+    return checkCount(count, spec);
+  };
+}
+
 // packages/context/src/lib/fragments/reminders/turn-predicates.ts
 function everyNTurns(n) {
   return ({ turn }) => turn % n === 0;
@@ -4825,6 +5654,11 @@ function afterTurn(n) {
   return ({ turn }) => turn > n;
 }
 
+// packages/context/src/lib/fragments/reminders/usage-predicates.ts
+function usageExceeds(totalTokens) {
+  return (ctx) => (ctx.usage?.totalTokens ?? 0) >= totalTokens;
+}
+
 // packages/context/src/lib/fragments/socratic.ts
 function socraticPrompting() {
   return [
@@ -5096,44 +5930,6 @@ async function useAgentOsSandbox(options, fn) {
   }
 }
 
-// packages/context/src/lib/sandbox/ast-utils.ts
-function asStaticWordText(word) {
-  if (!word) {
-    return null;
-  }
-  return asStaticWordPartText(
-    word.parts
-  );
-}
-function asStaticWordPartText(parts) {
-  let text = "";
-  for (const part of parts) {
-    const type = part.type;
-    if (type === "Literal" || type === "SingleQuoted" || type === "Escaped") {
-      if (typeof part.value !== "string") {
-        return null;
-      }
-      text += part.value;
-      continue;
-    }
-    if (type === "DoubleQuoted") {
-      if (!Array.isArray(part.parts)) {
-        return null;
-      }
-      const inner = asStaticWordPartText(
-        part.parts
-      );
-      if (inner == null) {
-        return null;
-      }
-      text += inner;
-      continue;
-    }
-    return null;
-  }
-  return text;
-}
-
 // packages/context/src/lib/sandbox/bash-exception.ts
 var BashException = class extends Error {
 };
@@ -5276,10 +6072,9 @@ function joinSandbox(base, relative3) {
   const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
   return `${normalizedBase}/${relative3}`;
 }
-async function uploadSkills(sandbox, inputs) {
+function discoverSkillMappings(inputs) {
   if (inputs.length === 0) return [];
   const discoveredByName = /* @__PURE__ */ new Map();
-  const filesToUpload = [];
   for (const { host, sandbox: sandboxBase } of inputs) {
     const absoluteHost = path3.resolve(expandHome2(host));
     for (const skill of discoverSkillsInDirectory(host)) {
@@ -5292,6 +6087,14 @@ async function uploadSkills(sandbox, inputs) {
         sandbox: joinSandbox(sandboxBase, relative3)
       });
     }
+  }
+  return Array.from(discoveredByName.values());
+}
+async function uploadSkills(sandbox, inputs) {
+  if (inputs.length === 0) return [];
+  const skills2 = discoverSkillMappings(inputs);
+  const filesToUpload = [];
+  for (const { host, sandbox: sandboxBase } of inputs) {
     const walked = await walkDirectory(host);
     for (const file of walked) {
       filesToUpload.push({
@@ -5303,7 +6106,7 @@ async function uploadSkills(sandbox, inputs) {
   if (filesToUpload.length > 0) {
     await sandbox.writeFiles(filesToUpload);
   }
-  return Array.from(discoveredByName.values());
+  return skills2;
 }
 
 // packages/context/src/lib/sandbox/bash-tool.ts
@@ -5339,7 +6142,16 @@ async function createBashTool(options = {}) {
         throw new Error("bash tool execution is not available");
       }
       return runWithBashMeta(async () => {
-        const result = await originalExecute({ command }, execOptions);
+        let result;
+        try {
+          result = await originalExecute({ command }, execOptions);
+        } catch (err) {
+          if (err instanceof BashException) {
+            result = err.format();
+          } else {
+            throw err;
+          }
+        }
         const state = readBashMeta();
         if (!state) return result;
         const hasHidden = Object.keys(state.hidden).length > 0;
@@ -5373,43 +6185,6 @@ async function createBashTool(options = {}) {
   };
 }
 
-// packages/context/src/lib/sandbox/extension.ts
-var DuplicateCommandError = class extends Error {
-  commandName;
-  constructor(commandName) {
-    super(`Duplicate extension command name: "${commandName}"`);
-    this.name = "DuplicateCommandError";
-    this.commandName = commandName;
-  }
-};
-function chainHooks(...hooks) {
-  return async (value) => {
-    let current = value;
-    for (const hook of hooks) {
-      current = await hook(current);
-    }
-    return current;
-  };
-}
-function mergeExtensions(...extensions) {
-  const commands = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const ext of extensions) {
-    for (const cmd of ext.commands ?? []) {
-      if (seen.has(cmd.name)) throw new DuplicateCommandError(cmd.name);
-      seen.add(cmd.name);
-      commands.push(cmd);
-    }
-  }
-  const hooks = extensions.map((e) => e.onBeforeBashCall).filter((h) => !!h);
-  return {
-    commands,
-    plugins: extensions.flatMap((e) => e.plugins ?? []),
-    env: Object.assign({}, ...extensions.map((e) => e.env ?? {})),
-    onBeforeBashCall: hooks.length > 0 ? chainHooks(...hooks) : void 0
-  };
-}
-
 // packages/context/src/lib/sandbox/file-events.ts
 var ObservedFs = class {
   #base;
@@ -5655,9 +6430,11 @@ function resolveRealCwd(ctx) {
 
 // packages/context/src/lib/sandbox/docker-sandbox.ts
 import "bash-tool";
-import spawn2 from "nano-spawn";
+import spawn3 from "nano-spawn";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+
+// packages/context/src/lib/sandbox/docker-sandbox-errors.ts
 var DockerSandboxError = class extends Error {
   containerId;
   constructor(message2, containerId) {
@@ -5699,19 +6476,33 @@ var PackageInstallError = class extends DockerSandboxError {
     this.stderr = stderr;
   }
 };
-var BinaryInstallError = class extends DockerSandboxError {
-  binaryName;
-  url;
+var InstallError = class extends DockerSandboxError {
+  target;
+  source;
   reason;
-  constructor(binaryName, url, reason, containerId) {
+  url;
+  constructor(opts) {
+    const where = opts.url ? `${opts.source} (${opts.url})` : opts.source;
     super(
-      `Failed to install binary "${binaryName}" from ${url}: ${reason}`,
-      containerId
+      `Failed to install "${opts.target}" via ${where}: ${opts.reason}`,
+      opts.containerId
     );
-    this.name = "BinaryInstallError";
-    this.binaryName = binaryName;
-    this.url = url;
-    this.reason = reason;
+    this.name = "InstallError";
+    this.target = opts.target;
+    this.source = opts.source;
+    this.reason = opts.reason;
+    this.url = opts.url;
+  }
+};
+var MissingRuntimeError = class extends DockerSandboxError {
+  runtime;
+  required;
+  constructor(runtime, required, details, containerId) {
+    const base = `Required runtime "${runtime}" is not installed (needs: ${required.join(", ")}).`;
+    super(details ? `${base} ${details}` : base, containerId);
+    this.name = "MissingRuntimeError";
+    this.runtime = runtime;
+    this.required = required;
   }
 };
 var MountPathError = class extends DockerSandboxError {
@@ -5744,12 +6535,108 @@ var ComposeStartError = class extends DockerSandboxError {
     this.stderr = stderr;
   }
 };
+
+// packages/context/src/lib/sandbox/installers/installer.ts
+import "bash-tool";
+import spawn2 from "nano-spawn";
+var Installer = class {
+};
 function isDebianBased(image) {
   const lower = image.toLowerCase();
   if (lower.includes("alpine")) return false;
   const debianPatterns = ["debian", "ubuntu", "node", "python"];
   return debianPatterns.some((pattern) => lower.includes(pattern));
 }
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function createInstallerContext(containerId, image) {
+  const packageManager = isDebianBased(image) ? "apt-get" : "apk";
+  let archPromise = null;
+  const ensuredTools = /* @__PURE__ */ new Set();
+  let aptUpdated = false;
+  const exec = async (command) => {
+    try {
+      const result = await spawn2("docker", [
+        "exec",
+        containerId,
+        "sh",
+        "-c",
+        command
+      ]);
+      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+    } catch (error) {
+      const err = error;
+      return {
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message ?? "",
+        exitCode: err.exitCode ?? 1
+      };
+    }
+  };
+  const arch = async () => {
+    if (!archPromise) {
+      const attempt = (async () => {
+        const result = await exec("uname -m");
+        if (result.exitCode !== 0) {
+          throw new DockerSandboxError(
+            `Failed to detect container architecture: ${result.stderr}`,
+            containerId
+          );
+        }
+        return result.stdout.trim();
+      })();
+      archPromise = attempt.catch((err) => {
+        archPromise = null;
+        throw err;
+      });
+    }
+    return archPromise;
+  };
+  const installPackages = async (packages) => {
+    if (packages.length === 0) return;
+    const quoted = packages.map(shellQuote).join(" ");
+    let cmd;
+    if (packageManager === "apt-get") {
+      cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
+    } else {
+      cmd = `apk add --no-cache ${quoted}`;
+    }
+    const result = await exec(cmd);
+    if (result.exitCode !== 0) {
+      throw new PackageInstallError(
+        packages,
+        image,
+        packageManager,
+        result.stderr,
+        containerId
+      );
+    }
+    if (packageManager === "apt-get") aptUpdated = true;
+  };
+  const ensureTool = async (checkName, installName) => {
+    const cacheKey = installName ?? checkName;
+    if (ensuredTools.has(cacheKey)) return;
+    const check = await exec(`which ${shellQuote(checkName)}`);
+    if (check.exitCode === 0) {
+      ensuredTools.add(cacheKey);
+      return;
+    }
+    await installPackages([installName ?? checkName]);
+    ensuredTools.add(cacheKey);
+  };
+  return {
+    containerId,
+    image,
+    packageManager,
+    arch,
+    exec,
+    installPackages,
+    ensureTool
+  };
+}
+
+// packages/context/src/lib/sandbox/docker-sandbox.ts
 function isDockerfileOptions(opts) {
   return "dockerfile" in opts;
 }
@@ -5761,7 +6648,8 @@ var DockerSandboxStrategy = class {
   mounts;
   resources;
   env;
-  constructor(mounts = [], resources = {}, env = {}) {
+  constructor(args = {}) {
+    const { mounts = [], resources = {}, env = {} } = args;
     for (const key of Object.keys(env)) {
       if (key.length === 0 || key.includes("=")) {
         throw new DockerSandboxError(
@@ -5773,16 +6661,6 @@ var DockerSandboxStrategy = class {
     this.resources = resources;
     this.env = env;
   }
-  /**
-   * Template method - defines the algorithm skeleton for creating a sandbox.
-   *
-   * Steps:
-   * 1. Validate mount paths exist on host
-   * 2. Get/build the Docker image (strategy-specific)
-   * 3. Start the container
-   * 4. Configure the container (strategy-specific)
-   * 5. Create and return sandbox methods
-   */
   async create() {
     this.validateMounts();
     const image = await this.getImage();
@@ -5796,12 +6674,6 @@ var DockerSandboxStrategy = class {
     }
     return this.createSandboxMethods();
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Common implementations (shared by all strategies)
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Validates that all mount paths exist on the host filesystem.
-   */
   validateMounts() {
     for (const mount of this.mounts) {
       if (!existsSync3(mount.hostPath)) {
@@ -5809,24 +6681,18 @@ var DockerSandboxStrategy = class {
       }
     }
   }
-  /**
-   * Builds the docker run command arguments.
-   */
   buildDockerArgs(image, containerId) {
     const { memory = "1g", cpus = 2 } = this.resources;
     const args = [
       "run",
       "-d",
-      // Detached mode
       "--rm",
-      // Remove container when stopped
       "--name",
       containerId,
       `--memory=${memory}`,
       `--cpus=${cpus}`,
       "-w",
       "/workspace"
-      // Set working directory
     ];
     for (const [key, value] of Object.entries(this.env)) {
       args.push("-e", `${key}=${value}`);
@@ -5838,14 +6704,11 @@ var DockerSandboxStrategy = class {
     args.push(image, "tail", "-f", "/dev/null");
     return args;
   }
-  /**
-   * Starts a Docker container with the given image.
-   */
   async startContainer(image) {
     const containerId = `sandbox-${crypto.randomUUID().slice(0, 8)}`;
     const args = this.buildDockerArgs(image, containerId);
     try {
-      await spawn2("docker", args);
+      await spawn3("docker", args);
     } catch (error) {
       const err = error;
       if (err.message?.includes("Cannot connect") || err.message?.includes("docker daemon") || err.stderr?.includes("Cannot connect")) {
@@ -5855,21 +6718,15 @@ var DockerSandboxStrategy = class {
     }
     return containerId;
   }
-  /**
-   * Stops a Docker container.
-   */
   async stopContainer(containerId) {
     try {
-      await spawn2("docker", ["stop", containerId]);
+      await spawn3("docker", ["stop", containerId]);
     } catch {
     }
   }
-  /**
-   * Executes a command in the container.
-   */
   async exec(command) {
     try {
-      const result = await spawn2("docker", [
+      const result = await spawn3("docker", [
         "exec",
         this.context.containerId,
         "sh",
@@ -5890,9 +6747,6 @@ var DockerSandboxStrategy = class {
       };
     }
   }
-  /**
-   * Creates the DockerSandbox interface with all methods.
-   */
   createSandboxMethods() {
     const { containerId } = this.context;
     const sandbox = {
@@ -5932,229 +6786,64 @@ var DockerSandboxStrategy = class {
 };
 var RuntimeStrategy = class extends DockerSandboxStrategy {
   image;
-  packages;
-  binaries;
-  constructor(image = "alpine:latest", packages = [], binaries = [], mounts, resources, env) {
-    super(mounts, resources, env);
-    this.image = image;
-    this.packages = packages;
-    this.binaries = binaries;
+  installers;
+  constructor(args = {}) {
+    super({ mounts: args.mounts, resources: args.resources, env: args.env });
+    this.image = args.image ?? "alpine:latest";
+    this.installers = args.installers ?? [];
   }
   async getImage() {
     return this.image;
   }
   async configure() {
-    await this.installPackages();
-    await this.installBinaries();
+    const ctx = createInstallerContext(this.context.containerId, this.image);
+    for (const installer of this.installers) {
+      await installer.install(ctx);
+    }
   }
-  /**
-   * Installs packages using the appropriate package manager (apk/apt-get).
-   */
-  async installPackages() {
-    if (this.packages.length === 0) return;
-    const useApt = isDebianBased(this.image);
-    const installCmd = useApt ? `apt-get update && apt-get install -y ${this.packages.join(" ")}` : `apk add --no-cache ${this.packages.join(" ")}`;
-    try {
-      await spawn2("docker", [
-        "exec",
-        this.context.containerId,
-        "sh",
-        "-c",
-        installCmd
-      ]);
-    } catch (error) {
-      const err = error;
-      throw new PackageInstallError(
-        this.packages,
-        this.image,
-        useApt ? "apt-get" : "apk",
-        err.stderr || err.message,
-        this.context.containerId
-      );
+};
+var DockerfileStrategy = class extends DockerSandboxStrategy {
+  imageTag;
+  dockerfile;
+  dockerContext;
+  constructor(args) {
+    super({ mounts: args.mounts, resources: args.resources, env: args.env });
+    this.dockerfile = args.dockerfile;
+    this.dockerContext = args.context ?? ".";
+    this.imageTag = this.computeImageTag();
+  }
+  computeImageTag() {
+    const content = this.isInlineDockerfile() ? this.dockerfile : readFileSync2(this.dockerfile, "utf-8");
+    const hash = createHash("sha256").update(content).digest("hex").slice(0, 12);
+    return `sandbox-${hash}`;
+  }
+  isInlineDockerfile() {
+    return this.dockerfile.includes("\n");
+  }
+  async getImage() {
+    const exists = await this.imageExists();
+    if (!exists) {
+      await this.buildImage();
     }
+    return this.imageTag;
   }
-  /**
-   * Installs binaries from URLs.
-   */
-  async installBinaries() {
-    if (this.binaries.length === 0) return;
-    await this.ensureCurl();
-    const arch = await this.detectArchitecture();
-    for (const binary of this.binaries) {
-      await this.installBinary(binary, arch);
+  async configure() {
+  }
+  async imageExists() {
+    try {
+      await spawn3("docker", ["image", "inspect", this.imageTag]);
+      return true;
+    } catch {
+      return false;
     }
   }
-  /**
-   * Ensures curl is installed in the container.
-   */
-  async ensureCurl() {
-    const checkResult = await spawn2("docker", [
-      "exec",
-      this.context.containerId,
-      "which",
-      "curl"
-    ]).catch(() => null);
-    if (checkResult) return;
-    const useApt = isDebianBased(this.image);
-    const curlInstallCmd = useApt ? "apt-get update && apt-get install -y curl" : "apk add --no-cache curl";
-    try {
-      await spawn2("docker", [
-        "exec",
-        this.context.containerId,
-        "sh",
-        "-c",
-        curlInstallCmd
-      ]);
-    } catch (error) {
-      const err = error;
-      throw new BinaryInstallError(
-        "curl",
-        "package-manager",
-        `Required for binary downloads: ${err.stderr || err.message}`,
-        this.context.containerId
-      );
-    }
-  }
-  /**
-   * Detects the container's CPU architecture.
-   */
-  async detectArchitecture() {
-    try {
-      const result = await spawn2("docker", [
-        "exec",
-        this.context.containerId,
-        "uname",
-        "-m"
-      ]);
-      return result.stdout.trim();
-    } catch (error) {
-      const err = error;
-      throw new DockerSandboxError(
-        `Failed to detect container architecture: ${err.stderr || err.message}`,
-        this.context.containerId
-      );
-    }
-  }
-  /**
-   * Installs a single binary from URL.
-   */
-  async installBinary(binary, arch) {
-    let url;
-    if (typeof binary.url === "string") {
-      url = binary.url;
-    } else {
-      const archUrl = binary.url[arch];
-      if (!archUrl) {
-        throw new BinaryInstallError(
-          binary.name,
-          `arch:${arch}`,
-          `No URL provided for architecture "${arch}". Available: ${Object.keys(binary.url).join(", ")}`,
-          this.context.containerId
-        );
-      }
-      url = archUrl;
-    }
-    const isTarGz = url.endsWith(".tar.gz") || url.endsWith(".tgz");
-    let installCmd;
-    if (isTarGz) {
-      const binaryPathInArchive = binary.binaryPath || binary.name;
-      installCmd = `
-        set -e
-        TMPDIR=$(mktemp -d)
-        cd "$TMPDIR"
-        curl -fsSL "${url}" -o archive.tar.gz
-        tar -xzf archive.tar.gz
-        BINARY_FILE=$(find . -name "${binaryPathInArchive}" -o -name "${binary.name}" | head -1)
-        if [ -z "$BINARY_FILE" ]; then
-          echo "Binary not found in archive. Contents:" >&2
-          find . -type f >&2
-          exit 1
-        fi
-        chmod +x "$BINARY_FILE"
-        mv "$BINARY_FILE" /usr/local/bin/${binary.name}
-        cd /
-        rm -rf "$TMPDIR"
-      `;
-    } else {
-      installCmd = `
-        curl -fsSL "${url}" -o /usr/local/bin/${binary.name}
-        chmod +x /usr/local/bin/${binary.name}
-      `;
-    }
-    try {
-      await spawn2("docker", [
-        "exec",
-        this.context.containerId,
-        "sh",
-        "-c",
-        installCmd
-      ]);
-    } catch (error) {
-      const err = error;
-      throw new BinaryInstallError(
-        binary.name,
-        url,
-        err.stderr || err.message,
-        this.context.containerId
-      );
-    }
-  }
-};
-var DockerfileStrategy = class extends DockerSandboxStrategy {
-  imageTag;
-  dockerfile;
-  dockerContext;
-  constructor(dockerfile, dockerContext = ".", mounts, resources, env) {
-    super(mounts, resources, env);
-    this.dockerfile = dockerfile;
-    this.dockerContext = dockerContext;
-    this.imageTag = this.computeImageTag();
-  }
-  /**
-   * Computes a deterministic image tag based on Dockerfile content.
-   * Same Dockerfile → same tag → Docker skips rebuild if image exists.
-   */
-  computeImageTag() {
-    const content = this.isInlineDockerfile() ? this.dockerfile : readFileSync2(this.dockerfile, "utf-8");
-    const hash = createHash("sha256").update(content).digest("hex").slice(0, 12);
-    return `sandbox-${hash}`;
-  }
-  /**
-   * Checks if the dockerfile property is inline content or a file path.
-   */
-  isInlineDockerfile() {
-    return this.dockerfile.includes("\n");
-  }
-  async getImage() {
-    const exists = await this.imageExists();
-    if (!exists) {
-      await this.buildImage();
-    }
-    return this.imageTag;
-  }
-  async configure() {
-  }
-  /**
-   * Checks if the image already exists locally.
-   */
-  async imageExists() {
-    try {
-      await spawn2("docker", ["image", "inspect", this.imageTag]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Builds the Docker image from the Dockerfile.
-   */
-  async buildImage() {
+  async buildImage() {
     try {
       if (this.isInlineDockerfile()) {
         const buildCmd = `echo '${this.dockerfile.replace(/'/g, "'\\''")}' | docker build -t ${this.imageTag} -f - ${this.dockerContext}`;
-        await spawn2("sh", ["-c", buildCmd]);
+        await spawn3("sh", ["-c", buildCmd]);
       } else {
-        await spawn2("docker", [
+        await spawn3("docker", [
           "build",
           "-t",
           this.imageTag,
@@ -6173,33 +6862,23 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   projectName;
   composeFile;
   service;
-  constructor(composeFile, service, resources) {
-    super([], resources);
-    this.composeFile = composeFile;
-    this.service = service;
+  constructor(args) {
+    super({ resources: args.resources });
+    this.composeFile = args.compose;
+    this.service = args.service;
     this.projectName = this.computeProjectName();
   }
-  /**
-   * Deterministic project name based on compose file content for caching.
-   * Same compose file → same project name → faster subsequent startups.
-   */
   computeProjectName() {
     const content = readFileSync2(this.composeFile, "utf-8");
     const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
     return `sandbox-${hash}`;
   }
-  /**
-   * Override: No image to get - compose manages its own images.
-   */
   async getImage() {
     return "";
   }
-  /**
-   * Override: Start all services with docker compose up.
-   */
   async startContainer(_image) {
     try {
-      await spawn2("docker", [
+      await spawn3("docker", [
         "compose",
         "-f",
         this.composeFile,
@@ -6219,12 +6898,9 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   }
   async configure() {
   }
-  /**
-   * Override: Execute commands in the target service.
-   */
   async exec(command) {
     try {
-      const result = await spawn2("docker", [
+      const result = await spawn3("docker", [
         "compose",
         "-f",
         this.composeFile,
@@ -6232,7 +6908,6 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
         this.projectName,
         "exec",
         "-T",
-        // -T disables pseudo-TTY
         this.service,
         "sh",
         "-c",
@@ -6248,12 +6923,9 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
       };
     }
   }
-  /**
-   * Override: Stop all services with docker compose down.
-   */
   async stopContainer(_containerId) {
     try {
-      await spawn2("docker", [
+      await spawn3("docker", [
         "compose",
         "-f",
         this.composeFile,
@@ -6268,28 +6940,27 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
 async function createDockerSandbox(options = {}) {
   let strategy;
   if (isComposeOptions(options)) {
-    strategy = new ComposeStrategy(
-      options.compose,
-      options.service,
-      options.resources
-    );
+    strategy = new ComposeStrategy({
+      compose: options.compose,
+      service: options.service,
+      resources: options.resources
+    });
   } else if (isDockerfileOptions(options)) {
-    strategy = new DockerfileStrategy(
-      options.dockerfile,
-      options.context,
-      options.mounts,
-      options.resources,
-      options.env
-    );
+    strategy = new DockerfileStrategy({
+      dockerfile: options.dockerfile,
+      context: options.context,
+      mounts: options.mounts,
+      resources: options.resources,
+      env: options.env
+    });
   } else {
-    strategy = new RuntimeStrategy(
-      options.image,
-      options.packages,
-      options.binaries,
-      options.mounts,
-      options.resources,
-      options.env
-    );
+    strategy = new RuntimeStrategy({
+      image: options.image,
+      installers: options.installers,
+      mounts: options.mounts,
+      resources: options.resources,
+      env: options.env
+    });
   }
   return strategy.create();
 }
@@ -6328,15 +6999,14 @@ async function createContainerTool(options = {}) {
   } else {
     const {
       image,
-      packages,
-      binaries,
+      installers,
       mounts,
       resources,
       env,
       skills: skills2 = [],
       ...rest
     } = options;
-    sandboxOptions = { image, packages, binaries, mounts, resources, env };
+    sandboxOptions = { image, installers, mounts, resources, env };
     bashOptions = rest;
     skillInputs = skills2;
   }
@@ -6354,215 +7024,252 @@ async function createContainerTool(options = {}) {
   };
 }
 
-// packages/context/src/lib/sandbox/routing-sandbox.ts
-import {
-  Bash,
-  defineCommand as defineCommand2,
-  parse
-} from "just-bash";
-function isInstallable(s) {
-  return typeof s.install === "function";
-}
-async function createVirtualSandbox(options) {
-  let bash = null;
-  const ensureInstalled = (op) => {
-    if (!bash) {
-      throw new Error(
-        `createVirtualSandbox: ${op} called before install(). Wrap this sandbox with createRoutingSandbox before use.`
-      );
-    }
-    return bash;
-  };
-  const sandbox = {
-    async install(ext) {
-      if (bash) {
-        throw new Error(
-          "createVirtualSandbox: install() called twice (extensions are install-once)"
-        );
-      }
-      const adapted = ext.commands.map(
-        (cmd) => adaptExtensionCommandForBash(cmd, () => sandbox)
-      );
-      bash = new Bash({
-        fs: options.fs,
-        cwd: options.cwd,
-        env: { ...options.env, ...ext.env },
-        customCommands: adapted
-      });
-      for (const plugin of ext.plugins) {
-        bash.registerTransformPlugin(plugin);
-      }
-    },
-    async executeCommand(command) {
-      const instance = ensureInstalled("executeCommand");
-      const result = await instance.exec(command);
-      return {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: result.exitCode
-      };
-    },
-    async readFile(path5) {
-      return ensureInstalled("readFile").readFile(path5);
-    },
-    async writeFiles(files) {
-      const instance = ensureInstalled("writeFiles");
-      for (const f of files) {
-        await instance.writeFile(
-          f.path,
-          typeof f.content === "string" ? f.content : Buffer.from(f.content).toString("utf-8")
-        );
-      }
-    }
-  };
-  return sandbox;
+// packages/context/src/lib/sandbox/installers/package-manager.ts
+var PackageInstaller = class extends Installer {
+  kind;
+  packages;
+  constructor(packages) {
+    super();
+    this.packages = packages;
+    this.kind = packages.length === 0 ? "pkg:<empty>" : `pkg:${packages.join(",")}`;
+  }
+  async install(ctx) {
+    if (this.packages.length === 0) return;
+    await ctx.installPackages([...this.packages]);
+  }
+};
+function pkg(packages) {
+  return new PackageInstaller(packages);
 }
-async function createRoutingSandbox(opts) {
-  const merged = mergeExtensions(...opts.hostExtensions);
-  if (isInstallable(opts.backend)) {
-    await opts.backend.install(merged);
-    return wrapPreCallHook(opts.backend, merged.onBeforeBashCall);
+
+// packages/context/src/lib/sandbox/installers/url-binary.ts
+var UrlBinaryInstaller = class extends Installer {
+  kind;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.kind = `url-binary:${options.name}`;
+  }
+  async install(ctx) {
+    const url = await resolveUrl(ctx, this.options);
+    await downloadAndInstall(
+      ctx,
+      this.options.name,
+      url,
+      this.options.binaryPath
+    );
+  }
+};
+function urlBinary(options) {
+  return new UrlBinaryInstaller(options);
+}
+async function resolveUrl(ctx, options) {
+  if (typeof options.url === "string") return options.url;
+  const arch = await ctx.arch();
+  const archUrl = options.url[arch];
+  if (!archUrl) {
+    throw new InstallError({
+      target: options.name,
+      source: "url",
+      reason: `No URL provided for architecture "${arch}". Available: ${Object.keys(options.url).join(", ")}`,
+      containerId: ctx.containerId
+    });
+  }
+  return archUrl;
+}
+async function downloadAndInstall(ctx, name, url, binaryPath, source = "url") {
+  await ctx.ensureTool("curl");
+  const isTarGz = url.endsWith(".tar.gz") || url.endsWith(".tgz");
+  const installCmd = isTarGz ? buildTarGzInstallCmd(name, url, binaryPath ?? name) : buildRawInstallCmd(name, url);
+  const result = await ctx.exec(installCmd);
+  if (result.exitCode !== 0) {
+    throw new InstallError({
+      target: name,
+      source,
+      url,
+      reason: result.stderr,
+      containerId: ctx.containerId
+    });
   }
-  return createShallowRouter(opts.backend, merged, opts.cwd ?? "/");
 }
-function wrapPreCallHook(backend, hook) {
-  if (!hook) return backend;
-  return {
-    executeCommand: async (raw) => {
-      const { command } = await hook({ command: raw });
-      return backend.executeCommand(command);
-    },
-    readFile: (path5) => backend.readFile(path5),
-    writeFiles: (files) => backend.writeFiles(files)
-  };
+function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
+  return `
+    set -e
+    NAME=${shellQuote(name)}
+    URL=${shellQuote(url)}
+    BIN_IN_ARCHIVE=${shellQuote(binaryPathInArchive)}
+    TMPDIR=$(mktemp -d)
+    cd "$TMPDIR"
+    curl -fsSL "$URL" -o archive.tar.gz
+    tar -xzf archive.tar.gz
+    BINARY_FILE=$(find . -name "$BIN_IN_ARCHIVE" -o -name "$NAME" | head -1)
+    if [ -z "$BINARY_FILE" ]; then
+      echo "Binary not found in archive. Contents:" >&2
+      find . -type f >&2
+      exit 1
+    fi
+    chmod +x "$BINARY_FILE"
+    mv "$BINARY_FILE" "/usr/local/bin/$NAME"
+    cd /
+    rm -rf "$TMPDIR"
+  `;
+}
+function buildRawInstallCmd(name, url) {
+  return `
+    NAME=${shellQuote(name)}
+    URL=${shellQuote(url)}
+    curl -fsSL "$URL" -o "/usr/local/bin/$NAME"
+    chmod +x "/usr/local/bin/$NAME"
+  `;
 }
-function createShallowRouter(backend, ext, cwd) {
-  const byName = new Map(ext.commands.map((c) => [c.name, c]));
-  const transformer = new Bash({});
-  for (const plugin of ext.plugins) {
-    transformer.registerTransformPlugin(plugin);
-  }
-  return {
-    readFile: (path5) => backend.readFile(path5),
-    writeFiles: (files) => backend.writeFiles(files),
-    executeCommand: async (raw) => {
-      const preHook = ext.onBeforeBashCall ? (await ext.onBeforeBashCall({ command: raw })).command : raw;
-      let transformed;
-      let dispatch;
-      try {
-        transformed = ext.plugins.length > 0 ? transformer.transform(preHook).script : preHook;
-        dispatch = extractDispatchTarget(parse(transformed), cwd);
-      } catch (err) {
-        return {
-          stdout: "",
-          stderr: `parse error: ${err.message}
-`,
-          exitCode: 2
-        };
-      }
-      const [name, ...args] = dispatch?.tokens ?? [];
-      const cmd = name ? byName.get(name) : void 0;
-      if (cmd) {
-        return cmd.handler(args, {
-          sandbox: backend,
-          cwd: dispatch?.cwd ?? cwd,
-          env: ext.env,
-          stdin: ""
-        });
-      }
-      return backend.executeCommand(transformed);
+
+// packages/context/src/lib/sandbox/installers/npm.ts
+var NODE_BINARIES = ["node", "npm"];
+var ENSURE_RUNTIME_HINT = "Pass `{ ensureRuntime: true }` to auto-install, or add it via `pkg([...])`.";
+var NpmInstaller = class extends Installer {
+  kind;
+  packageName;
+  options;
+  constructor(packageName, options = {}) {
+    super();
+    this.packageName = packageName;
+    this.options = options;
+    this.kind = `npm:${packageName}`;
+  }
+  async install(ctx) {
+    await ensureNodeRuntime(ctx, this.options.ensureRuntime ?? false);
+    const spec = this.options.version ? `${this.packageName}@${this.options.version}` : this.packageName;
+    const result = await ctx.exec(`npm install -g ${spec}`);
+    if (result.exitCode !== 0) {
+      throw new InstallError({
+        target: this.packageName,
+        source: "npm",
+        reason: result.stderr,
+        containerId: ctx.containerId
+      });
     }
-  };
-}
-function extractDispatchTarget(ast, defaultCwd) {
-  if (ast.statements.length !== 1) return null;
-  const statement = ast.statements[0];
-  if (statement.background) return null;
-  if (statement.operators.length === 0 && statement.pipelines.length === 1) {
-    const tokens = tokenizeSimplePipeline(statement.pipelines[0]);
-    return tokens ? { tokens, cwd: defaultCwd } : null;
-  }
-  if (statement.operators.length === 1 && statement.operators[0] === "&&" && statement.pipelines.length === 2) {
-    const cd = simpleCommandFromPipeline(statement.pipelines[0]);
-    const cdCwd = readCdTarget(cd);
-    if (!cdCwd) return null;
-    const tokens = tokenizeSimplePipeline(statement.pipelines[1]);
-    return tokens ? { tokens, cwd: cdCwd } : null;
   }
-  return null;
+};
+function npm(packageName, options) {
+  return new NpmInstaller(packageName, options);
 }
-function simpleCommandFromPipeline(pipeline) {
-  if (!pipeline) return null;
-  if (pipeline.negated || pipeline.timed || pipeline.commands.length !== 1) {
-    return null;
+async function ensureNodeRuntime(ctx, ensure) {
+  if (ensure) {
+    await ctx.ensureTool("node", "nodejs");
+    await ctx.ensureTool("npm");
+    return;
+  }
+  const check = await ctx.exec("which node && which npm");
+  if (check.exitCode !== 0) {
+    throw new MissingRuntimeError(
+      "npm",
+      NODE_BINARIES,
+      ENSURE_RUNTIME_HINT,
+      ctx.containerId
+    );
   }
-  const command = pipeline.commands[0];
-  return command?.type === "SimpleCommand" ? command : null;
 }
-function readCdTarget(command) {
-  if (!command) return null;
-  if (command.redirections.length > 0 || command.args.length !== 1) {
-    return null;
+
+// packages/context/src/lib/sandbox/installers/pip.ts
+var PYTHON_BINARIES = ["python3", "pip3"];
+var PipInstaller = class extends Installer {
+  kind;
+  packageName;
+  options;
+  constructor(packageName, options = {}) {
+    super();
+    this.packageName = packageName;
+    this.options = options;
+    this.kind = `pip:${packageName}`;
+  }
+  async install(ctx) {
+    await ensurePythonRuntime(ctx, this.options.ensureRuntime ?? false);
+    const spec = this.options.version ? `${this.packageName}${formatVersion(this.options.version)}` : this.packageName;
+    const flags = this.options.breakSystemPackages ?? true ? "--break-system-packages" : "";
+    const result = await ctx.exec(`pip3 install ${flags} ${spec}`.trim());
+    if (result.exitCode !== 0) {
+      throw new InstallError({
+        target: this.packageName,
+        source: "pypi",
+        reason: result.stderr,
+        containerId: ctx.containerId
+      });
+    }
+  }
+};
+function pip(packageName, options) {
+  return new PipInstaller(packageName, options);
+}
+async function ensurePythonRuntime(ctx, ensure) {
+  if (ensure) {
+    const pipPackage = ctx.packageManager === "apk" ? "py3-pip" : "python3-pip";
+    await ctx.ensureTool("python3");
+    await ctx.ensureTool("pip3", pipPackage);
+    return;
+  }
+  const check = await ctx.exec("which python3 && which pip3");
+  if (check.exitCode !== 0) {
+    throw new MissingRuntimeError(
+      "pip",
+      PYTHON_BINARIES,
+      "Pass `{ ensureRuntime: true }` to auto-install, or add via `pkg([...])` (Alpine: `python3 py3-pip`; Debian: `python3 python3-pip`).",
+      ctx.containerId
+    );
   }
-  const name = asStaticWordText(command.name);
-  if (name !== "cd") return null;
-  return asStaticWordText(command.args[0]);
-}
-function tokenizeSimplePipeline(pipeline) {
-  const command = simpleCommandFromPipeline(pipeline);
-  if (!command || command.redirections.length > 0) return null;
-  const name = asStaticWordText(command.name);
-  if (!name) return null;
-  const args = [];
-  for (const arg of command.args) {
-    const text = asStaticWordText(arg);
-    if (text == null) return null;
-    args.push(text);
-  }
-  return [name, ...args];
-}
-function adaptExtensionCommandForBash(ext, getSandbox) {
-  return defineCommand2(ext.name, async (args, bashCtx) => {
-    return ext.handler(args, {
-      sandbox: getSandbox(),
-      cwd: bashCtx.cwd,
-      env: Object.fromEntries(bashCtx.env),
-      stdin: bashCtx.stdin,
-      signal: bashCtx.signal
-    });
-  });
+}
+function formatVersion(version) {
+  return /^[<>=!~]/.test(version) ? version : `==${version}`;
 }
 
-// packages/context/src/lib/sandbox/openapi/extension.ts
-import { rpc } from "@sdk-it/rpc";
-import {
-  forEachOperation,
-  loadSpec,
-  toIR
-} from "@sdk-it/spec";
+// packages/context/src/lib/sandbox/installers/github-release.ts
+var GithubReleaseInstaller = class extends Installer {
+  kind;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.kind = `github-release:${options.owner}/${options.repo}@${options.version}`;
+  }
+  async install(ctx) {
+    const arch = await ctx.arch();
+    const assetName = this.options.asset(arch);
+    const url = `https://github.com/${this.options.owner}/${this.options.repo}/releases/download/${this.options.version}/${assetName}`;
+    await downloadAndInstall(
+      ctx,
+      this.options.name,
+      url,
+      this.options.binaryPath,
+      "github-release"
+    );
+  }
+};
+function githubRelease(options) {
+  return new GithubReleaseInstaller(options);
+}
 
 // packages/context/src/lib/sandbox/subcommand.ts
-import { parse as parse2 } from "just-bash";
+import {
+  defineCommand as defineCommand2,
+  parse
+} from "just-bash";
 function defineSubcommandGroup(name, subcommands) {
   const usageLines = Object.entries(subcommands).map(([, def]) => `  ${name} ${def.usage.padEnd(30)} ${def.description}`).join("\n");
-  return {
-    name,
-    handler: async (args, ctx) => {
-      const subcommand = args[0];
-      const restArgs = args.slice(1);
-      if (subcommand && subcommand in subcommands) {
-        return subcommands[subcommand].handler(restArgs, ctx);
-      }
-      return {
-        stdout: "",
-        stderr: `${name}: ${subcommand ? `unknown subcommand '${subcommand}'` : "missing subcommand"}
+  return defineCommand2(name, async (args, ctx) => {
+    const subcommand = args[0];
+    const restArgs = args.slice(1);
+    if (subcommand && subcommand in subcommands) {
+      return subcommands[subcommand].handler(restArgs, ctx);
+    }
+    return {
+      stdout: "",
+      stderr: `${name}: ${subcommand ? `unknown subcommand '${subcommand}'` : "missing subcommand"}
 
 Usage:
 ${usageLines}`,
-        exitCode: 1
-      };
-    }
-  };
+      exitCode: 1
+    };
+  });
 }
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -6593,7 +7300,7 @@ function buildSubcommandRepair(name, subcommands) {
     const match = raw.match(pattern);
     if (!match) return raw;
     try {
-      parse2(raw);
+      parse(raw);
       return raw;
     } catch {
     }
@@ -6605,7 +7312,7 @@ function buildSubcommandRepair(name, subcommands) {
     if (repairedArgs == null) return raw;
     const repaired = `${prefix} ${repairedArgs}`;
     try {
-      parse2(repaired);
+      parse(repaired);
       return repaired;
     } catch {
       return raw;
@@ -6613,294 +7320,51 @@ function buildSubcommandRepair(name, subcommands) {
   };
 }
 
-// packages/context/src/lib/sandbox/openapi/format.ts
-function formatResponse(value) {
-  const payload = unwrapApiResponse(value);
-  if (Array.isArray(payload)) {
-    const stdout = payload.length === 0 ? "" : payload.map((item) => JSON.stringify(item)).join("\n") + "\n";
-    return { stdout, stderr: "", exitCode: 0 };
-  }
-  return { stdout: JSON.stringify(payload) + "\n", stderr: "", exitCode: 0 };
-}
-function unwrapApiResponse(value) {
-  if (value !== null && typeof value === "object" && "status" in value && "data" in value) {
-    return value.data;
-  }
-  return value;
-}
-function formatError(details) {
-  const payload = { ...details.extra ?? {} };
-  payload.ok = false;
-  payload.group = details.group;
-  payload.code = details.code;
-  payload.message = details.message;
-  if (details.operation) payload.operation = details.operation;
-  return {
-    stdout: "",
-    stderr: JSON.stringify(payload) + "\n",
-    exitCode: 1
-  };
-}
-
-// packages/context/src/lib/sandbox/openapi/schema.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-function buildSchemaSubcommand(group, client, entries) {
+// packages/context/src/lib/sandbox/virtual-sandbox.ts
+import { Bash } from "just-bash";
+async function createVirtualSandbox(options) {
+  const bash = new Bash({
+    fs: options.fs,
+    cwd: options.cwd,
+    env: options.env,
+    customCommands: options.customCommands
+  });
   return {
-    usage: "schema",
-    description: "Dump JSON Schema for every operation in this group.",
-    handler: async () => {
-      try {
-        const operations = entries.map((entry) => {
-          const [method, path5] = entry.endpoint.split(" ");
-          const zodSchema = client.schemas[entry.endpoint]?.schema;
-          const input = zodSchema ? zodToJsonSchema(zodSchema, {
-            target: "jsonSchema7",
-            $refStrategy: "none"
-          }) : {};
-          return entry.summary ? {
-            operationId: entry.operationId,
-            method,
-            path: path5,
-            summary: entry.summary,
-            input
-          } : { operationId: entry.operationId, method, path: path5, input };
-        });
-        return formatResponse({ group, operations });
-      } catch (error) {
-        return formatError({
-          group,
-          operation: "schema",
-          code: "schema_dump_failed",
-          message: error instanceof Error ? error.message : String(error)
-        });
+    async executeCommand(command) {
+      const result = await bash.exec(command);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode
+      };
+    },
+    async readFile(path5) {
+      return bash.readFile(path5);
+    },
+    async writeFiles(files) {
+      for (const file of files) {
+        await bash.writeFile(
+          file.path,
+          typeof file.content === "string" ? file.content : Buffer.from(file.content).toString("utf-8")
+        );
       }
     }
   };
 }
 
-// packages/context/src/lib/sandbox/openapi/validate.ts
-function extractPathParams(path5) {
-  const names = [];
-  const re = /{([^}]+)}/g;
-  let match;
-  while ((match = re.exec(path5)) !== null) {
-    names.push(match[1]);
-  }
-  return names;
-}
-var UNSAFE_CHARS = /[/\\?#&]/;
-var CONTROL = /[\x00-\x1f\x7f]/;
-var PRE_ENCODED = /%[0-9a-fA-F]{2}/;
-function findUnsafePathParam(input, names) {
-  if (input === null || typeof input !== "object" || Array.isArray(input)) {
-    return null;
+// packages/context/src/lib/skills/fragments.ts
+import dedent from "dedent";
+function skills(sandbox) {
+  const mounts = sandbox.skills ?? [];
+  if (mounts.length === 0) {
+    return { name: "available_skills", data: [], metadata: { mounts: [] } };
   }
-  const record = input;
-  for (const name of names) {
-    const value = record[name];
-    if (typeof value !== "string") continue;
-    if (value.length === 0) {
-      return { field: name, reason: "is empty" };
-    }
-    if (value === "." || value === "..") {
-      return {
-        field: name,
-        reason: `resolves to '${value}' path segment`
-      };
-    }
-    const unsafeChar = value.match(UNSAFE_CHARS);
-    if (unsafeChar) {
-      return {
-        field: name,
-        reason: `contains disallowed character '${unsafeChar[0]}'`
-      };
-    }
-    if (CONTROL.test(value)) {
-      return { field: name, reason: "contains a control character" };
-    }
-    const encoded = value.match(PRE_ENCODED);
-    if (encoded) {
-      return {
-        field: name,
-        reason: `contains pre-encoded sequence '${encoded[0]}'`
-      };
-    }
-  }
-  return null;
-}
-
-// packages/context/src/lib/sandbox/openapi/extension.ts
-var RESERVED_SUBCOMMAND = "schema";
-function serializeError(err) {
-  if (err === null || err === void 0) return err;
-  if (typeof err !== "object") return String(err);
-  if (err instanceof Error) {
-    const out = {
-      name: err.name,
-      message: err.message
-    };
-    for (const key of Object.getOwnPropertyNames(err)) {
-      if (key === "stack") continue;
-      const value = err[key];
-      out[key] = key === "cause" ? serializeError(value) : value;
-    }
-    return out;
-  }
-  return err;
-}
-async function createOpenAPIExtension(options) {
-  const { name, openapi, includeOperation, ...clientOptions } = options;
-  const ir = toIR({
-    spec: await loadSpec(openapi),
-    responses: { flattenErrorResponses: true }
-  });
-  if ((ir.servers?.length ?? 0) === 0 && !clientOptions.baseUrl) {
-    throw new Error(
-      `createOpenAPIExtension("${name}"): openapi spec has no servers and no baseUrl was provided`
-    );
-  }
-  const planned = [];
-  const registered = /* @__PURE__ */ new Map();
-  forEachOperation(ir, (entry, operation) => {
-    if (includeOperation && !includeOperation(entry, operation)) return;
-    const subName = operation["x-fn-name"] || operation.operationId;
-    const endpoint = `${entry.method.toUpperCase()} ${entry.path}`;
-    if (!subName) {
-      throw new Error(
-        `createOpenAPIExtension("${name}"): operation ${endpoint} has no x-fn-name or operationId`
-      );
-    }
-    if (subName === RESERVED_SUBCOMMAND) {
-      throw new Error(
-        `createOpenAPIExtension("${name}"): operation name "${RESERVED_SUBCOMMAND}" is reserved for introspection`
-      );
-    }
-    const existing = registered.get(subName);
-    if (existing) {
-      throw new Error(
-        `createOpenAPIExtension("${name}"): duplicate subcommand "${subName}" (from ${existing} and ${endpoint})`
-      );
-    }
-    registered.set(subName, endpoint);
-    planned.push({
-      subName,
-      endpoint,
-      description: operation.summary || operation.description || endpoint,
-      summary: operation.summary,
-      pathParamNames: extractPathParams(entry.path)
-    });
-  });
-  if (planned.length === 0) {
-    throw new Error(
-      `createOpenAPIExtension("${name}"): no operations matched; spec has no operations or includeOperation filtered all of them out`
-    );
-  }
-  const client = await rpc(openapi, clientOptions);
-  const subcommands = {};
-  const schemaEntries = [];
-  for (const {
-    subName,
-    endpoint,
-    description,
-    summary,
-    pathParamNames
-  } of planned) {
-    const schema = client.schemas[endpoint]?.schema;
-    if (!schema) {
-      throw new Error(
-        `createOpenAPIExtension("${name}"): no input schema for ${endpoint}`
-      );
-    }
-    schemaEntries.push({ endpoint, operationId: subName, summary });
-    subcommands[subName] = {
-      usage: `${subName} '<json>'`,
-      description,
-      repair: repairQuotedArg,
-      handler: async (args, ctx) => {
-        const raw = args.join(" ").trim();
-        if (!raw) {
-          return formatError({
-            group: name,
-            operation: subName,
-            code: "missing_input",
-            message: "no input provided"
-          });
-        }
-        let input;
-        try {
-          input = JSON.parse(raw);
-        } catch (error) {
-          return formatError({
-            group: name,
-            operation: subName,
-            code: "invalid_json",
-            message: error instanceof Error ? error.message : String(error)
-          });
-        }
-        const parsed = schema.safeParse(input);
-        if (!parsed.success) {
-          return formatError({
-            group: name,
-            operation: subName,
-            code: "schema_validation",
-            message: parsed.error.message,
-            extra: { issues: parsed.error.issues }
-          });
-        }
-        const unsafe = findUnsafePathParam(parsed.data, pathParamNames);
-        if (unsafe) {
-          return formatError({
-            group: name,
-            operation: subName,
-            code: "path_param_unsafe",
-            message: `path parameter '${unsafe.field}' ${unsafe.reason}`,
-            extra: { field: unsafe.field }
-          });
-        }
-        try {
-          const response = await client.request(endpoint, parsed.data, {
-            signal: ctx.signal
-          });
-          return formatResponse(response);
-        } catch (error) {
-          return formatError({
-            group: name,
-            operation: subName,
-            code: "request_failed",
-            message: error instanceof Error ? error.message : String(error),
-            extra: { error: serializeError(error) }
-          });
-        }
-      }
-    };
-  }
-  subcommands[RESERVED_SUBCOMMAND] = buildSchemaSubcommand(
-    name,
-    client,
-    schemaEntries
-  );
-  const command = defineSubcommandGroup(name, subcommands);
-  const repair = buildSubcommandRepair(name, subcommands);
-  return {
-    commands: [command],
-    onBeforeBashCall: ({ command: raw }) => ({ command: repair(raw) }),
-    client
-  };
-}
-
-// packages/context/src/lib/skills/fragments.ts
-import dedent from "dedent";
-function skills(sandbox) {
-  const mounts = sandbox.skills ?? [];
-  if (mounts.length === 0) {
-    return { name: "available_skills", data: [], metadata: { mounts: [] } };
-  }
-  const skillFragments = mounts.map((mount) => ({
-    name: "skill",
-    data: {
-      name: mount.name,
-      path: mount.sandbox,
-      description: mount.description
+  const skillFragments = mounts.map((mount) => ({
+    name: "skill",
+    data: {
+      name: mount.name,
+      path: mount.sandbox,
+      description: mount.description
     }
   }));
   return {
@@ -8549,129 +9013,931 @@ async function persistedWriter(options) {
       }
     }
   }
-  const wrappedWriter = {
-    onError: writer.onError,
-    async write(part) {
-      await persistChunk(makeChunk(part));
-      writer.write(part);
-    },
-    merge(stream) {
-      const transform = new TransformStream({
-        async transform(chunk, controller) {
-          await persistChunk(makeChunk(chunk));
-          controller.enqueue(chunk);
-        }
-      });
-      writer.merge(stream.pipeThrough(transform));
+  const wrappedWriter = {
+    onError: writer.onError,
+    async write(part) {
+      await persistChunk(makeChunk(part));
+      writer.write(part);
+    },
+    merge(stream) {
+      const transform = new TransformStream({
+        async transform(chunk, controller) {
+          await persistChunk(makeChunk(chunk));
+          controller.enqueue(chunk);
+        }
+      });
+      writer.merge(stream.pipeThrough(transform));
+    }
+  };
+  return {
+    writer: wrappedWriter,
+    streamId,
+    flush,
+    async complete() {
+      await flush();
+      await store2.updateStreamStatus(streamId, "completed");
+    },
+    async fail(error) {
+      await flush();
+      await store2.updateStreamStatus(streamId, "failed", { error });
+    },
+    async cleanup() {
+      await store2.deleteStream(streamId);
+    }
+  };
+}
+
+// packages/context/src/lib/stream/polling-change-source.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// packages/context/src/lib/stream/polling-policy.ts
+var DEFAULT_WATCH_POLLING = {
+  minMs: 25,
+  maxMs: 500,
+  multiplier: 2,
+  jitterRatio: 0.15,
+  statusCheckEvery: 3
+};
+var DEFAULT_CANCEL_POLLING = {
+  minMs: 50,
+  maxMs: 500,
+  multiplier: 2,
+  jitterRatio: 0.15
+};
+function normalizeWatchPolling(polling, fallback = DEFAULT_WATCH_POLLING) {
+  const merged = {
+    ...fallback,
+    ...polling
+  };
+  const normalizedBase = normalizeAdaptivePolling(merged, fallback);
+  return {
+    ...normalizedBase,
+    statusCheckEvery: clampInt(merged.statusCheckEvery, 1, 1e4)
+  };
+}
+function normalizeCancelPolling(polling, fallback = DEFAULT_CANCEL_POLLING) {
+  return normalizeAdaptivePolling(polling, fallback);
+}
+function createAdaptivePollingState(config) {
+  return {
+    config,
+    currentMs: config.minMs
+  };
+}
+function resetAdaptivePolling(state) {
+  state.currentMs = state.config.minMs;
+}
+function nextAdaptivePollingDelay(state) {
+  const current = clampInt(
+    state.currentMs,
+    state.config.minMs,
+    state.config.maxMs
+  );
+  const delay2 = applyJitter(
+    current,
+    state.config.jitterRatio,
+    state.config.minMs,
+    state.config.maxMs
+  );
+  state.currentMs = clampInt(
+    Math.ceil(current * state.config.multiplier),
+    state.config.minMs,
+    state.config.maxMs
+  );
+  return delay2;
+}
+function normalizeAdaptivePolling(polling, fallback) {
+  const merged = {
+    ...fallback,
+    ...polling
+  };
+  const minMs = clampInt(merged.minMs, 1, 6e4);
+  const maxMs = clampInt(merged.maxMs, minMs, 6e4);
+  return {
+    minMs,
+    maxMs,
+    multiplier: clampFloat(merged.multiplier, 1, 10),
+    jitterRatio: clampFloat(merged.jitterRatio, 0, 1)
+  };
+}
+function applyJitter(value, jitterRatio, min, max) {
+  if (jitterRatio <= 0) return value;
+  const radius = value * jitterRatio;
+  const lowerBound = Math.max(0, value - radius);
+  const upperBound = value + radius;
+  const jittered = Math.round(
+    lowerBound + Math.random() * (upperBound - lowerBound)
+  );
+  return clampInt(jittered, min, max);
+}
+function clampInt(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.round(value)));
+}
+function clampFloat(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, value));
+}
+
+// packages/context/src/lib/stream/polling-change-source.ts
+var PollingChangeSource = class {
+  #reads;
+  #config;
+  #onPoll;
+  constructor(options) {
+    this.#reads = options.reads;
+    this.#config = normalizeWatchPolling(options.config, DEFAULT_WATCH_POLLING);
+    this.#onPoll = options.onPoll;
+  }
+  async *subscribe(streamId, signal) {
+    const initialStatus = await this.#reads.getStreamStatus(streamId);
+    if (initialStatus === void 0) {
+      throw new Error(`Stream "${streamId}" not found`);
+    }
+    yield { kind: "tick" };
+    if (isTerminal(initialStatus)) return;
+    const delayState = createAdaptivePollingState(this.#config);
+    let pollsSinceStatus = 0;
+    let lastStatus = initialStatus;
+    while (!signal.aborted) {
+      const delayMs = nextAdaptivePollingDelay(delayState);
+      this.#emit({ type: "idle", streamId, delayMs });
+      if (!await waitForDelay(delayMs, signal)) return;
+      pollsSinceStatus += 1;
+      const shouldCheckStatus = pollsSinceStatus >= this.#config.statusCheckEvery;
+      if (!shouldCheckStatus) {
+        yield { kind: "chunks" };
+        continue;
+      }
+      pollsSinceStatus = 0;
+      const status = await this.#reads.getStreamStatus(streamId);
+      this.#emit({
+        type: "poll",
+        streamId,
+        delayMs,
+        status: status ?? "missing"
+      });
+      if (status === void 0) {
+        yield { kind: "status" };
+        return;
+      }
+      if (status === "running" && lastStatus !== "running") {
+        resetAdaptivePolling(delayState);
+      }
+      lastStatus = status;
+      if (isTerminal(status)) {
+        yield { kind: "status" };
+        return;
+      }
+      yield { kind: "tick" };
+    }
+  }
+  #emit(event) {
+    if (!this.#onPoll) return;
+    try {
+      this.#onPoll(event);
+    } catch {
+    }
+  }
+};
+function isTerminal(status) {
+  return status !== "queued" && status !== "running";
+}
+function waitForDelay(ms, signal) {
+  return delay(ms, true, { signal }).catch((err) => {
+    if (signal.aborted) return false;
+    throw err;
+  });
+}
+
+// packages/context/src/lib/sandbox/ast-utils.ts
+import { serialize } from "just-bash";
+function asStaticWordText(word, options = {}) {
+  if (!word) {
+    return null;
+  }
+  return asStaticWordPartText(
+    word.parts,
+    options
+  );
+}
+function asStaticWordPartText(parts, options = {}) {
+  let text = "";
+  for (const part of parts) {
+    const type = part.type;
+    if (type === "Literal" || type === "SingleQuoted" || type === "Escaped") {
+      if (typeof part.value !== "string") {
+        return null;
+      }
+      text += part.value;
+      continue;
+    }
+    if (type === "DoubleQuoted") {
+      if (!Array.isArray(part.parts)) {
+        return null;
+      }
+      const inner = asStaticWordPartText(
+        part.parts,
+        options
+      );
+      if (inner == null) {
+        return null;
+      }
+      text += inner;
+      continue;
+    }
+    if (options.preserveLegacyBackticks && type === "CommandSubstitution" && part.legacy === true) {
+      text += "`" + serialize(part.body).trim() + "`";
+      continue;
+    }
+    return null;
+  }
+  return text;
+}
+
+// packages/context/src/lib/stream/postgres-notify-change-source.ts
+import { createRequire as createRequire3 } from "node:module";
+
+// packages/context/src/lib/stream/ddl.stream.postgres-notify.ts
+var DEFAULT_POSTGRES_STREAM_CHANGES_CHANNEL = "deepagents_stream_changes";
+function postgresStreamNotifyDDL(schema, channel = DEFAULT_POSTGRES_STREAM_CHANGES_CHANNEL) {
+  return `
+CREATE SCHEMA IF NOT EXISTS "${schema}";
+
+CREATE OR REPLACE FUNCTION "${schema}"."notify_stream_chunks_insert"()
+RETURNS TRIGGER AS $$
+DECLARE
+  changed_stream_id TEXT;
+BEGIN
+  FOR changed_stream_id IN
+    SELECT DISTINCT stream_id FROM new_rows
+  LOOP
+    PERFORM pg_notify(
+      '${channel}',
+      json_build_object(
+        'schema', TG_TABLE_SCHEMA,
+        'streamId', changed_stream_id,
+        'kind', 'chunks'
+      )::text
+    );
+  END LOOP;
+  RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "stream_chunks_notify_insert"
+AFTER INSERT ON "${schema}"."stream_chunks"
+REFERENCING NEW TABLE AS new_rows
+FOR EACH STATEMENT
+EXECUTE FUNCTION "${schema}"."notify_stream_chunks_insert"();
+
+CREATE OR REPLACE FUNCTION "${schema}"."notify_stream_status_update"()
+RETURNS TRIGGER AS $$
+BEGIN
+  IF OLD.status IS DISTINCT FROM NEW.status THEN
+    PERFORM pg_notify(
+      '${channel}',
+      json_build_object(
+        'schema', TG_TABLE_SCHEMA,
+        'streamId', NEW.id,
+        'kind', 'status'
+      )::text
+    );
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "streams_notify_status_update"
+AFTER UPDATE OF status ON "${schema}"."streams"
+FOR EACH ROW
+EXECUTE FUNCTION "${schema}"."notify_stream_status_update"();
+`;
+}
+
+// packages/context/src/lib/stream/postgres-notify-change-source.ts
+var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
+  #pool;
+  #schema;
+  #channel;
+  #ownsPool;
+  #listener;
+  #listenPromise;
+  #isInitialized = false;
+  #isClosing = false;
+  #isClosed = false;
+  #subscribers = /* @__PURE__ */ new Map();
+  #onNotification = (message2) => {
+    this.#handleNotification(message2);
+  };
+  #onListenerError = (error) => {
+    this.#failListener(error);
+  };
+  #onListenerEnd = () => {
+    if (!this.#isClosing) {
+      this.#failListener(
+        new Error("PostgreSQL stream notification listener ended")
+      );
+    }
+  };
+  constructor(options) {
+    const schema = options.schema ?? "public";
+    const channel = options.channel ?? DEFAULT_POSTGRES_STREAM_CHANGES_CHANNEL;
+    assertIdentifier(schema, "schema");
+    assertIdentifier(channel, "channel");
+    this.#schema = schema;
+    this.#channel = channel;
+    const pg = _PostgresNotifyChangeSource.#requirePg();
+    if (options.pool instanceof pg.Pool) {
+      this.#pool = options.pool;
+      this.#ownsPool = false;
+    } else {
+      this.#pool = typeof options.pool === "string" ? new pg.Pool({ connectionString: options.pool }) : new pg.Pool(options.pool);
+      this.#ownsPool = true;
+    }
+  }
+  static #requirePg() {
+    try {
+      const require2 = createRequire3(import.meta.url);
+      return require2("pg");
+    } catch {
+      throw new Error(
+        'PostgresNotifyChangeSource requires the "pg" package. Install it with: npm install pg'
+      );
+    }
+  }
+  async initialize() {
+    await this.#pool.query(
+      postgresStreamNotifyDDL(this.#schema, this.#channel)
+    );
+    this.#isInitialized = true;
+  }
+  async *subscribe(streamId, signal) {
+    this.#ensureInitialized();
+    this.#ensureOpen();
+    const queue = new ChangeQueue();
+    this.#addSubscriber(streamId, queue);
+    const cleanup = () => {
+      queue.close();
+      this.#removeSubscriber(streamId, queue);
+    };
+    signal.addEventListener("abort", cleanup, { once: true });
+    try {
+      await this.#ensureListening();
+      if (signal.aborted || this.#isClosed) return;
+      yield { kind: "tick" };
+      while (!signal.aborted && !this.#isClosed) {
+        const change = await queue.next(signal);
+        if (!change) return;
+        yield change;
+      }
+    } finally {
+      signal.removeEventListener("abort", cleanup);
+      cleanup();
+      await this.#releaseListenerIfIdle();
+    }
+  }
+  async close() {
+    if (this.#isClosed) return;
+    this.#isClosed = true;
+    this.#isClosing = true;
+    for (const subscribers of this.#subscribers.values()) {
+      for (const subscriber of subscribers) {
+        subscriber.close();
+      }
+    }
+    this.#subscribers.clear();
+    if (this.#listenPromise) {
+      try {
+        await this.#listenPromise;
+      } catch {
+      }
+    }
+    await this.#releaseListener();
+    if (this.#ownsPool) {
+      await this.#pool.end();
+    }
+  }
+  #ensureInitialized() {
+    if (!this.#isInitialized) {
+      throw new Error(
+        "PostgresNotifyChangeSource not initialized. Call await source.initialize() after construction."
+      );
+    }
+  }
+  #ensureOpen() {
+    if (this.#isClosed) {
+      throw new Error("PostgresNotifyChangeSource is closed.");
+    }
+  }
+  async #ensureListening() {
+    this.#ensureOpen();
+    if (this.#listener) return;
+    if (this.#listenPromise) return this.#listenPromise;
+    this.#listenPromise = (async () => {
+      const listener = await this.#pool.connect();
+      let success = false;
+      try {
+        listener.on("notification", this.#onNotification);
+        listener.on("error", this.#onListenerError);
+        listener.on("end", this.#onListenerEnd);
+        await listener.query(`LISTEN ${quoteIdentifier(this.#channel)}`);
+        if (this.#isClosed) {
+          return;
+        }
+        this.#listener = listener;
+        success = true;
+      } finally {
+        this.#listenPromise = void 0;
+        if (!success) {
+          listener.off("notification", this.#onNotification);
+          listener.off("error", this.#onListenerError);
+          listener.off("end", this.#onListenerEnd);
+          listener.release(true);
+        }
+      }
+    })();
+    return this.#listenPromise;
+  }
+  #handleNotification(message2) {
+    if (message2.channel !== this.#channel || !message2.payload) return;
+    const payload = parsePayload(message2.payload);
+    if (!payload) return;
+    if (payload.schema !== this.#schema) return;
+    if (payload.kind !== "chunks" && payload.kind !== "status") return;
+    const subscribers = this.#subscribers.get(payload.streamId);
+    if (!subscribers) return;
+    const change = payload.kind === "chunks" ? { kind: "chunks" } : { kind: "status" };
+    for (const subscriber of subscribers) {
+      subscriber.push(change);
+    }
+  }
+  #failListener(error) {
+    const listener = this.#listener;
+    this.#listener = void 0;
+    this.#listenPromise = void 0;
+    if (listener) {
+      listener.off("notification", this.#onNotification);
+      listener.off("error", this.#onListenerError);
+      listener.off("end", this.#onListenerEnd);
+      listener.release(error);
+    }
+    for (const subscribers of this.#subscribers.values()) {
+      for (const subscriber of subscribers) {
+        subscriber.fail(error);
+      }
+    }
+    this.#subscribers.clear();
+  }
+  async #releaseListenerIfIdle() {
+    if (this.#subscribers.size > 0) return;
+    await this.#releaseListener();
+  }
+  async #releaseListener() {
+    const listener = this.#listener;
+    if (!listener) return;
+    this.#listener = void 0;
+    listener.off("notification", this.#onNotification);
+    listener.off("error", this.#onListenerError);
+    listener.off("end", this.#onListenerEnd);
+    try {
+      await listener.query(`UNLISTEN ${quoteIdentifier(this.#channel)}`);
+    } finally {
+      listener.release();
+    }
+  }
+  #addSubscriber(streamId, subscriber) {
+    let subscribers = this.#subscribers.get(streamId);
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      this.#subscribers.set(streamId, subscribers);
+    }
+    subscribers.add(subscriber);
+  }
+  #removeSubscriber(streamId, subscriber) {
+    const subscribers = this.#subscribers.get(streamId);
+    if (!subscribers) return;
+    subscribers.delete(subscriber);
+    if (subscribers.size === 0) {
+      this.#subscribers.delete(streamId);
+    }
+  }
+};
+var ChangeQueue = class {
+  #values = [];
+  #waiters = /* @__PURE__ */ new Set();
+  #closed = false;
+  #error;
+  push(value) {
+    if (this.#closed) return;
+    const waiter = this.#waiters.values().next().value;
+    if (waiter) {
+      this.#waiters.delete(waiter);
+      waiter.resolve(value);
+      return;
+    }
+    this.#values.push(value);
+  }
+  fail(error) {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#error = error;
+    this.#values = [];
+    for (const waiter of this.#waiters) {
+      waiter.reject(error);
+    }
+    this.#waiters.clear();
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#values = [];
+    for (const waiter of this.#waiters) {
+      waiter.resolve(void 0);
+    }
+    this.#waiters.clear();
+  }
+  async next(signal) {
+    if (this.#error) throw this.#error;
+    if (this.#closed || signal.aborted) return void 0;
+    if (this.#values.length > 0) {
+      return this.#values.shift();
+    }
+    return new Promise((resolve4, reject) => {
+      const waiter = { resolve: resolve4, reject };
+      const cleanup = () => {
+        this.#waiters.delete(waiter);
+        signal.removeEventListener("abort", onAbort);
+      };
+      const onAbort = () => {
+        cleanup();
+        resolve4(void 0);
+      };
+      waiter.resolve = (value) => {
+        cleanup();
+        resolve4(value);
+      };
+      waiter.reject = (error) => {
+        cleanup();
+        reject(error);
+      };
+      this.#waiters.add(waiter);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+function parsePayload(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const candidate = parsed;
+    if (typeof candidate.schema !== "string" || typeof candidate.streamId !== "string" || typeof candidate.kind !== "string") {
+      return void 0;
+    }
+    return {
+      schema: candidate.schema,
+      streamId: candidate.streamId,
+      kind: candidate.kind
+    };
+  } catch {
+    return void 0;
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function assertIdentifier(value, label) {
+  if (!/^[a-zA-Z_]\w*$/.test(value)) {
+    throw new Error(`Invalid ${label} name: "${value}"`);
+  }
+}
+
+// packages/context/src/lib/stream/postgres.stream-store.ts
+import { createRequire as createRequire4 } from "node:module";
+
+// packages/context/src/lib/stream/ddl.stream.postgres.ts
+function postgresStreamDDL(schema) {
+  return `
+CREATE SCHEMA IF NOT EXISTS "${schema}";
+
+CREATE TABLE IF NOT EXISTS "${schema}"."streams" (
+  id TEXT PRIMARY KEY,
+  status TEXT NOT NULL DEFAULT 'queued'
+    CHECK (status IN ('queued', 'running', 'completed', 'failed', 'cancelled')),
+  created_at BIGINT NOT NULL,
+  started_at BIGINT,
+  finished_at BIGINT,
+  cancel_requested_at BIGINT,
+  error TEXT
+);
+
+CREATE TABLE IF NOT EXISTS "${schema}"."stream_chunks" (
+  stream_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  data JSONB NOT NULL,
+  created_at BIGINT NOT NULL,
+  PRIMARY KEY (stream_id, seq),
+  FOREIGN KEY (stream_id) REFERENCES "${schema}"."streams"(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS "idx_${schema}_streams_created_at_id"
+  ON "${schema}"."streams"(created_at, id);
+
+CREATE INDEX IF NOT EXISTS "idx_${schema}_streams_status_created_at_id"
+  ON "${schema}"."streams"(status, created_at, id);
+`;
+}
+
+// packages/context/src/lib/stream/stream-store.ts
+var StreamStore = class {
+  async listRunningStreamIds() {
+    return this.listStreamIds({ status: "running" });
+  }
+};
+
+// packages/context/src/lib/stream/postgres.stream-store.ts
+var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
+  #pool;
+  #schema;
+  #ownsPool;
+  #isInitialized = false;
+  #isClosed = false;
+  constructor(options) {
+    super();
+    const schema = options.schema ?? "public";
+    assertIdentifier2(schema, "schema");
+    this.#schema = schema;
+    const pg = _PostgresStreamStore.#requirePg();
+    if (options.pool instanceof pg.Pool) {
+      this.#pool = options.pool;
+      this.#ownsPool = false;
+    } else {
+      this.#pool = typeof options.pool === "string" ? new pg.Pool({ connectionString: options.pool }) : new pg.Pool(options.pool);
+      this.#ownsPool = true;
+    }
+  }
+  static #requirePg() {
+    try {
+      const require2 = createRequire4(import.meta.url);
+      return require2("pg");
+    } catch {
+      throw new Error(
+        'PostgresStreamStore requires the "pg" package. Install it with: npm install pg'
+      );
+    }
+  }
+  #t(name) {
+    return `"${this.#schema}"."${name}"`;
+  }
+  async initialize() {
+    await this.#pool.query(postgresStreamDDL(this.#schema));
+    this.#isInitialized = true;
+  }
+  async close() {
+    if (this.#isClosed) return;
+    this.#isClosed = true;
+    if (this.#ownsPool) {
+      await this.#pool.end();
+    }
+  }
+  #ensureInitialized() {
+    if (!this.#isInitialized) {
+      throw new Error(
+        "PostgresStreamStore not initialized. Call await store.initialize() after construction."
+      );
+    }
+  }
+  async #query(sql, params) {
+    this.#ensureInitialized();
+    const result = await this.#pool.query(sql, params);
+    return result.rows;
+  }
+  async #useTransaction(fn) {
+    this.#ensureInitialized();
+    const client = await this.#pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async createStream(stream) {
+    await this.#query(
+      `INSERT INTO ${this.#t("streams")}
+       (id, status, created_at, started_at, finished_at, cancel_requested_at, error)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+      streamParams(stream)
+    );
+  }
+  async upsertStream(stream) {
+    const rows = await this.#query(
+      `INSERT INTO ${this.#t("streams")}
+       (id, status, created_at, started_at, finished_at, cancel_requested_at, error)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT(id) DO NOTHING
+       RETURNING *`,
+      streamParams(stream)
+    );
+    if (rows[0]) {
+      return { stream: rowToStream(rows[0]), created: true };
+    }
+    const existing = await this.getStream(stream.id);
+    if (!existing) {
+      throw new Error(
+        `Stream "${stream.id}" disappeared between upsert and fetch`
+      );
+    }
+    return { stream: existing, created: false };
+  }
+  async getStream(streamId) {
+    const rows = await this.#query(
+      `SELECT * FROM ${this.#t("streams")} WHERE id = $1`,
+      [streamId]
+    );
+    return rows[0] ? rowToStream(rows[0]) : void 0;
+  }
+  async getStreamStatus(streamId) {
+    const rows = await this.#query(
+      `SELECT status FROM ${this.#t("streams")} WHERE id = $1`,
+      [streamId]
+    );
+    return rows[0]?.status;
+  }
+  async listStreamIds(options) {
+    const params = [];
+    let sql = `SELECT id FROM ${this.#t("streams")}`;
+    if (options?.status) {
+      params.push(options.status);
+      sql += ` WHERE status = $${params.length}`;
+    }
+    sql += " ORDER BY created_at ASC, id ASC";
+    const rows = await this.#query(sql, params);
+    return rows.map((row) => row.id);
+  }
+  async updateStreamStatus(streamId, status, options) {
+    const now = Date.now();
+    switch (status) {
+      case "running":
+        await this.#query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1, started_at = $2
+           WHERE id = $3`,
+          [status, now, streamId]
+        );
+        break;
+      case "completed":
+        await this.#query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1, finished_at = $2
+           WHERE id = $3`,
+          [status, now, streamId]
+        );
+        break;
+      case "failed":
+        await this.#query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1, finished_at = $2, error = $3
+           WHERE id = $4`,
+          [status, now, options?.error ?? null, streamId]
+        );
+        break;
+      case "cancelled":
+        await this.#query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1, cancel_requested_at = $2, finished_at = $3
+           WHERE id = $4`,
+          [status, now, now, streamId]
+        );
+        break;
+      default:
+        await this.#query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1
+           WHERE id = $2`,
+          [status, streamId]
+        );
+    }
+  }
+  async appendChunks(chunks) {
+    if (chunks.length === 0) return;
+    const rows = chunks.map((chunk) => ({
+      stream_id: chunk.streamId,
+      seq: chunk.seq,
+      data: chunk.data,
+      created_at: chunk.createdAt
+    }));
+    await this.#query(
+      `INSERT INTO ${this.#t("stream_chunks")} (stream_id, seq, data, created_at)
+       SELECT stream_id, seq, data, created_at
+       FROM jsonb_to_recordset($1::jsonb)
+         AS rows(stream_id TEXT, seq INTEGER, data JSONB, created_at BIGINT)`,
+      [JSON.stringify(rows)]
+    );
+  }
+  async getChunks(streamId, fromSeq, limit) {
+    const params = [streamId];
+    let sql = `SELECT * FROM ${this.#t("stream_chunks")} WHERE stream_id = $1`;
+    if (fromSeq !== void 0) {
+      params.push(fromSeq);
+      sql += ` AND seq >= $${params.length}`;
     }
-  };
-  return {
-    writer: wrappedWriter,
-    streamId,
-    flush,
-    async complete() {
-      await flush();
-      await store2.updateStreamStatus(streamId, "completed");
-    },
-    async fail(error) {
-      await flush();
-      await store2.updateStreamStatus(streamId, "failed", { error });
-    },
-    async cleanup() {
-      await store2.deleteStream(streamId);
+    sql += " ORDER BY seq ASC";
+    if (limit !== void 0) {
+      params.push(limit);
+      sql += ` LIMIT $${params.length}`;
     }
-  };
-}
-
-// packages/context/src/lib/stream/polling-policy.ts
-var DEFAULT_WATCH_POLLING = {
-  minMs: 25,
-  maxMs: 500,
-  multiplier: 2,
-  jitterRatio: 0.15,
-  statusCheckEvery: 3,
-  chunkPageSize: 128
-};
-var DEFAULT_CANCEL_POLLING = {
-  minMs: 50,
-  maxMs: 500,
-  multiplier: 2,
-  jitterRatio: 0.15
+    const rows = await this.#query(sql, params);
+    return rows.map((row) => ({
+      streamId: row.stream_id,
+      seq: row.seq,
+      data: row.data,
+      createdAt: toNumber(row.created_at)
+    }));
+  }
+  async deleteStream(streamId) {
+    await this.#query(`DELETE FROM ${this.#t("streams")} WHERE id = $1`, [
+      streamId
+    ]);
+  }
+  async reopenStream(streamId) {
+    return this.#useTransaction(async (client) => {
+      const result = await client.query(
+        `SELECT * FROM ${this.#t("streams")} WHERE id = $1 FOR UPDATE`,
+        [streamId]
+      );
+      const row = result.rows[0];
+      if (!row) {
+        throw new Error(`Stream "${streamId}" not found`);
+      }
+      if (!isTerminal2(row.status)) {
+        throw new Error(
+          `Cannot reopen stream "${streamId}" with status "${row.status}". Only terminal streams can be reopened.`
+        );
+      }
+      await client.query(`DELETE FROM ${this.#t("streams")} WHERE id = $1`, [
+        streamId
+      ]);
+      const now = Date.now();
+      const stream = {
+        id: streamId,
+        status: "queued",
+        createdAt: now,
+        startedAt: null,
+        finishedAt: null,
+        cancelRequestedAt: null,
+        error: null
+      };
+      await client.query(
+        `INSERT INTO ${this.#t("streams")}
+         (id, status, created_at, started_at, finished_at, cancel_requested_at, error)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+        streamParams(stream)
+      );
+      return stream;
+    });
+  }
 };
-function normalizeWatchPolling(polling, fallback = DEFAULT_WATCH_POLLING) {
-  const merged = {
-    ...fallback,
-    ...polling
-  };
-  const normalizedBase = normalizeAdaptivePolling(merged, fallback);
-  return {
-    ...normalizedBase,
-    statusCheckEvery: clampInt(merged.statusCheckEvery, 1, 1e4),
-    chunkPageSize: clampInt(merged.chunkPageSize, 1, 1e4)
-  };
-}
-function normalizeCancelPolling(polling, fallback = DEFAULT_CANCEL_POLLING) {
-  return normalizeAdaptivePolling(polling, fallback);
+function streamParams(stream) {
+  return [
+    stream.id,
+    stream.status,
+    stream.createdAt,
+    stream.startedAt,
+    stream.finishedAt,
+    stream.cancelRequestedAt,
+    stream.error
+  ];
 }
-function createAdaptivePollingState(config) {
+function rowToStream(row) {
   return {
-    config,
-    currentMs: config.minMs
+    id: row.id,
+    status: row.status,
+    createdAt: toNumber(row.created_at),
+    startedAt: toNullableNumber(row.started_at),
+    finishedAt: toNullableNumber(row.finished_at),
+    cancelRequestedAt: toNullableNumber(row.cancel_requested_at),
+    error: row.error
   };
 }
-function resetAdaptivePolling(state) {
-  state.currentMs = state.config.minMs;
-}
-function nextAdaptivePollingDelay(state) {
-  const current = clampInt(
-    state.currentMs,
-    state.config.minMs,
-    state.config.maxMs
-  );
-  const delay = applyJitter(
-    current,
-    state.config.jitterRatio,
-    state.config.minMs,
-    state.config.maxMs
-  );
-  state.currentMs = clampInt(
-    Math.ceil(current * state.config.multiplier),
-    state.config.minMs,
-    state.config.maxMs
-  );
-  return delay;
-}
-function normalizeAdaptivePolling(polling, fallback) {
-  const merged = {
-    ...fallback,
-    ...polling
-  };
-  const minMs = clampInt(merged.minMs, 1, 6e4);
-  const maxMs = clampInt(merged.maxMs, minMs, 6e4);
-  return {
-    minMs,
-    maxMs,
-    multiplier: clampFloat(merged.multiplier, 1, 10),
-    jitterRatio: clampFloat(merged.jitterRatio, 0, 1)
-  };
+function toNumber(value) {
+  return typeof value === "number" ? value : Number(value);
 }
-function applyJitter(value, jitterRatio, min, max) {
-  if (jitterRatio <= 0) return value;
-  const radius = value * jitterRatio;
-  const lowerBound = Math.max(0, value - radius);
-  const upperBound = value + radius;
-  const jittered = Math.round(
-    lowerBound + Math.random() * (upperBound - lowerBound)
-  );
-  return clampInt(jittered, min, max);
+function toNullableNumber(value) {
+  return value == null ? null : toNumber(value);
 }
-function clampInt(value, min, max) {
-  if (!Number.isFinite(value)) return min;
-  return Math.min(max, Math.max(min, Math.round(value)));
+function isTerminal2(status) {
+  return status !== "queued" && status !== "running";
 }
-function clampFloat(value, min, max) {
-  if (!Number.isFinite(value)) return min;
-  return Math.min(max, Math.max(min, value));
+function assertIdentifier2(value, label) {
+  if (!/^[a-zA-Z_]\w*$/.test(value)) {
+    throw new Error(`Invalid ${label} name: "${value}"`);
+  }
 }
 
 // packages/context/src/lib/stream/sqlite.stream-store.ts
@@ -8680,13 +9946,6 @@ import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 // packages/context/src/lib/stream/ddl.stream.sqlite.sql
 var ddl_stream_sqlite_default = "PRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA foreign_keys = ON;\n\nCREATE TABLE IF NOT EXISTS streams (\n  id TEXT PRIMARY KEY,\n  status TEXT NOT NULL DEFAULT 'queued'\n    CHECK(status IN ('queued','running','completed','failed','cancelled')),\n  createdAt INTEGER NOT NULL,\n  startedAt INTEGER,\n  finishedAt INTEGER,\n  cancelRequestedAt INTEGER,\n  error TEXT\n);\n\nCREATE TABLE IF NOT EXISTS stream_chunks (\n  streamId TEXT NOT NULL,\n  seq INTEGER NOT NULL,\n  data TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  PRIMARY KEY (streamId, seq),\n  FOREIGN KEY (streamId) REFERENCES streams(id) ON DELETE CASCADE\n);\n\n-- Supports ordered listing across all streams.\nCREATE INDEX IF NOT EXISTS idx_streams_created_at_id\n  ON streams(createdAt, id);\n\n-- Supports status-filtered ordered listing (e.g. running streams).\nCREATE INDEX IF NOT EXISTS idx_streams_status_created_at_id\n  ON streams(status, createdAt, id);\n";
 
-// packages/context/src/lib/stream/stream-store.ts
-var StreamStore = class {
-  async listRunningStreamIds() {
-    return this.listStreamIds({ status: "running" });
-  }
-};
-
 // packages/context/src/lib/stream/sqlite.stream-store.ts
 var SqliteStreamStore = class extends StreamStore {
   #db;
@@ -8913,26 +10172,20 @@ var SqliteStreamStore = class extends StreamStore {
 
 // packages/context/src/lib/stream/stream-manager.ts
 import { createUIMessageStream as createUIMessageStream3 } from "ai";
-import { setTimeout } from "node:timers/promises";
-function isTerminal(status) {
+function isTerminal3(status) {
   return status !== "queued" && status !== "running";
 }
+var DEFAULT_CHUNK_PAGE_SIZE = 128;
 var StreamManager = class {
   #store;
-  #watchPollingDefaults;
-  #cancelPollingDefaults;
-  #onPollingEvent;
+  #changeSource;
+  #chunkPageSize;
+  #onWatchEvent;
   constructor(options) {
     this.#store = options.store;
-    this.#watchPollingDefaults = normalizeWatchPolling(
-      options.watchPolling,
-      DEFAULT_WATCH_POLLING
-    );
-    this.#cancelPollingDefaults = normalizeCancelPolling(
-      options.cancelPolling,
-      DEFAULT_CANCEL_POLLING
-    );
-    this.#onPollingEvent = options.onPollingEvent;
+    this.#changeSource = options.changeSource;
+    this.#chunkPageSize = options.chunkPageSize ?? DEFAULT_CHUNK_PAGE_SIZE;
+    this.#onWatchEvent = options.onWatchEvent;
   }
   get store() {
     return this.#store;
@@ -8956,51 +10209,12 @@ var StreamManager = class {
   }
   async persist(stream, streamId, options) {
     const existing = await this.#store.getStream(streamId);
-    if (existing && isTerminal(existing.status)) {
+    if (existing && isTerminal3(existing.status)) {
       return { streamId };
     }
     await this.#store.updateStreamStatus(streamId, "running");
     const ac = new AbortController();
-    const cancelPolling = normalizeCancelPolling(
-      options?.cancelPolling,
-      this.#cancelPollingDefaults
-    );
-    const pollState = createAdaptivePollingState(cancelPolling);
-    const pollCancel = (async () => {
-      while (!ac.signal.aborted) {
-        const delayMs = nextAdaptivePollingDelay(pollState);
-        const continued = await waitForDelay(delayMs, ac.signal);
-        if (!continued || ac.signal.aborted) break;
-        const status = await this.#store.getStreamStatus(streamId);
-        this.#emitPolling({
-          type: "persist:cancel-poll",
-          streamId,
-          delayMs,
-          status: status ?? "missing"
-        });
-        if (status === void 0) {
-          ac.abort();
-          break;
-        }
-        if (status === "cancelled") {
-          const current = await this.#store.getStream(streamId);
-          const latencyMs = current?.cancelRequestedAt != null ? Math.max(0, Date.now() - current.cancelRequestedAt) : null;
-          this.#emitPolling({
-            type: "persist:cancel-detected",
-            streamId,
-            latencyMs
-          });
-          if (options?.onCancelDetected) {
-            try {
-              await options.onCancelDetected({ streamId, latencyMs });
-            } catch {
-            }
-          }
-          ac.abort();
-          break;
-        }
-      }
-    })();
+    const cancelWatcher = this.#runCancelWatcher(streamId, ac, options);
     let pw;
     const sink = createUIMessageStream3({
       execute: async ({ writer }) => {
@@ -9041,142 +10255,131 @@ var StreamManager = class {
       }
     } finally {
       if (!ac.signal.aborted) ac.abort();
-      await pollCancel;
+      await cancelWatcher;
     }
     return { streamId: pw?.streamId ?? streamId };
   }
-  watch(streamId, options) {
+  async #runCancelWatcher(streamId, ac, options) {
+    try {
+      for await (const change of this.#changeSource.subscribe(
+        streamId,
+        ac.signal
+      )) {
+        if (change.kind === "chunks") continue;
+        const status = await this.#store.getStreamStatus(streamId);
+        if (status === void 0) {
+          ac.abort();
+          return;
+        }
+        if (status === "cancelled") {
+          const current = await this.#store.getStream(streamId);
+          const latencyMs = current?.cancelRequestedAt != null ? Math.max(0, Date.now() - current.cancelRequestedAt) : null;
+          this.#emit({
+            type: "persist:cancel-detected",
+            streamId,
+            latencyMs
+          });
+          if (options?.onCancelDetected) {
+            try {
+              await options.onCancelDetected({ streamId, latencyMs });
+            } catch {
+            }
+          }
+          ac.abort();
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+  watch(streamId) {
     const store2 = this.#store;
-    const polling = normalizeWatchPolling(options, this.#watchPollingDefaults);
-    const delayState = createAdaptivePollingState(polling);
+    const changeSource = this.#changeSource;
+    const pageSize = this.#chunkPageSize;
+    const emit = this.#emit.bind(this);
     const ac = new AbortController();
     const lastSeqRef = { value: -1 };
-    let chunkPollsSinceStatus = 0;
-    const emitChunks = (controller, chunks) => {
-      for (const chunk of chunks) {
-        controller.enqueue(chunk.data);
-        lastSeqRef.value = chunk.seq;
-      }
-      return chunks.length;
+    let iterator;
+    const emitPage = (delivered, lastSeq) => {
+      emit({ type: "watch:chunks", streamId, delivered, lastSeq });
     };
-    return new ReadableStream({
-      async start() {
+    const finalize = async (controller, reason, knownStatus) => {
+      await drainAvailable(
+        controller,
+        store2,
+        streamId,
+        lastSeqRef,
+        pageSize,
+        emitPage
+      );
+      const finalStatus = knownStatus ?? await store2.getStreamStatus(streamId);
+      if (finalStatus === "failed") {
         const stream = await store2.getStream(streamId);
-        if (!stream) {
-          throw new Error(`Stream "${streamId}" not found`);
+        if (stream) {
+          const errorText = stream.error || "Stream failed";
+          emit({
+            type: "watch:error-emitted",
+            streamId,
+            errorTextLength: errorText.length
+          });
+          controller.enqueue({ type: "error", errorText });
         }
+      }
+      emit({ type: "watch:closed", streamId, reason });
+      controller.close();
+      ac.abort();
+    };
+    return new ReadableStream({
+      start: () => {
+        iterator = changeSource.subscribe(streamId, ac.signal)[Symbol.asyncIterator]();
       },
       pull: async (controller) => {
+        if (!iterator) return;
         while (!ac.signal.aborted) {
-          const fromSeq = lastSeqRef.value + 1;
-          const chunks = await store2.getChunks(
-            streamId,
-            fromSeq,
-            polling.chunkPageSize
-          );
-          let statusChecked = false;
-          let currentStatus;
-          if (chunks.length === 0) {
-            chunkPollsSinceStatus = polling.statusCheckEvery;
-          } else {
-            chunkPollsSinceStatus += 1;
+          let result;
+          try {
+            result = await iterator.next();
+          } catch (error) {
+            iterator.return?.().catch(() => void 0);
+            if (isAbortError(error)) return;
+            throw error;
           }
-          if (chunkPollsSinceStatus >= polling.statusCheckEvery) {
-            statusChecked = true;
-            chunkPollsSinceStatus = 0;
-            currentStatus = await store2.getStreamStatus(streamId);
+          if (result.done) {
+            await finalize(controller, "source-ended");
+            return;
           }
-          this.#emitPolling({
-            type: "watch:poll",
-            streamId,
-            fromSeq,
-            chunkCount: chunks.length,
-            statusChecked
-          });
-          if (chunks.length > 0) {
-            const delivered = emitChunks(controller, chunks);
-            this.#emitPolling({
-              type: "watch:chunks",
+          const change = result.value;
+          let delivered = 0;
+          if (change.kind !== "status") {
+            delivered = await drainAvailable(
+              controller,
+              store2,
               streamId,
-              delivered,
-              lastSeq: lastSeqRef.value
-            });
-            resetAdaptivePolling(delayState);
-            if (chunks.length >= polling.chunkPageSize) {
-              continue;
-            }
-            return;
+              lastSeqRef,
+              pageSize,
+              emitPage
+            );
           }
-          if (statusChecked) {
-            if (currentStatus === void 0) {
-              this.#emitPolling({
-                type: "watch:closed",
-                streamId,
-                reason: "missing"
-              });
-              controller.close();
-              ac.abort();
+          if (change.kind !== "chunks") {
+            const status = await store2.getStreamStatus(streamId);
+            if (status === void 0) {
+              await finalize(controller, "missing");
               return;
             }
-            if (isTerminal(currentStatus)) {
-              const drained = await drainRemainingChunks({
-                controller,
-                store: store2,
-                streamId,
-                fromSeq: lastSeqRef.value + 1,
-                chunkPageSize: polling.chunkPageSize,
-                onChunk: (seq) => {
-                  lastSeqRef.value = seq;
-                }
-              });
-              if (drained > 0) {
-                this.#emitPolling({
-                  type: "watch:chunks",
-                  streamId,
-                  delivered: drained,
-                  lastSeq: lastSeqRef.value
-                });
-              }
-              if (currentStatus === "failed") {
-                const stream = await store2.getStream(streamId);
-                if (stream) {
-                  const errorText = stream.error || "Stream failed";
-                  this.#emitPolling({
-                    type: "watch:error-emitted",
-                    streamId,
-                    errorTextLength: errorText.length
-                  });
-                  controller.enqueue({
-                    type: "error",
-                    errorText
-                  });
-                }
-              }
-              this.#emitPolling({
-                type: "watch:closed",
-                streamId,
-                reason: "terminal"
-              });
-              controller.close();
-              ac.abort();
+            if (isTerminal3(status)) {
+              await finalize(controller, "terminal", status);
               return;
             }
           }
-          const delayMs = nextAdaptivePollingDelay(delayState);
-          this.#emitPolling({
-            type: "watch:empty",
-            streamId,
-            fromSeq: lastSeqRef.value + 1,
-            delayMs
-          });
-          const continued = await waitForDelay(delayMs, ac.signal);
-          if (!continued) {
-            return;
-          }
+          if (delivered > 0) return;
         }
       },
-      cancel() {
+      cancel: () => {
         ac.abort();
+        return iterator?.return?.().then(
+          () => void 0,
+          () => void 0
+        );
       }
     });
   }
@@ -9187,41 +10390,32 @@ var StreamManager = class {
   async cleanup(streamId) {
     await this.#store.deleteStream(streamId);
   }
-  #emitPolling(event) {
-    if (!this.#onPollingEvent) return;
+  #emit(event) {
+    if (!this.#onWatchEvent) return;
     try {
-      this.#onPollingEvent(event);
+      this.#onWatchEvent(event);
     } catch {
     }
   }
 };
-async function drainRemainingChunks(options) {
-  const { controller, store: store2, streamId, chunkPageSize, onChunk } = options;
-  let fromSeq = options.fromSeq;
-  let drained = 0;
+async function drainAvailable(controller, store2, streamId, lastSeqRef, pageSize, onPage) {
+  let total = 0;
   while (true) {
-    const chunks = await store2.getChunks(streamId, fromSeq, chunkPageSize);
+    const chunks = await store2.getChunks(
+      streamId,
+      lastSeqRef.value + 1,
+      pageSize
+    );
     if (chunks.length === 0) break;
     for (const chunk of chunks) {
       controller.enqueue(chunk.data);
-      onChunk(chunk.seq);
-      drained++;
-      fromSeq = chunk.seq + 1;
+      lastSeqRef.value = chunk.seq;
     }
-    if (chunks.length < chunkPageSize) {
-      break;
-    }
-  }
-  return drained;
-}
-async function waitForDelay(ms, signal) {
-  try {
-    await setTimeout(ms, void 0, signal ? { signal } : void 0);
-    return true;
-  } catch (error) {
-    if (isAbortError(error)) return false;
-    throw error;
+    total += chunks.length;
+    onPage?.(chunks.length, lastSeqRef.value);
+    if (chunks.length < pageSize) break;
   }
+  return total;
 }
 function isAbortError(error) {
   return error instanceof Error && (error.name === "AbortError" || /aborted/i.test(error.message));
@@ -9302,9 +10496,9 @@ export {
   AgentOsCreationError,
   AgentOsNotAvailableError,
   AgentOsSandboxError,
+  AsyncResolver,
   BM25Classifier,
   BashException,
-  BinaryInstallError,
   ComposeStartError,
   ComposeStrategy,
   ContainerCreationError,
@@ -9318,15 +10512,29 @@ export {
   DockerSandboxStrategy,
   DockerfileBuildError,
   DockerfileStrategy,
-  DuplicateCommandError,
+  FragmentLoaderResolver,
+  FunctionResolver,
+  GeneratorResolver,
+  GithubReleaseInstaller,
   InMemoryContextStore,
+  InstallError,
+  Installer,
+  IterableResolver,
   LOCALE_METADATA_KEY,
   MarkdownRenderer,
+  MissingRuntimeError,
   ModelsRegistry,
   MountPathError,
+  NpmInstaller,
   ObservedFs,
   PackageInstallError,
+  PackageInstaller,
+  PipInstaller,
+  PollingChangeSource,
   PostgresContextStore,
+  PostgresNotifyChangeSource,
+  PostgresStreamStore,
+  PromiseResolver,
   RuntimeStrategy,
   SqlServerContextStore,
   SqliteContextStore,
@@ -9336,6 +10544,7 @@ export {
   TitleGenerator,
   TomlRenderer,
   ToonRenderer,
+  UrlBinaryInstaller,
   XmlRenderer,
   addUsage,
   advisorPreamble,
@@ -9346,17 +10555,19 @@ export {
   alias,
   analogy,
   and,
+  anyToolCalled,
   applyInlineReminder,
   applyPartReminder,
   applyReminderToMessage,
+  applyToolOutputRemindersToMessage,
   asStaticWordPartText,
   asStaticWordText,
+  assertCountSpec,
   assistant,
   assistantText,
-  buildSchemaSubcommand,
   buildSubcommandRepair,
-  chainHooks,
   chat,
+  checkCount,
   clarification,
   classifies,
   contentIncludes,
@@ -9369,29 +10580,29 @@ export {
   createBinaryBridges,
   createContainerTool,
   createDockerSandbox,
-  createOpenAPIExtension,
+  createInstallerContext,
   createRepairToolCall,
-  createRoutingSandbox,
   createVirtualSandbox,
   dateReminder,
   dayChanged,
   defaultChatMessageMetadata,
+  defaultResolvers,
   defaultTokenizer,
   defineSubcommandGroup,
+  discoverSkillMappings,
   discoverSkillsInDirectory,
+  elapsedExceeds,
   encodeSerializedValue,
   errorRecoveryGuardrail,
   estimate,
   everyNTurns,
+  everyOfLastN,
   example,
   executorContext,
   explain,
-  extractPathParams,
   fail,
-  findUnsafePathParam,
+  findSingleOutputAvailableToolPart,
   firstN,
-  formatError,
-  formatResponse,
   fragment,
   fromFragment,
   getFragmentData,
@@ -9399,6 +10610,7 @@ export {
   getModelsRegistry,
   getReminderRanges,
   getSeason,
+  githubRelease,
   glossary,
   guardrail,
   hint,
@@ -9406,16 +10618,16 @@ export {
   identity,
   isComposeOptions,
   isConditionalReminder,
+  isDebianBased,
   isDockerfileOptions,
   isFragment,
   isFragmentObject,
-  isInstallable,
   isMessageFragment,
   isRecord,
+  lastAssistantLength,
   loadSkillMetadata,
   localeReminder,
   mapGenerateErrorToCode,
-  mergeExtensions,
   mergeMessageMetadata,
   mergeReminderMetadata,
   message,
@@ -9425,6 +10637,7 @@ export {
   normalizeCancelPolling,
   normalizeWatchPolling,
   not,
+  npm,
   nullUsage,
   once,
   or,
@@ -9432,6 +10645,8 @@ export {
   pass,
   persistedWriter,
   persona,
+  pip,
+  pkg,
   policy,
   preference,
   principle,
@@ -9452,6 +10667,7 @@ export {
   seasonChanged,
   seasonReminder,
   selfCritique,
+  shellQuote,
   skills,
   skillsReminder,
   socraticPrompting,
@@ -9467,13 +10683,20 @@ export {
   timeReminder,
   toFragment,
   toMessageFragment,
+  toolCall,
+  toolCallCount,
+  toolCalled,
+  toolFailed,
   uploadSkills,
+  urlBinary,
+  usageExceeds,
   useAgentOsSandbox,
   useBashMeta,
   useSandbox,
   user,
   visualizeGraph,
   weekChanged,
+  withinLastN,
   workflow,
   yearChanged,
   yearReminder