@dudousxd/nestjs-agent-core 0.12.0 → 0.14.0

package/dist/index.js

@@ -22,6 +22,9 @@ var AGENT_PROMPT_CONTRIBUTORS = Symbol.for("@dudousxd/nestjs-agent:prompt-contri
 var AGENT_ACTOR_DIRECTORY = Symbol.for("@dudousxd/nestjs-agent:actor-directory");
 var AGENT_ATTACHMENT_STAGING = Symbol.for("@dudousxd/nestjs-agent:attachment-staging");
 var AGENT_APPROVAL_PORT = Symbol.for("@dudousxd/nestjs-agent:approval-port");
+var AGENT_SKILLS = Symbol.for("@dudousxd/nestjs-agent:skills");
+var AGENT_MEMORY = Symbol.for("@dudousxd/nestjs-agent:memory");
+var AGENT_SKILL_SOURCES = Symbol.for("@dudousxd/nestjs-agent:skill-sources");
 
 // src/spi/token-stream-sink.ts
 var AgentStreamError = class extends Error {
@@ -43,6 +46,17 @@ function encodeStreamEvent(event) {
 `);
 }
 __name(encodeStreamEvent, "encodeStreamEvent");
+function decodeStreamEvent(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.kind === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(decodeStreamEvent, "decodeStreamEvent");
 
 // src/spi/pricing-store.ts
 async function seedModelPrices(store, prices) {
@@ -52,6 +66,40 @@ async function seedModelPrices(store, prices) {
 }
 __name(seedModelPrices, "seedModelPrices");
 
+// src/spi/processors.ts
+var DEFAULT_INCREMENTAL_LOOKBACK_CHARS = 64;
+var OutputRejectedError = class extends Error {
+  static {
+    __name(this, "OutputRejectedError");
+  }
+  /** {@link OutputProcessor.name} of the processor that refused. */
+  processor;
+  /** The reason it gave, verbatim. */
+  reason;
+  constructor(processor, reason) {
+    super(`Output rejected by "${processor}": ${reason}`);
+    this.name = "OutputRejectedError";
+    this.processor = processor;
+    this.reason = reason;
+  }
+};
+var ProcessorFailedError = class extends Error {
+  static {
+    __name(this, "ProcessorFailedError");
+  }
+  /** Which seam it was on, so a reader knows whether the prompt or the answer was in flight. */
+  phase;
+  /** The processor's `name`. */
+  processor;
+  constructor(phase, processor, cause) {
+    super(`${phase} processor "${processor}" failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "ProcessorFailedError";
+    this.phase = phase;
+    this.processor = processor;
+    this.cause = cause;
+  }
+};
+
 // src/spi/governance-queries.ts
 var THREAD_DETAIL_CONTENT_CHARS = 2e3;
 function truncateDetailContent(content) {
@@ -268,464 +316,2779 @@ function filterToolsByAllowList(tools, allowedTools) {
 }
 __name(filterToolsByAllowList, "filterToolsByAllowList");
 
-// src/agent-registry.ts
-var AgentRegistry = class {
-  static {
-    __name(this, "AgentRegistry");
+// src/history.ts
+function estimateMessageTokens(message) {
+  const extras = (message.toolCalls !== void 0 ? JSON.stringify(message.toolCalls).length : 0) + (message.toolResults !== void 0 ? JSON.stringify(message.toolResults).length : 0);
+  return Math.ceil((message.content.length + extras) / 4) + 4;
+}
+__name(estimateMessageTokens, "estimateMessageTokens");
+function windowHistory(options) {
+  const estimate = options.estimate ?? estimateMessageTokens;
+  const policy = {
+    // A suffix selection of at most `maxMessages` rows, which is exactly what `HistoryPolicy`'s row
+    // hint promises — so the store can bound its read to that many of the thread's newest messages.
+    // A token-only window declares nothing: its budget names no row count.
+    ...options.maxMessages !== void 0 ? {
+      maxMessages: options.maxMessages
+    } : {},
+    select(messages) {
+      let cut = 0;
+      if (options.maxMessages !== void 0) {
+        cut = Math.max(cut, messages.length - options.maxMessages);
+      }
+      if (options.maxTokens !== void 0) {
+        cut = Math.max(cut, tokenCut(messages, options.maxTokens, estimate));
+      }
+      cut = Math.min(cut, Math.max(0, messages.length - 1));
+      return {
+        keep: messages.slice(cut),
+        drop: messages.slice(0, cut)
+      };
+    }
+  };
+  return options.summarize !== void 0 ? {
+    ...policy,
+    summarize: options.summarize
+  } : policy;
+}
+__name(windowHistory, "windowHistory");
+function tokenCut(messages, maxTokens, estimate) {
+  let index = messages.length;
+  let total = 0;
+  while (index > 0) {
+    const message = messages[index - 1];
+    if (message === void 0) {
+      break;
+    }
+    const cost = estimate(message);
+    if (index < messages.length && total + cost > maxTokens) {
+      break;
+    }
+    total += cost;
+    index -= 1;
   }
-  definitions = /* @__PURE__ */ new Map();
-  register(definition) {
-    this.definitions.set(definition.name, definition);
+  return index;
+}
+__name(tokenCut, "tokenCut");
+var DEFAULT_HISTORY_SUMMARY_INSTRUCTION = "Summarize this conversation for an assistant that will continue it without seeing these messages. Preserve decisions made, facts and constraints the user stated, identifiers and names mentioned, and anything left unresolved. Omit pleasantries. Reply with the summary only \u2014 no preamble, no headings.";
+function summarizeWithModel(model, instruction = DEFAULT_HISTORY_SUMMARY_INSTRUCTION) {
+  return async (dropped) => {
+    const discard = {
+      write: /* @__PURE__ */ __name(() => {
+      }, "write"),
+      end: /* @__PURE__ */ __name(() => {
+      }, "end"),
+      fail: /* @__PURE__ */ __name(() => {
+      }, "fail")
+    };
+    const turn = await model.runTurn({
+      system: instruction,
+      messages: dropped,
+      tools: [],
+      sink: discard
+    });
+    return {
+      text: turn.text,
+      usage: turn.usage,
+      ...turn.modelId !== void 0 ? {
+        modelId: turn.modelId
+      } : {}
+    };
+  };
+}
+__name(summarizeWithModel, "summarizeWithModel");
+
+// src/processors.ts
+var decoder = new TextDecoder();
+function createFrameBuffer() {
+  const frames = [];
+  return {
+    writer: {
+      write: /* @__PURE__ */ __name((chunk) => {
+        for (const line of decoder.decode(chunk).split("\n")) {
+          if (line.length > 0) {
+            frames.push(line);
+          }
+        }
+      }, "write"),
+      end: /* @__PURE__ */ __name(() => {
+      }, "end"),
+      fail: /* @__PURE__ */ __name(() => {
+      }, "fail")
+    },
+    frames: /* @__PURE__ */ __name(() => frames, "frames")
+  };
+}
+__name(createFrameBuffer, "createFrameBuffer");
+function releaseGatedFrames(frames, text) {
+  const released = [];
+  let emitted = false;
+  for (const frame of frames) {
+    const event = decodeStreamEvent(frame);
+    if (event === null || event.kind === "text") {
+      if (!emitted && text.length > 0) {
+        released.push(encodeStreamEvent({
+          kind: "text",
+          text
+        }));
+        emitted = true;
+      }
+      continue;
+    }
+    released.push(encodeStreamEvent(event));
   }
-  get(name) {
-    return this.definitions.get(name);
+  if (!emitted && text.length > 0) {
+    released.push(encodeStreamEvent({
+      kind: "text",
+      text
+    }));
   }
-  has(name) {
-    return this.definitions.has(name);
+  return released;
+}
+__name(releaseGatedFrames, "releaseGatedFrames");
+async function runInputProcessors(processors, prompt, ctx) {
+  let current = prompt;
+  for (const processor of processors) {
+    try {
+      current = await processor.process(current, ctx);
+    } catch (error) {
+      throw new ProcessorFailedError("input", processor.name, error);
+    }
   }
-  list() {
-    return [
-      ...this.definitions.values()
-    ];
+  return current;
+}
+__name(runInputProcessors, "runInputProcessors");
+async function runOutputProcessors(processors, answer, ctx) {
+  let text = answer.text;
+  for (const processor of processors) {
+    let verdict;
+    try {
+      verdict = await processor.process({
+        text,
+        toolCalls: answer.toolCalls
+      }, ctx);
+    } catch (error) {
+      throw new ProcessorFailedError("output", processor.name, error);
+    }
+    if (verdict.action === "reject") {
+      return {
+        text,
+        rejection: {
+          processor: processor.name,
+          reason: verdict.reason
+        }
+      };
+    }
+    if (verdict.action === "replace") {
+      text = verdict.text;
+    }
   }
-};
-
-// src/tool-registry.ts
-var ToolForbiddenError = class extends Error {
-  static {
-    __name(this, "ToolForbiddenError");
+  return {
+    text
+  };
+}
+__name(runOutputProcessors, "runOutputProcessors");
+async function gateFollowUps(processors, followUps, ctx) {
+  const kept = [];
+  for (const followUp of followUps) {
+    const settled = await runOutputProcessors(processors, {
+      text: followUp,
+      toolCalls: []
+    }, ctx);
+    if (settled.rejection === void 0 && settled.text.length > 0) {
+      kept.push(settled.text);
+    }
   }
-  toolName;
-  constructor(toolName) {
-    super(`Tool "${toolName}" is not allowed for this role`), this.toolName = toolName;
-    this.name = "ToolForbiddenError";
+  return kept;
+}
+__name(gateFollowUps, "gateFollowUps");
+function resolveOutputGateMode(processors) {
+  if (processors.length === 0) {
+    return "off";
   }
-};
-var ToolDisabledError = class extends Error {
-  static {
-    __name(this, "ToolDisabledError");
+  return processors.every((processor) => processor.incremental !== void 0) ? "incremental" : "whole";
+}
+__name(resolveOutputGateMode, "resolveOutputGateMode");
+function resolveGateLookback(processors) {
+  let lookback = 0;
+  for (const processor of processors) {
+    if (processor.incremental !== void 0) {
+      lookback = Math.max(lookback, processor.incremental.lookbackChars ?? DEFAULT_INCREMENTAL_LOOKBACK_CHARS);
+    }
   }
-  toolName;
-  constructor(toolName) {
-    super(`Tool "${toolName}" is disabled in this deployment`), this.toolName = toolName;
-    this.name = "ToolDisabledError";
+  return lookback;
+}
+__name(resolveGateLookback, "resolveGateLookback");
+function createIncrementalGate(options) {
+  const { processors, ctx, lookbackChars, writer } = options;
+  let raw = "";
+  let released = "";
+  let rejection;
+  let stalled = false;
+  const toolCalls = [];
+  let queue = Promise.resolve();
+  async function advance() {
+    if (raw.length === 0) {
+      return;
+    }
+    let settled;
+    try {
+      settled = await runOutputProcessors(processors, {
+        text: raw,
+        toolCalls
+      }, ctx);
+    } catch {
+      stalled = true;
+      return;
+    }
+    if (settled.rejection !== void 0) {
+      rejection = settled.rejection;
+      return;
+    }
+    const candidate = settled.text.slice(0, Math.max(0, settled.text.length - lookbackChars));
+    if (candidate.length <= released.length || !candidate.startsWith(released)) {
+      return;
+    }
+    const delta = candidate.slice(released.length);
+    released = candidate;
+    await writer.write(encodeStreamEvent({
+      kind: "text",
+      text: delta
+    }));
   }
-};
-var ToolNotFoundError = class extends Error {
-  static {
-    __name(this, "ToolNotFoundError");
+  __name(advance, "advance");
+  async function handle(chunk) {
+    for (const line of decoder.decode(chunk).split("\n")) {
+      if (line.length === 0) {
+        continue;
+      }
+      const event = decodeStreamEvent(line);
+      if (event === null || rejection !== void 0) {
+        continue;
+      }
+      if (event.kind === "text") {
+        raw += event.text;
+        if (!stalled) {
+          await advance();
+        }
+        continue;
+      }
+      if (event.kind === "tool-input-available") {
+        toolCalls.push({
+          id: event.id,
+          name: event.name,
+          input: event.input
+        });
+      }
+      await writer.write(encodeStreamEvent(event));
+    }
   }
-  toolName;
-  constructor(toolName) {
-    super(`Tool "${toolName}" is not registered`), this.toolName = toolName;
-    this.name = "ToolNotFoundError";
+  __name(handle, "handle");
+  return {
+    writer: {
+      write: /* @__PURE__ */ __name((chunk) => {
+        queue = queue.then(() => handle(chunk));
+        return queue;
+      }, "write"),
+      end: /* @__PURE__ */ __name(() => {
+      }, "end"),
+      fail: /* @__PURE__ */ __name(() => {
+      }, "fail")
+    },
+    settled: /* @__PURE__ */ __name(() => queue, "settled"),
+    released: /* @__PURE__ */ __name(() => released, "released"),
+    rejection: /* @__PURE__ */ __name(() => rejection, "rejection")
+  };
+}
+__name(createIncrementalGate, "createIncrementalGate");
+function gateTail(processors, released, text) {
+  if (!text.startsWith(released)) {
+    throw new ProcessorFailedError("output", processors.map((processor) => processor.name).join(" \u2192 "), new Error(`the gated answer is not an extension of the ${released.length} characters this chain already released \u2014 a processor that declares "incremental" promises its result on a prefix stays a prefix of its result on the whole answer, outside the last lookbackChars`));
   }
-};
-var ToolInputInvalidError = class extends Error {
+  return text.slice(released.length);
+}
+__name(gateTail, "gateTail");
+
+// src/structured-output.ts
+var StructuredOutputError = class extends Error {
   static {
-    __name(this, "ToolInputInvalidError");
+    __name(this, "StructuredOutputError");
   }
-  toolName;
+  /** Why it failed the schema. Empty only when the text was not JSON at all. */
   issues;
-  constructor(toolName, issues) {
-    super(`Invalid input for tool "${toolName}": ${issues.map((issue) => issue.message).join("; ")}`), this.toolName = toolName, this.issues = issues;
-    this.name = "ToolInputInvalidError";
+  /** The last text the model produced, verbatim. */
+  text;
+  /** How many model calls were spent trying (1 = the formatting pass, no repairs). */
+  attempts;
+  constructor(issues, text, attempts) {
+    const detail = issues.length > 0 ? issues.map((issue4) => issue4.message).join("; ") : "the model did not reply with JSON";
+    super(`Structured output invalid after ${attempts} attempt(s): ${detail}`);
+    this.name = "StructuredOutputError";
+    this.issues = issues;
+    this.text = text;
+    this.attempts = attempts;
   }
 };
-var ToolRegistry = class {
-  static {
-    __name(this, "ToolRegistry");
-  }
-  entries = /* @__PURE__ */ new Map();
-  register(spec, handler) {
-    this.entries.set(spec.name, {
-      spec,
-      handler
-    });
-  }
-  has(name) {
-    return this.entries.has(name);
-  }
-  spec(name) {
-    return this.entries.get(name)?.spec;
-  }
-  allSpecs() {
-    return [
-      ...this.entries.values()
-    ].map((entry) => entry.spec);
-  }
-  /**
-  * The tools to offer the model for this actor+agent, after the four filter layers: what this
-  * deployment has enabled, what this actor's role allows, what each tool's own `canUse` allows
-  * this actor, and finally what this agent pinned.
-  *
-  * Every layer only ever removes tools, so no arrangement of them can widen what a turn reaches.
-  */
-  async definitionsFor(actor, policy, allowedTools) {
-    const live = await filterToolsByEnabled([
-      ...this.entries.values()
-    ]);
-    const allowedByRole = new Set((await filterToolsByRole(live.map((entry) => entry.spec), actor, policy)).map((spec) => spec.name));
-    const roleScoped = live.filter((entry) => allowedByRole.has(entry.spec.name));
-    const actorScoped = await filterToolsByCanUse(roleScoped, actor);
-    const allowScoped = filterToolsByAllowList(actorScoped.map((entry) => entry.spec), allowedTools);
-    return allowScoped.map((spec) => ({
-      name: spec.name,
-      kind: spec.kind,
-      description: spec.description,
-      inputSchema: spec.inputSchema
-    }));
-  }
-  /**
-  * Run a tool. Re-checks that the tool is enabled and that the role allows it (defense-in-depth —
-  * a call can reach here from a replayed durable step or an approval granted before the flag
-  * moved, neither of which went through `definitionsFor` again) and re-parses the input via Zod.
-  */
-  async invoke(name, input, ctx, policy) {
-    const entry = this.entries.get(name);
-    if (entry === void 0) {
-      throw new ToolNotFoundError(name);
-    }
-    if (!await isToolEnabled(entry.spec, entry.handler)) {
-      throw new ToolDisabledError(name);
-    }
-    if (!await policy.can(ctx.actor, entry.spec)) {
-      throw new ToolForbiddenError(name);
-    }
-    if (!await canActorUseTool(ctx.actor, entry.handler)) {
-      throw new ToolForbiddenError(name);
+function extractJson(text) {
+  const candidates = [
+    text,
+    text.match(/\{[\s\S]*\}/)?.[0],
+    text.match(/\[[\s\S]*\]/)?.[0]
+  ];
+  for (const candidate of candidates) {
+    if (candidate === void 0) {
+      continue;
     }
-    const validation = await entry.spec.inputSchema["~standard"].validate(input);
-    if (validation.issues !== void 0) {
-      throw new ToolInputInvalidError(name, validation.issues);
+    try {
+      return JSON.parse(candidate);
+    } catch {
     }
-    return entry.handler.execute(validation.value, ctx);
-  }
-};
-var DefaultRolesPolicy = class {
-  static {
-    __name(this, "DefaultRolesPolicy");
-  }
-  defaultRoles;
-  constructor(defaultRoles = [
-    "ADMIN"
-  ]) {
-    this.defaultRoles = defaultRoles;
   }
-  can(actor, tool) {
-    const allowed = tool.roles ?? this.defaultRoles;
-    return (actor.roles ?? []).some((role) => allowed.includes(role));
+  return void 0;
+}
+__name(extractJson, "extractJson");
+async function validateStructured(schema, text, reported) {
+  const candidate = reported !== void 0 ? reported : extractJson(text);
+  if (candidate === void 0) {
+    return {
+      ok: false,
+      issues: []
+    };
   }
-};
+  const result = await schema["~standard"].validate(candidate);
+  return result.issues !== void 0 ? {
+    ok: false,
+    issues: result.issues
+  } : {
+    ok: true,
+    value: result.value
+  };
+}
+__name(validateStructured, "validateStructured");
+var DEFAULT_STRUCTURED_OUTPUT_INSTRUCTION = "Restate the assistant's final answer as a single JSON value matching the required schema. Use only information already present in the conversation \u2014 add nothing, and answer nothing that was not asked. Reply with ONLY the JSON: no prose, no explanation, no code fences.";
+function repairInstruction(instruction, issues) {
+  const detail = issues.length > 0 ? issues.map((issue4) => `${(issue4.path ?? []).join(".") || "(root)"}: ${issue4.message}`).join("\n") : "the previous reply was not valid JSON";
+  return `${instruction}
 
-// src/agent-loop.ts
-import { createHash } from "node:crypto";
-import { trace } from "@dudousxd/nestjs-diagnostics";
+Your previous reply was rejected:
+${detail}`;
+}
+__name(repairInstruction, "repairInstruction");
 
-// src/diagnostics.ts
-import { emit } from "@dudousxd/nestjs-diagnostics";
-function publishAgentRunStarted(payload) {
-  emit("agent", "run.started", payload);
+// src/elicitation.ts
+function optionValues(question) {
+  return new Set(question.options.map((option) => option.value));
 }
-__name(publishAgentRunStarted, "publishAgentRunStarted");
-function publishAgentMessage(payload) {
-  emit("agent", "message", payload);
+__name(optionValues, "optionValues");
+function normalizeElicitationReply(reply) {
+  if (typeof reply !== "object" || reply === null) {
+    return {
+      answers: {}
+    };
+  }
+  const candidate = reply;
+  if (typeof candidate.answers === "object" && candidate.answers !== null) {
+    return reply;
+  }
+  const answeredByRef = candidate.answeredByRef ?? candidate.executedByRef;
+  return {
+    answers: {},
+    ...candidate.approved === false || candidate.skipped === true ? {
+      skipped: true
+    } : {},
+    ...answeredByRef !== void 0 ? {
+      answeredByRef
+    } : {}
+  };
 }
-__name(publishAgentMessage, "publishAgentMessage");
-function publishAgentToolCall(payload) {
-  emit("agent", "tool-call", payload);
+__name(normalizeElicitationReply, "normalizeElicitationReply");
+function resolveElicitation(request, raw) {
+  const reply = normalizeElicitationReply(raw);
+  const answers = {};
+  const defaulted = [];
+  for (const question of request.questions) {
+    const submitted = reply.skipped === true ? void 0 : reply.answers[question.id];
+    if (submitted === void 0) {
+      answers[question.id] = [
+        ...question.defaults ?? []
+      ];
+      defaulted.push(question.id);
+      continue;
+    }
+    const allowed = optionValues(question);
+    const valid = question.allowFreeText === true ? submitted : submitted.filter((value) => allowed.has(value));
+    answers[question.id] = question.multiple === true ? valid : valid.slice(0, 1);
+  }
+  return {
+    answers,
+    skipped: reply.skipped === true,
+    defaulted
+  };
 }
-__name(publishAgentToolCall, "publishAgentToolCall");
-function publishAgentQuotaExceeded(payload) {
-  emit("agent", "quota.exceeded", payload);
+__name(resolveElicitation, "resolveElicitation");
+function settleElicitation(request, reply) {
+  const outcome = resolveElicitation(request, reply);
+  return {
+    ...outcome,
+    summary: renderElicitationAnswers(request, outcome)
+  };
 }
-__name(publishAgentQuotaExceeded, "publishAgentQuotaExceeded");
-function publishAgentRunFinished(payload) {
-  emit("agent", "run.finished", payload);
+__name(settleElicitation, "settleElicitation");
+function renderElicitationAnswers(request, outcome) {
+  const lines = request.questions.map((question) => {
+    const chosen = outcome.answers[question.id] ?? [];
+    const labels = chosen.map((value) => question.options.find((option) => option.value === value)?.label ?? value);
+    return `${question.prompt} \u2192 ${labels.length > 0 ? labels.join(", ") : "(no answer)"}`;
+  });
+  const preface = outcome.skipped ? "The user declined to answer and asked you to proceed on these assumptions:" : "The user answered:";
+  return `${preface}
+${lines.join("\n")}`;
 }
-__name(publishAgentRunFinished, "publishAgentRunFinished");
-function publishAgentRunFailed(payload) {
-  emit("agent", "run.failed", payload);
-}
-__name(publishAgentRunFailed, "publishAgentRunFailed");
-function publishAgentDelegated(payload) {
-  emit("agent", "delegated", payload);
-}
-__name(publishAgentDelegated, "publishAgentDelegated");
-function publishAgentRetrieved(payload) {
-  emit("agent", "retrieved", payload);
-}
-__name(publishAgentRetrieved, "publishAgentRetrieved");
-function publishAgentToolRetry(payload) {
-  emit("agent", "tool.retry", payload);
-}
-__name(publishAgentToolRetry, "publishAgentToolRetry");
-var AGENT_SPAN_EVENTS = [
-  "llm.turn",
-  "tool.execution",
-  "retrieval",
-  "follow-ups"
-];
-var AGENT_DIAGNOSTIC_EVENTS = [
-  "run.started",
-  "message",
-  "tool-call",
-  "quota.exceeded",
-  "run.finished",
-  "run.failed",
-  "delegated",
-  "retrieved",
-  "tool.retry"
-];
-function agentDiagnosticKey(event) {
-  return `agent:${event}`;
+__name(renderElicitationAnswers, "renderElicitationAnswers");
+var ASK_TOOL_NAME = "ask";
+var MAX_ASK_QUESTIONS = 5;
+function issue(path, message) {
+  return {
+    message,
+    path
+  };
 }
-__name(agentDiagnosticKey, "agentDiagnosticKey");
-
-// src/tool-retry.ts
-function hasTransientShape(error) {
-  if (typeof error !== "object" || error === null) {
-    return false;
+__name(issue, "issue");
+function parseOption(raw, path, issues) {
+  if (typeof raw !== "object" || raw === null) {
+    issues.push(issue(path, "must be an object"));
+    return void 0;
   }
-  const code = "code" in error ? error.code : void 0;
-  const errno = "errno" in error ? error.errno : void 0;
-  const sqlState = "sqlState" in error ? error.sqlState : void 0;
-  if (code === 1213 || code === 1205 || errno === 1213 || errno === 1205) {
-    return true;
+  const candidate = raw;
+  if (typeof candidate.value !== "string" || candidate.value.length === 0) {
+    issues.push(issue([
+      ...path,
+      "value"
+    ], "must be a non-empty string"));
+    return void 0;
   }
-  if (code === "ER_LOCK_DEADLOCK" || code === "ER_LOCK_WAIT_TIMEOUT") {
-    return true;
+  if (typeof candidate.label !== "string" || candidate.label.length === 0) {
+    issues.push(issue([
+      ...path,
+      "label"
+    ], "must be a non-empty string"));
+    return void 0;
   }
-  if (code === "40001" || code === "40P01" || sqlState === "40001" || sqlState === "40P01") {
-    return true;
+  return {
+    value: candidate.value,
+    label: candidate.label,
+    ...typeof candidate.hotkey === "string" ? {
+      hotkey: candidate.hotkey
+    } : {}
+  };
+}
+__name(parseOption, "parseOption");
+function parseQuestion(raw, path, issues) {
+  if (typeof raw !== "object" || raw === null) {
+    issues.push(issue(path, "must be an object"));
+    return void 0;
   }
-  if (code === "SQLITE_BUSY") {
-    return true;
+  const candidate = raw;
+  if (typeof candidate.id !== "string" || candidate.id.length === 0) {
+    issues.push(issue([
+      ...path,
+      "id"
+    ], "must be a non-empty string"));
+    return void 0;
   }
-  const message = "message" in error ? error.message : void 0;
-  return typeof message === "string" && /deadlock|lock wait timeout|serialization failure/i.test(message);
-}
-__name(hasTransientShape, "hasTransientShape");
-function isTransientToolError(error) {
-  if (hasTransientShape(error)) {
-    return true;
+  if (typeof candidate.prompt !== "string" || candidate.prompt.length === 0) {
+    issues.push(issue([
+      ...path,
+      "prompt"
+    ], "must be a non-empty string"));
+    return void 0;
   }
-  if (typeof error === "object" && error !== null && "cause" in error) {
-    const cause = error.cause;
-    if (cause !== void 0 && cause !== error && hasTransientShape(cause)) {
-      return true;
+  if (!Array.isArray(candidate.options) || candidate.options.length === 0) {
+    issues.push(issue([
+      ...path,
+      "options"
+    ], "must be a non-empty array"));
+    return void 0;
+  }
+  const options = [];
+  for (const [index, rawOption] of candidate.options.entries()) {
+    const option = parseOption(rawOption, [
+      ...path,
+      "options",
+      index
+    ], issues);
+    if (option !== void 0) {
+      options.push(option);
     }
   }
-  return false;
-}
-__name(isTransientToolError, "isTransientToolError");
-var DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS = 2;
-var DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS = 150;
-function resolveToolTransientRetryNumbers(setting) {
-  if (setting === false) {
-    return false;
+  if (!Array.isArray(candidate.defaults) || candidate.defaults.length === 0) {
+    issues.push(issue([
+      ...path,
+      "defaults"
+    ], "must pre-pick at least one option \u2014 say what you would choose so the user can just confirm"));
+    return void 0;
+  }
+  const offered = new Set(options.map((option) => option.value));
+  const defaults = candidate.defaults.filter((value) => typeof value === "string" && offered.has(value));
+  if (defaults.length === 0) {
+    issues.push(issue([
+      ...path,
+      "defaults"
+    ], "must name values that appear in this question's options"));
+    return void 0;
   }
   return {
-    attempts: setting?.attempts ?? DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS,
-    backoffMs: setting?.backoffMs ?? DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS
+    id: candidate.id,
+    prompt: candidate.prompt,
+    options,
+    defaults,
+    ...candidate.multiple === true ? {
+      multiple: true
+    } : {},
+    ...candidate.allowFreeText === true ? {
+      allowFreeText: true
+    } : {}
   };
 }
-__name(resolveToolTransientRetryNumbers, "resolveToolTransientRetryNumbers");
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-__name(delay, "delay");
-async function invokeWithTransientRetry(fn, setting, options) {
-  if (setting === false) {
-    return fn();
-  }
-  const attempts = setting.attempts ?? DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS;
-  const backoffMs = setting.backoffMs ?? DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS;
-  const classify = setting.classify ?? isTransientToolError;
-  let attempt = 1;
-  for (; ; ) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (options?.isControlFlowError?.(error) === true) {
-        throw error;
+__name(parseQuestion, "parseQuestion");
+var ASK_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    preamble: {
+      type: "string",
+      description: 'One sentence shown above the form, e.g. "Three questions before I start. I have pre-picked what I would choose, so confirming is enough."'
+    },
+    questions: {
+      type: "array",
+      minItems: 1,
+      maxItems: MAX_ASK_QUESTIONS,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "id",
+          "prompt",
+          "options",
+          "defaults"
+        ],
+        properties: {
+          id: {
+            type: "string",
+            description: "Unique within this call; answers come back under it."
+          },
+          prompt: {
+            type: "string"
+          },
+          multiple: {
+            type: "boolean",
+            description: "Allow more than one option to be chosen."
+          },
+          allowFreeText: {
+            type: "boolean",
+            description: "Accept an answer that is not an option."
+          },
+          defaults: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "string"
+            },
+            description: "REQUIRED. The option values you would pick yourself, so the user can confirm rather than decide."
+          },
+          options: {
+            type: "array",
+            minItems: 2,
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: [
+                "value",
+                "label"
+              ],
+              properties: {
+                value: {
+                  type: "string"
+                },
+                label: {
+                  type: "string"
+                },
+                hotkey: {
+                  type: "string",
+                  maxLength: 1
+                }
+              }
+            }
+          }
+        }
       }
-      const attemptsRemain = attempt < attempts;
-      if (!attemptsRemain || !classify(error)) {
-        throw error;
+    }
+  },
+  required: [
+    "questions"
+  ]
+};
+var askInputSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "nestjs-agent",
+    validate: /* @__PURE__ */ __name((value) => {
+      const issues = [];
+      if (typeof value !== "object" || value === null) {
+        return {
+          issues: [
+            issue([], "must be an object")
+          ]
+        };
       }
-      options?.onRetry?.(attempt, error);
-      await delay(backoffMs * attempt);
-      attempt += 1;
+      const candidate = value;
+      if (!Array.isArray(candidate.questions) || candidate.questions.length === 0) {
+        return {
+          issues: [
+            issue([
+              "questions"
+            ], "must be a non-empty array")
+          ]
+        };
+      }
+      if (candidate.questions.length > MAX_ASK_QUESTIONS) {
+        return {
+          issues: [
+            issue([
+              "questions"
+            ], `must hold at most ${MAX_ASK_QUESTIONS} questions`)
+          ]
+        };
+      }
+      const questions = [];
+      for (const [index, raw] of candidate.questions.entries()) {
+        const question = parseQuestion(raw, [
+          "questions",
+          index
+        ], issues);
+        if (question !== void 0) {
+          questions.push(question);
+        }
+      }
+      if (issues.length > 0) {
+        return {
+          issues
+        };
+      }
+      return {
+        value: {
+          questions,
+          ...typeof candidate.preamble === "string" ? {
+            preamble: candidate.preamble
+          } : {}
+        }
+      };
+    }, "validate"),
+    jsonSchema: {
+      input: /* @__PURE__ */ __name(() => ASK_JSON_SCHEMA, "input")
     }
   }
+};
+var ASK_TOOL_DESCRIPTION = "Ask the user to settle the scope of the work before you do it. Use it when a reasonable person would produce a materially different result depending on the answer \u2014 not to confirm something the conversation already says. Every question must pre-pick the answer you would choose, so the user can confirm instead of deciding. The user may decline, in which case you proceed on those pre-picked answers.";
+function askToolDefinition() {
+  return {
+    name: ASK_TOOL_NAME,
+    kind: "ask",
+    description: ASK_TOOL_DESCRIPTION,
+    inputSchema: askInputSchema
+  };
 }
-__name(invokeWithTransientRetry, "invokeWithTransientRetry");
+__name(askToolDefinition, "askToolDefinition");
+var DEFAULT_INTAKE_PREAMBLE = "A few questions before I start. I have pre-picked what I would choose, so confirming is enough.";
 
-// src/agent-loop.ts
-function resolveCostUsd(usage, reportedCostUsd, price) {
-  if (reportedCostUsd !== void 0) {
-    return reportedCostUsd;
-  }
-  return price === void 0 ? null : estimateCost(usage, price);
+// src/skills.ts
+var GLOBAL_SCOPE = "global";
+function actorScope(actor) {
+  return `actor:${actor.id}`;
 }
-__name(resolveCostUsd, "resolveCostUsd");
-function buildContextBlock(passages) {
-  const items = passages.map((passage, index) => {
-    const label = passage.source !== void 0 ? ` (${passage.source})` : "";
-    return `[${index + 1}]${label} ${passage.text}`;
-  }).join("\n\n");
-  return `<retrieved_context>
-${items}
-</retrieved_context>
-Use the retrieved context above to answer when relevant, and cite sources by their bracket number.`;
+__name(actorScope, "actorScope");
+function tenantScope(tenantRef) {
+  return `tenant:${tenantRef}`;
 }
-__name(buildContextBlock, "buildContextBlock");
-var QuotaExceededError = class extends Error {
-  static {
-    __name(this, "QuotaExceededError");
-  }
-  constructor() {
-    super("Daily token quota exceeded");
-    this.name = "QuotaExceededError";
-  }
+__name(tenantScope, "tenantScope");
+var defaultScopeResolver = {
+  resolve: /* @__PURE__ */ __name(({ actor }) => [
+    actorScope(actor),
+    ...actor.tenantRef !== void 0 ? [
+      tenantScope(actor.tenantRef)
+    ] : [],
+    GLOBAL_SCOPE
+  ], "resolve")
 };
-var MAX_DELEGATION_DEPTH = 5;
-async function resolvePrompt(prompt, ctx) {
-  return typeof prompt === "function" ? prompt(ctx) : prompt;
+function staticSkillProvider(skills) {
+  return {
+    list: /* @__PURE__ */ __name(({ scopes }) => skills.filter((skill) => scopes.includes(skill.scope)), "list"),
+    load: /* @__PURE__ */ __name(({ name, scope }) => skills.find((skill) => skill.name === name && skill.scope === scope)?.body ?? null, "load")
+  };
 }
-__name(resolvePrompt, "resolvePrompt");
-async function resolveSystemPrompt(deps, input) {
-  const ctx = {
-    actor: input.actor,
-    agentName: input.agentName ?? "default",
-    ...input.pageContext !== void 0 ? {
-      pageContext: input.pageContext
-    } : {}
+__name(staticSkillProvider, "staticSkillProvider");
+function compositeSkillProvider(providers) {
+  return {
+    list: /* @__PURE__ */ __name(async ({ scopes, ctx }) => {
+      const seen = /* @__PURE__ */ new Set();
+      const merged = [];
+      for (const provider of providers) {
+        for (const summary of await provider.list({
+          scopes,
+          ctx
+        })) {
+          const key = `${summary.scope}\0${summary.name}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            merged.push(summary);
+          }
+        }
+      }
+      return merged;
+    }, "list"),
+    load: /* @__PURE__ */ __name(async ({ name, scope, ctx }) => {
+      for (const provider of providers) {
+        const body = await provider.load({
+          name,
+          scope,
+          ctx
+        });
+        if (body !== null) {
+          return body;
+        }
+      }
+      return null;
+    }, "load")
   };
-  const sections = [
-    await resolvePrompt(deps.systemPrompt, ctx)
-  ];
-  for (const contribute of deps.promptContributors ?? []) {
-    const section = await contribute(ctx);
-    if (section !== null && section.length > 0) {
-      sections.push(section);
+}
+__name(compositeSkillProvider, "compositeSkillProvider");
+var DEFAULT_MAX_SKILLS = 20;
+function resolveSkillCatalog(summaries, scopes, maxSkills = DEFAULT_MAX_SKILLS) {
+  const rank = new Map(scopes.map((scope, index) => [
+    scope,
+    index
+  ]));
+  const byName = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    if (!rank.has(summary.scope)) {
+      continue;
+    }
+    const existing = byName.get(summary.name);
+    if (existing === void 0) {
+      byName.set(summary.name, [
+        summary
+      ]);
+    } else {
+      existing.push(summary);
     }
   }
-  return sections.join("\n\n");
-}
-__name(resolveSystemPrompt, "resolveSystemPrompt");
-function extractTask(input) {
-  if (typeof input === "object" && input !== null && "task" in input) {
-    const task = input.task;
-    if (typeof task === "string") {
-      return task;
+  const resolved = [];
+  for (const candidates of byName.values()) {
+    const ordered = [
+      ...candidates
+    ].sort((a, b) => (rank.get(a.scope) ?? 0) - (rank.get(b.scope) ?? 0));
+    const winner = ordered[0];
+    if (winner === void 0) {
+      continue;
     }
+    const shadows = ordered.slice(1).map((candidate) => candidate.scope);
+    resolved.push({
+      name: winner.name,
+      description: winner.description,
+      scope: winner.scope,
+      ...shadows.length > 0 ? {
+        shadows
+      } : {}
+    });
   }
-  return JSON.stringify(input);
+  resolved.sort((a, b) => {
+    const byScope = (rank.get(a.scope) ?? 0) - (rank.get(b.scope) ?? 0);
+    return byScope !== 0 ? byScope : compare(a.name, b.name);
+  });
+  return {
+    entries: resolved.slice(0, maxSkills),
+    omitted: Math.max(0, resolved.length - maxSkills)
+  };
 }
-__name(extractTask, "extractTask");
-function deriveTitle(userText) {
-  const trimmed = userText.trim().replace(/\s+/g, " ");
-  return trimmed.length > 60 ? `${trimmed.slice(0, 57)}...` : trimmed || "New chat";
+__name(resolveSkillCatalog, "resolveSkillCatalog");
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
 }
-__name(deriveTitle, "deriveTitle");
-var ToolTimeoutError = class ToolTimeoutError2 extends Error {
-  static {
-    __name(this, "ToolTimeoutError");
-  }
-  constructor(toolName, ms) {
-    super(`Tool "${toolName}" exceeded its ${ms}ms timeout`);
-    this.name = "ToolTimeoutError";
+__name(compare, "compare");
+async function offerSkills(config, ctx) {
+  const scopes = await (config.scopes ?? defaultScopeResolver).resolve(ctx);
+  const summaries = await config.provider.list({
+    scopes,
+    ctx
+  });
+  return {
+    scopes,
+    ...resolveSkillCatalog(summaries, scopes, config.maxSkills)
+  };
+}
+__name(offerSkills, "offerSkills");
+function buildSkillsBlock(entries) {
+  const lines = entries.map((entry) => {
+    const shadows = entry.shadows === void 0 ? "" : ` (overrides the one from ${entry.shadows.join(", ")})`;
+    return `- ${entry.name} [${entry.scope}] \u2014 ${entry.description}${shadows}`;
+  });
+  return `<skills>
+Procedures available to you. Each line is a name, the scope it came from, and what it covers \u2014 not the procedure itself.
+Call the \`${SKILL_TOOL_NAME}\` tool with a name from this list to read one BEFORE doing the task it covers, and follow what it says; never guess its contents from the description.
+A skill from a narrower scope overrides a same-named one from a wider scope. When you follow one that overrides another, say which scope it came from, so the user knows their setting differs from the wider default.
+${lines.join("\n")}
+</skills>`;
+}
+__name(buildSkillsBlock, "buildSkillsBlock");
+var SKILL_TOOL_NAME = "skill";
+var SKILL_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "name"
+  ],
+  properties: {
+    name: {
+      type: "string",
+      description: "The name of a skill from the <skills> list, exactly as written there."
+    }
   }
 };
-function withToolTimeout(work, ms, toolName) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new ToolTimeoutError(toolName, ms)), ms);
-    work.then((value) => {
-      clearTimeout(timer);
-      resolve(value);
-    }, (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-  });
+function issue2(path, message) {
+  return {
+    message,
+    path
+  };
 }
-__name(withToolTimeout, "withToolTimeout");
-function parseFollowUps(text, count) {
-  const source = text.match(/\[[\s\S]*\]/)?.[0] ?? text;
-  try {
-    const parsed = JSON.parse(source);
-    if (Array.isArray(parsed)) {
-      return parsed.filter((item) => typeof item === "string").slice(0, count);
+__name(issue2, "issue");
+var skillInputSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "nestjs-agent",
+    validate: /* @__PURE__ */ __name((value) => {
+      if (typeof value !== "object" || value === null) {
+        return {
+          issues: [
+            issue2([], "must be an object")
+          ]
+        };
+      }
+      const candidate = value;
+      if (typeof candidate.name !== "string" || candidate.name.length === 0) {
+        return {
+          issues: [
+            issue2([
+              "name"
+            ], "must be a non-empty string")
+          ]
+        };
+      }
+      return {
+        value: {
+          name: candidate.name
+        }
+      };
+    }, "validate"),
+    jsonSchema: {
+      input: /* @__PURE__ */ __name(() => SKILL_JSON_SCHEMA, "input")
     }
-  } catch {
   }
-  return [];
+};
+var SKILL_TOOL_DESCRIPTION = "Read one of the procedures listed in <skills>. Call it before doing a task a listed skill covers, and follow what it returns. It performs nothing and changes nothing \u2014 it only gives you instructions you do not yet have.";
+function skillToolDefinition() {
+  return {
+    name: SKILL_TOOL_NAME,
+    kind: "skill",
+    description: SKILL_TOOL_DESCRIPTION,
+    inputSchema: skillInputSchema
+  };
 }
-__name(parseFollowUps, "parseFollowUps");
-async function generateFollowUps(model, messages, count) {
-  const discard = {
-    write: /* @__PURE__ */ __name(() => {
-    }, "write"),
-    end: /* @__PURE__ */ __name(() => {
+__name(skillToolDefinition, "skillToolDefinition");
+function withSkillTool({ tools, enabled }) {
+  return enabled ? [
+    ...tools,
+    skillToolDefinition()
+  ] : tools;
+}
+__name(withSkillTool, "withSkillTool");
+async function loadSkill(config, offer, name, ctx) {
+  const entry = offer.entries.find((candidate) => candidate.name === name);
+  if (entry === void 0) {
+    const available = offer.entries.map((candidate) => candidate.name).join(", ");
+    return {
+      ok: false,
+      error: available.length === 0 ? `No skill named "${name}" is available to you, and no others are either.` : `No skill named "${name}" is available to you. Available: ${available}.`
+    };
+  }
+  const body = await config.provider.load({
+    name: entry.name,
+    scope: entry.scope,
+    ctx
+  });
+  if (body === null) {
+    return {
+      ok: false,
+      error: `Skill "${name}" is listed but its body could not be read.`
+    };
+  }
+  return {
+    ok: true,
+    skill: {
+      name: entry.name,
+      description: entry.description,
+      scope: entry.scope,
+      body
+    },
+    ...entry.shadows !== void 0 ? {
+      shadows: entry.shadows
+    } : {}
+  };
+}
+__name(loadSkill, "loadSkill");
+function skillWriteVerdict(request) {
+  const { scope, scopes, author, actor } = request;
+  if (!scopes.includes(scope)) {
+    return {
+      allowed: false,
+      reason: `"${scope}" is not a scope this actor belongs to`
+    };
+  }
+  const own = actorScope(actor);
+  if (scope === own) {
+    return {
+      allowed: true
+    };
+  }
+  if (author.kind !== "human") {
+    return {
+      allowed: false,
+      reason: `only a human may author a skill at "${scope}"; an agent may write only at "${own}"`
+    };
+  }
+  return request.elevated === true ? {
+    allowed: true
+  } : {
+    allowed: false,
+    reason: `authoring at "${scope}" requires an elevated human author`
+  };
+}
+__name(skillWriteVerdict, "skillWriteVerdict");
+
+// src/memory.ts
+var DEFAULT_MAX_MEMORIES = 20;
+var DEFAULT_MAX_FACT_CHARS = 240;
+function resolveMemoryDigest({ records, scopes, maxMemories = DEFAULT_MAX_MEMORIES, ranked = false }) {
+  const rank = new Map(scopes.map((scope, index) => [
+    scope,
+    index
+  ]));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of records) {
+    if (!rank.has(entry.scope)) {
+      continue;
+    }
+    const existing = byKey.get(entry.key);
+    if (existing === void 0) {
+      byKey.set(entry.key, [
+        entry
+      ]);
+    } else {
+      existing.push(entry);
+    }
+  }
+  const resolved = [];
+  for (const candidates of byKey.values()) {
+    const ordered = [
+      ...candidates
+    ].sort((a, b) => (rank.get(a.scope) ?? 0) - (rank.get(b.scope) ?? 0));
+    const winner = ordered[0];
+    if (winner === void 0) {
+      continue;
+    }
+    const overrides = ordered.slice(1).map((beaten) => ({
+      scope: beaten.scope,
+      text: beaten.text,
+      author: beaten.origin.author
+    }));
+    const pinned = ordered.some((candidate) => candidate.pinned === true);
+    resolved.push({
+      ...winner,
+      ...pinned ? {
+        pinned: true
+      } : {},
+      ...overrides.length > 0 ? {
+        overrides
+      } : {}
+    });
+  }
+  const byPrecedence = /* @__PURE__ */ __name((a, b) => (rank.get(a.scope) ?? 0) - (rank.get(b.scope) ?? 0) || compare2(b.updatedAt, a.updatedAt) || compare2(a.key, b.key), "byPrecedence");
+  const selected = resolved.map((entry, index) => ({
+    entry,
+    index
+  })).sort((a, b) => pinRank(a.entry) - pinRank(b.entry) || (ranked && a.entry.pinned !== true ? a.index - b.index : byPrecedence(a.entry, b.entry))).slice(0, maxMemories).map((candidate) => candidate.entry);
+  const pinnedOmitted = resolved.filter((entry) => entry.pinned === true).length - selected.filter((entry) => entry.pinned === true).length;
+  selected.sort((a, b) => pinRank(a) - pinRank(b) || (rank.get(a.scope) ?? 0) - (rank.get(b.scope) ?? 0) || compare2(a.key, b.key));
+  return {
+    entries: selected,
+    omitted: Math.max(0, resolved.length - maxMemories),
+    pinnedOmitted
+  };
+}
+__name(resolveMemoryDigest, "resolveMemoryDigest");
+function pinRank(entry) {
+  return entry.pinned === true ? 0 : 1;
+}
+__name(pinRank, "pinRank");
+function compare2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+__name(compare2, "compare");
+async function offerMemories({ config, ctx, query }) {
+  const scopes = await (config.scopes ?? defaultScopeResolver).resolve(ctx);
+  const maxMemories = config.maxMemories ?? DEFAULT_MAX_MEMORIES;
+  const trimmed = query?.trim() ?? "";
+  const search = trimmed.length > 0 ? config.provider.search : void 0;
+  const records = search !== void 0 ? await search({
+    scopes,
+    query: trimmed,
+    limit: maxMemories,
+    ctx
+  }) : await config.provider.list({
+    scopes,
+    ctx
+  });
+  return {
+    scopes,
+    recalled: search !== void 0,
+    ...resolveMemoryDigest({
+      records,
+      scopes,
+      maxMemories,
+      ranked: search !== void 0
+    })
+  };
+}
+__name(offerMemories, "offerMemories");
+var ASSERTED_FRAMING = "Stated by people. A person wrote each of these deliberately \u2014 the user about themselves, or someone administering their organisation. Treat them as you would any other instruction you were given. If the user says something that contradicts one, say which note it conflicts with and at what scope it is held, rather than quietly setting it aside.";
+var CONCLUDED_FRAMING = "Concluded by you. These are your own notes from earlier turns, not documents anyone wrote: they may be wrong or out of date, so prefer what the user says now, and say where a note came from if you act on it.";
+var PARTIAL_FRAMING = "You are being shown a selection, not everything on file. Other notes exist that are not in this list, so never read something\u2019s absence from it as evidence that it was never recorded.";
+function memorySection(framing, entries) {
+  if (entries.length === 0) {
+    return [];
+  }
+  return [
+    framing,
+    ...entries.flatMap((entry) => [
+      `- [${entry.scope}] ${entry.key}: ${entry.text}`,
+      ...(entry.overrides ?? []).map((beaten) => `    \u21B3 [${beaten.scope}] ${beaten.author === "human" ? "a person stated" : "instead has"}: ${beaten.text}`)
+    ])
+  ];
+}
+__name(memorySection, "memorySection");
+function buildMemoryBlock({ entries, writable, partial }) {
+  const writeLine = writable ? [
+    `When you learn something durable about this user, record it with the \`${REMEMBER_TOOL_NAME}\` tool; when one of these turns out to be wrong, record the corrected fact under the same key. What you record that way is one of your own notes, not something stated by a person.`
+  ] : [];
+  const body = [
+    "What is on file about this user and their organisation, carried over from earlier conversations. Each line is a scope, a key and the fact. A narrower scope overrides a wider one; where the wider value is shown underneath, tell the user their setting differs from it rather than silently choosing one.",
+    ...partial ? [
+      PARTIAL_FRAMING
+    ] : [],
+    ...writeLine,
+    // People before inferences: the model meets what it was told before what it worked out.
+    ...memorySection(ASSERTED_FRAMING, entries.filter((entry) => entry.origin.author === "human")),
+    ...memorySection(CONCLUDED_FRAMING, entries.filter((entry) => entry.origin.author !== "human"))
+  ];
+  return `<memory>
+${body.join("\n")}
+</memory>`;
+}
+__name(buildMemoryBlock, "buildMemoryBlock");
+var REMEMBER_TOOL_NAME = "remember";
+var REMEMBER_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "key",
+    "fact"
+  ],
+  properties: {
+    key: {
+      type: "string",
+      description: 'A short, stable handle for what this fact is ABOUT (e.g. "fiscal-year", "preferred-units"). Reusing an existing key replaces that fact rather than adding a second one.'
+    },
+    fact: {
+      type: "string",
+      description: "The fact itself, in one sentence, stated so it still makes sense in a conversation months from now."
+    }
+  }
+};
+function issue3(path, message) {
+  return {
+    message,
+    path
+  };
+}
+__name(issue3, "issue");
+var rememberInputSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "nestjs-agent",
+    validate: /* @__PURE__ */ __name((value) => {
+      if (typeof value !== "object" || value === null) {
+        return {
+          issues: [
+            issue3([], "must be an object")
+          ]
+        };
+      }
+      const candidate = value;
+      if (typeof candidate.key !== "string" || candidate.key.length === 0) {
+        return {
+          issues: [
+            issue3([
+              "key"
+            ], "must be a non-empty string")
+          ]
+        };
+      }
+      if (typeof candidate.fact !== "string" || candidate.fact.length === 0) {
+        return {
+          issues: [
+            issue3([
+              "fact"
+            ], "must be a non-empty string")
+          ]
+        };
+      }
+      return {
+        value: {
+          key: candidate.key,
+          fact: candidate.fact
+        }
+      };
+    }, "validate"),
+    jsonSchema: {
+      input: /* @__PURE__ */ __name(() => REMEMBER_JSON_SCHEMA, "input")
+    }
+  }
+};
+var REMEMBER_TOOL_DESCRIPTION = "Record one durable fact about this user under a key, so later conversations start knowing it. For things that will still be true another day \u2014 how they work, what their organisation requires, a correction they made. Not for what this conversation is about, and not for anything you were not told or could not reasonably infer. The user can read and delete everything you record here.";
+function rememberToolDefinition() {
+  return {
+    name: REMEMBER_TOOL_NAME,
+    kind: "memory",
+    description: REMEMBER_TOOL_DESCRIPTION,
+    inputSchema: rememberInputSchema
+  };
+}
+__name(rememberToolDefinition, "rememberToolDefinition");
+function withMemoryTool({ tools, enabled }) {
+  return enabled ? [
+    ...tools,
+    rememberToolDefinition()
+  ] : tools;
+}
+__name(withMemoryTool, "withMemoryTool");
+function memoryWriteVerdict(request) {
+  const { scope, scopes, author, actor } = request;
+  if (!scopes.includes(scope)) {
+    return {
+      allowed: false,
+      reason: `"${scope}" is not a scope this actor belongs to`
+    };
+  }
+  const own = actorScope(actor);
+  if (scope === own) {
+    return {
+      allowed: true
+    };
+  }
+  if (author.kind !== "human") {
+    return {
+      allowed: false,
+      reason: `only a human may write a memory at "${scope}"; an agent may write only at "${own}"`
+    };
+  }
+  return request.elevated === true ? {
+    allowed: true
+  } : {
+    allowed: false,
+    reason: `writing at "${scope}" requires an elevated human author`
+  };
+}
+__name(memoryWriteVerdict, "memoryWriteVerdict");
+function memoryForgetVerdict({ record, actor }) {
+  return record.scope === actorScope(actor) ? {
+    allowed: true
+  } : {
+    allowed: false,
+    reason: `"${record.scope}" is not this actor's own scope; deleting it is an administrative action`
+  };
+}
+__name(memoryForgetVerdict, "memoryForgetVerdict");
+async function writeMemory({ config, digest, call, ctx, runId }) {
+  const write = config.provider.write;
+  if (write === void 0) {
+    return {
+      ok: false,
+      error: "Memory is read-only in this deployment."
+    };
+  }
+  const key = call.key.trim();
+  const text = call.fact.trim();
+  if (key.length === 0 || text.length === 0) {
+    return {
+      ok: false,
+      error: "A memory needs both a key and a fact."
+    };
+  }
+  const maxFactChars = config.maxFactChars ?? DEFAULT_MAX_FACT_CHARS;
+  if (text.length > maxFactChars) {
+    return {
+      ok: false,
+      error: `A memory must be at most ${maxFactChars} characters; that was ${text.length}. State the fact more briefly.`
+    };
+  }
+  const scope = actorScope(ctx.actor);
+  const verdict = memoryWriteVerdict({
+    scope,
+    actor: ctx.actor,
+    scopes: digest.scopes,
+    author: {
+      kind: "agent",
+      actorRef: ctx.actor.id
+    }
+  });
+  if (!verdict.allowed) {
+    return {
+      ok: false,
+      error: verdict.reason
+    };
+  }
+  const record = await write({
+    key,
+    text,
+    scope,
+    origin: {
+      author: "agent",
+      threadId: ctx.threadId,
+      runId,
+      actorRef: ctx.actor.id
+    },
+    ctx
+  });
+  return {
+    ok: true,
+    record
+  };
+}
+__name(writeMemory, "writeMemory");
+
+// src/agent-registry.ts
+var AgentRegistry = class {
+  static {
+    __name(this, "AgentRegistry");
+  }
+  definitions = /* @__PURE__ */ new Map();
+  register(definition) {
+    this.definitions.set(definition.name, definition);
+  }
+  get(name) {
+    return this.definitions.get(name);
+  }
+  has(name) {
+    return this.definitions.has(name);
+  }
+  list() {
+    return [
+      ...this.definitions.values()
+    ];
+  }
+};
+
+// src/replay-integrity.ts
+function isReplayIntegrityError(error) {
+  return error instanceof Error && error.name.toLowerCase().endsWith("nondeterminismerror");
+}
+__name(isReplayIntegrityError, "isReplayIntegrityError");
+
+// src/control-flow.ts
+var CONTROL_FLOW_SIGNAL = Symbol.for("aviary:durable:control-flow");
+function isControlFlowSignal(error) {
+  return typeof error === "object" && error !== null && error[CONTROL_FLOW_SIGNAL] === true;
+}
+__name(isControlFlowSignal, "isControlFlowSignal");
+
+// src/delegation.ts
+function normalizeDelegation(entry) {
+  return typeof entry === "string" ? {
+    agent: entry,
+    detached: false
+  } : {
+    agent: entry.agent,
+    detached: entry.detached === true
+  };
+}
+__name(normalizeDelegation, "normalizeDelegation");
+function detachedStarted(args) {
+  return {
+    detached: true,
+    status: "started",
+    agent: args.agent,
+    runId: args.runId,
+    note: `The "${args.agent}" agent is now working on this in the background. Its answer is NOT part of this turn and will arrive in this conversation as a separate message when it is ready. Tell the user the work has started; do not state or guess what it will find.`
+  };
+}
+__name(detachedStarted, "detachedStarted");
+function detachedDelivered(args) {
+  return {
+    detached: true,
+    status: "delivered",
+    agent: args.agent,
+    runId: args.runId,
+    text: args.text
+  };
+}
+__name(detachedDelivered, "detachedDelivered");
+function detachedUnsettled(args) {
+  return {
+    detached: true,
+    status: args.status,
+    agent: args.agent,
+    runId: args.runId,
+    ...args.error !== void 0 ? {
+      error: args.error
+    } : {}
+  };
+}
+__name(detachedUnsettled, "detachedUnsettled");
+async function settleUnsettledDelegation(args) {
+  const { store, delivery, agent, runId, status } = args;
+  if (await store.getThread(delivery.threadId) === null) {
+    return;
+  }
+  await store.appendMessage({
+    threadId: delivery.threadId,
+    role: "assistant",
+    content: status === "cancelled" ? `The "${agent}" agent was stopped before it could answer.` : `The "${agent}" agent stopped before it could answer: ${args.error ?? "unknown error"}`,
+    agentName: agent,
+    runId
+  });
+  await store.updateToolCall({
+    toolCallId: delivery.toolCallId,
+    status: "executed",
+    output: detachedUnsettled({
+      agent,
+      runId,
+      status,
+      ...args.error !== void 0 ? {
+        error: args.error
+      } : {}
+    })
+  });
+}
+__name(settleUnsettledDelegation, "settleUnsettledDelegation");
+
+// src/tool-registry.ts
+var ToolForbiddenError = class extends Error {
+  static {
+    __name(this, "ToolForbiddenError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" is not allowed for this role`), this.toolName = toolName;
+    this.name = "ToolForbiddenError";
+  }
+};
+var ToolDisabledError = class extends Error {
+  static {
+    __name(this, "ToolDisabledError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" is disabled in this deployment`), this.toolName = toolName;
+    this.name = "ToolDisabledError";
+  }
+};
+var ToolNotFoundError = class extends Error {
+  static {
+    __name(this, "ToolNotFoundError");
+  }
+  toolName;
+  constructor(toolName) {
+    super(`Tool "${toolName}" is not registered`), this.toolName = toolName;
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolInputInvalidError = class extends Error {
+  static {
+    __name(this, "ToolInputInvalidError");
+  }
+  toolName;
+  issues;
+  constructor(toolName, issues) {
+    super(`Invalid input for tool "${toolName}": ${issues.map((issue4) => issue4.message).join("; ")}`), this.toolName = toolName, this.issues = issues;
+    this.name = "ToolInputInvalidError";
+  }
+};
+var ToolRegistry = class {
+  static {
+    __name(this, "ToolRegistry");
+  }
+  entries = /* @__PURE__ */ new Map();
+  register(spec, handler) {
+    this.entries.set(spec.name, {
+      spec,
+      handler
+    });
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  spec(name) {
+    return this.entries.get(name)?.spec;
+  }
+  allSpecs() {
+    return [
+      ...this.entries.values()
+    ].map((entry) => entry.spec);
+  }
+  /**
+  * The tools to offer the model for this actor+agent, after the four filter layers: what this
+  * agent pinned, what this deployment has enabled, what this actor's role allows, and what each
+  * tool's own `canUse` allows this actor.
+  *
+  * Every layer only ever removes tools, so no arrangement of them can widen what a turn reaches.
+  * The agent's allow-list therefore goes FIRST, even though it is the narrowest statement: it is a
+  * pure name-set match, while each of the three below it may be a round trip — an authz service, a
+  * feature-flag store, an MCP server — and this runs once per model step. Asking those about a
+  * tool the allow-list has already excluded is a call whose answer nothing reads.
+  */
+  async definitionsFor(actor, policy, allowedTools) {
+    const pinnedNames = new Set(filterToolsByAllowList(this.allSpecs(), allowedTools).map((spec) => spec.name));
+    const pinned = [
+      ...this.entries.values()
+    ].filter((entry) => pinnedNames.has(entry.spec.name));
+    const live = await filterToolsByEnabled(pinned);
+    const allowedByRole = new Set((await filterToolsByRole(live.map((entry) => entry.spec), actor, policy)).map((spec) => spec.name));
+    const roleScoped = live.filter((entry) => allowedByRole.has(entry.spec.name));
+    const actorScoped = await filterToolsByCanUse(roleScoped, actor);
+    return actorScoped.map(({ spec }) => ({
+      name: spec.name,
+      kind: spec.kind,
+      description: spec.description,
+      inputSchema: spec.inputSchema
+    }));
+  }
+  /**
+  * Run a tool. Re-checks that the tool is enabled and that the role allows it (defense-in-depth —
+  * a call can reach here from a replayed durable step or an approval granted before the flag
+  * moved, neither of which went through `definitionsFor` again) and re-parses the input via Zod.
+  */
+  async invoke(name, input, ctx, policy) {
+    const entry = this.entries.get(name);
+    if (entry === void 0) {
+      throw new ToolNotFoundError(name);
+    }
+    if (!await isToolEnabled(entry.spec, entry.handler)) {
+      throw new ToolDisabledError(name);
+    }
+    if (!await policy.can(ctx.actor, entry.spec)) {
+      throw new ToolForbiddenError(name);
+    }
+    if (!await canActorUseTool(ctx.actor, entry.handler)) {
+      throw new ToolForbiddenError(name);
+    }
+    const validation = await entry.spec.inputSchema["~standard"].validate(input);
+    if (validation.issues !== void 0) {
+      throw new ToolInputInvalidError(name, validation.issues);
+    }
+    return entry.handler.execute(validation.value, ctx);
+  }
+};
+var DefaultRolesPolicy = class {
+  static {
+    __name(this, "DefaultRolesPolicy");
+  }
+  defaultRoles;
+  constructor(defaultRoles = [
+    "ADMIN"
+  ]) {
+    this.defaultRoles = defaultRoles;
+  }
+  can(actor, tool) {
+    const allowed = tool.roles ?? this.defaultRoles;
+    return (actor.roles ?? []).some((role) => allowed.includes(role));
+  }
+};
+
+// src/agent-loop.ts
+import { createHash } from "node:crypto";
+import { trace } from "@dudousxd/nestjs-diagnostics";
+
+// src/diagnostics.ts
+import { emit } from "@dudousxd/nestjs-diagnostics";
+function publishAgentRunStarted(payload) {
+  emit("agent", "run.started", payload);
+}
+__name(publishAgentRunStarted, "publishAgentRunStarted");
+function publishAgentMessage(payload) {
+  emit("agent", "message", payload);
+}
+__name(publishAgentMessage, "publishAgentMessage");
+function publishAgentToolCall(payload) {
+  emit("agent", "tool-call", payload);
+}
+__name(publishAgentToolCall, "publishAgentToolCall");
+function publishAgentQuotaExceeded(payload) {
+  emit("agent", "quota.exceeded", payload);
+}
+__name(publishAgentQuotaExceeded, "publishAgentQuotaExceeded");
+function publishAgentRunFinished(payload) {
+  emit("agent", "run.finished", payload);
+}
+__name(publishAgentRunFinished, "publishAgentRunFinished");
+function publishAgentRunFailed(payload) {
+  emit("agent", "run.failed", payload);
+}
+__name(publishAgentRunFailed, "publishAgentRunFailed");
+function publishAgentDelegated(payload) {
+  emit("agent", "delegated", payload);
+}
+__name(publishAgentDelegated, "publishAgentDelegated");
+function publishAgentRetrieved(payload) {
+  emit("agent", "retrieved", payload);
+}
+__name(publishAgentRetrieved, "publishAgentRetrieved");
+function publishAgentToolRetry(payload) {
+  emit("agent", "tool.retry", payload);
+}
+__name(publishAgentToolRetry, "publishAgentToolRetry");
+function publishAgentSkillsResolved(payload) {
+  emit("agent", "skills.resolved", payload);
+}
+__name(publishAgentSkillsResolved, "publishAgentSkillsResolved");
+function publishAgentMemoryResolved(payload) {
+  emit("agent", "memory.resolved", payload);
+}
+__name(publishAgentMemoryResolved, "publishAgentMemoryResolved");
+function publishAgentMemoryWritten(payload) {
+  emit("agent", "memory.written", payload);
+}
+__name(publishAgentMemoryWritten, "publishAgentMemoryWritten");
+var AGENT_SPAN_EVENTS = [
+  "llm.turn",
+  "tool.execution",
+  "retrieval",
+  "follow-ups"
+];
+var AGENT_DIAGNOSTIC_EVENTS = [
+  "run.started",
+  "message",
+  "tool-call",
+  "quota.exceeded",
+  "run.finished",
+  "run.failed",
+  "delegated",
+  "retrieved",
+  "skills.resolved",
+  "memory.resolved",
+  "memory.written",
+  "tool.retry"
+];
+function agentDiagnosticKey(event) {
+  return `agent:${event}`;
+}
+__name(agentDiagnosticKey, "agentDiagnosticKey");
+
+// src/tool-retry.ts
+function hasTransientShape(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const code = "code" in error ? error.code : void 0;
+  const errno = "errno" in error ? error.errno : void 0;
+  const sqlState = "sqlState" in error ? error.sqlState : void 0;
+  if (code === 1213 || code === 1205 || errno === 1213 || errno === 1205) {
+    return true;
+  }
+  if (code === "ER_LOCK_DEADLOCK" || code === "ER_LOCK_WAIT_TIMEOUT") {
+    return true;
+  }
+  if (code === "40001" || code === "40P01" || sqlState === "40001" || sqlState === "40P01") {
+    return true;
+  }
+  if (code === "SQLITE_BUSY") {
+    return true;
+  }
+  const message = "message" in error ? error.message : void 0;
+  return typeof message === "string" && /deadlock|lock wait timeout|serialization failure/i.test(message);
+}
+__name(hasTransientShape, "hasTransientShape");
+function isTransientToolError(error) {
+  if (hasTransientShape(error)) {
+    return true;
+  }
+  if (typeof error === "object" && error !== null && "cause" in error) {
+    const cause = error.cause;
+    if (cause !== void 0 && cause !== error && hasTransientShape(cause)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(isTransientToolError, "isTransientToolError");
+var DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS = 2;
+var DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS = 150;
+function resolveToolTransientRetryNumbers(setting) {
+  if (setting === false) {
+    return false;
+  }
+  return {
+    attempts: setting?.attempts ?? DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS,
+    backoffMs: setting?.backoffMs ?? DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS
+  };
+}
+__name(resolveToolTransientRetryNumbers, "resolveToolTransientRetryNumbers");
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+__name(delay, "delay");
+async function invokeWithTransientRetry(fn, setting, options) {
+  if (setting === false) {
+    return fn();
+  }
+  const attempts = setting.attempts ?? DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS;
+  const backoffMs = setting.backoffMs ?? DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS;
+  const classify = setting.classify ?? isTransientToolError;
+  let attempt = 1;
+  for (; ; ) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (isControlFlowSignal(error) || options?.isControlFlowError?.(error) === true) {
+        throw error;
+      }
+      const attemptsRemain = attempt < attempts;
+      if (!attemptsRemain || !classify(error)) {
+        throw error;
+      }
+      options?.onRetry?.(attempt, error);
+      await delay(backoffMs * attempt);
+      attempt += 1;
+    }
+  }
+}
+__name(invokeWithTransientRetry, "invokeWithTransientRetry");
+
+// src/agent-loop.ts
+function resolveCostUsd(usage, reportedCostUsd, price) {
+  if (reportedCostUsd !== void 0) {
+    return reportedCostUsd;
+  }
+  return price === void 0 ? null : estimateCost(usage, price);
+}
+__name(resolveCostUsd, "resolveCostUsd");
+function buildContextBlock(passages) {
+  const items = passages.map((passage, index) => {
+    const label = passage.source !== void 0 ? ` (${passage.source})` : "";
+    return `[${index + 1}]${label} ${passage.text}`;
+  }).join("\n\n");
+  return `<retrieved_context>
+${items}
+</retrieved_context>
+Use the retrieved context above to answer when relevant, and cite sources by their bracket number.`;
+}
+__name(buildContextBlock, "buildContextBlock");
+function buildSummaryBlock(summary) {
+  return `<conversation_summary>
+${summary}
+</conversation_summary>
+Earlier messages in this thread are no longer included verbatim. Treat the summary above as an accurate record of them.`;
+}
+__name(buildSummaryBlock, "buildSummaryBlock");
+function settleAll(tasks) {
+  const started = tasks.map((task) => task());
+  return Promise.all(started.map((work) => work.then((value) => ({
+    ok: true,
+    value
+  }), (error) => ({
+    ok: false,
+    error
+  }))));
+}
+__name(settleAll, "settleAll");
+var QuotaExceededError = class extends Error {
+  static {
+    __name(this, "QuotaExceededError");
+  }
+  constructor() {
+    super("Daily token quota exceeded");
+    this.name = "QuotaExceededError";
+  }
+};
+var RunCancelledError = class extends Error {
+  static {
+    __name(this, "RunCancelledError");
+  }
+  constructor() {
+    super("Run cancelled");
+    this.name = "RunCancelledError";
+  }
+};
+function agentFailureCode(error) {
+  if (error instanceof RunCancelledError) {
+    return "cancelled";
+  }
+  if (error instanceof QuotaExceededError) {
+    return "quota_exceeded";
+  }
+  if (error instanceof OutputRejectedError) {
+    return "output_rejected";
+  }
+  if (error instanceof StructuredOutputError) {
+    return "structured_output_invalid";
+  }
+  return "run_failed";
+}
+__name(agentFailureCode, "agentFailureCode");
+var MAX_DELEGATION_DEPTH = 5;
+var DEFAULT_MAX_AGENT_APPEARANCES = 1;
+function delegationRefusal(args) {
+  const { deps, input, targetAgent } = args;
+  const ancestry = [
+    ...input.delegationPath ?? [],
+    ...input.agentName !== void 0 ? [
+      input.agentName
+    ] : []
+  ];
+  const appearances = ancestry.filter((name) => name === targetAgent).length;
+  const maxAppearances = deps.maxAgentAppearances ?? DEFAULT_MAX_AGENT_APPEARANCES;
+  if (appearances >= maxAppearances) {
+    const chain = [
+      ...ancestry,
+      targetAgent
+    ].join(" \u2192 ");
+    const times = appearances + 1;
+    return `(delegation cycle: ${chain} \u2014 ${targetAgent} ${times} times on one chain)`;
+  }
+  const maxDepth = deps.maxDelegationDepth ?? MAX_DELEGATION_DEPTH;
+  if ((input.delegationDepth ?? 0) >= maxDepth) {
+    return `(delegation depth limit of ${maxDepth} reached)`;
+  }
+  return null;
+}
+__name(delegationRefusal, "delegationRefusal");
+async function resolvePrompt(prompt, ctx) {
+  return typeof prompt === "function" ? prompt(ctx) : prompt;
+}
+__name(resolvePrompt, "resolvePrompt");
+async function resolveSystemPrompt(deps, input) {
+  const ctx = {
+    actor: input.actor,
+    agentName: input.agentName ?? "default",
+    ...input.pageContext !== void 0 ? {
+      pageContext: input.pageContext
+    } : {}
+  };
+  const sections = [
+    await resolvePrompt(deps.systemPrompt, ctx)
+  ];
+  for (const contribute of deps.promptContributors ?? []) {
+    const section = await contribute(ctx);
+    if (section !== null && section.length > 0) {
+      sections.push(section);
+    }
+  }
+  return sections.join("\n\n");
+}
+__name(resolveSystemPrompt, "resolveSystemPrompt");
+function extractTask(input) {
+  if (typeof input === "object" && input !== null && "task" in input) {
+    const task = input.task;
+    if (typeof task === "string") {
+      return task;
+    }
+  }
+  return JSON.stringify(input);
+}
+__name(extractTask, "extractTask");
+function deriveTitle(userText) {
+  const trimmed = userText.trim().replace(/\s+/g, " ");
+  return trimmed.length > 60 ? `${trimmed.slice(0, 57)}...` : trimmed || "New chat";
+}
+__name(deriveTitle, "deriveTitle");
+var ToolTimeoutError = class ToolTimeoutError2 extends Error {
+  static {
+    __name(this, "ToolTimeoutError");
+  }
+  constructor(toolName, ms) {
+    super(`Tool "${toolName}" exceeded its ${ms}ms timeout`);
+    this.name = "ToolTimeoutError";
+  }
+};
+function withToolTimeout(work, ms, toolName) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new ToolTimeoutError(toolName, ms)), ms);
+    work.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+__name(withToolTimeout, "withToolTimeout");
+function parseFollowUps(text, count) {
+  const source = text.match(/\[[\s\S]*\]/)?.[0] ?? text;
+  try {
+    const parsed = JSON.parse(source);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((item) => typeof item === "string").slice(0, count);
+    }
+  } catch {
+  }
+  return [];
+}
+__name(parseFollowUps, "parseFollowUps");
+async function generateFollowUps(model, messages, count) {
+  const discard = {
+    write: /* @__PURE__ */ __name(() => {
+    }, "write"),
+    end: /* @__PURE__ */ __name(() => {
     }, "end"),
     fail: /* @__PURE__ */ __name(() => {
     }, "fail")
   };
-  const turn = await model.runTurn({
-    system: `Based on the conversation so far, propose up to ${count} short, distinct follow-up questions the user is likely to ask next. Respond with ONLY a JSON array of strings \u2014 no prose, no code fences.`,
-    messages,
-    tools: [],
-    sink: discard
+  const turn = await model.runTurn({
+    system: `Based on the conversation so far, propose up to ${count} short, distinct follow-up questions the user is likely to ask next. Respond with ONLY a JSON array of strings \u2014 no prose, no code fences.`,
+    messages,
+    tools: [],
+    sink: discard
+  });
+  return {
+    followUps: parseFollowUps(turn.text, count),
+    usage: turn.usage,
+    ...turn.modelId !== void 0 ? {
+      modelId: turn.modelId
+    } : {}
+  };
+}
+__name(generateFollowUps, "generateFollowUps");
+async function spanned(event, runId, payload, run, summarize) {
+  let value;
+  await trace("agent", event, async () => {
+    value = await run();
+    return summarize(value);
+  }, payload, {
+    traceId: runId
+  });
+  return value;
+}
+__name(spanned, "spanned");
+function traceLlmTurn(runId, step, run) {
+  return spanned("llm.turn", runId, {
+    runId,
+    step
+  }, run, (turn) => ({
+    ...turn.modelId !== void 0 ? {
+      modelId: turn.modelId
+    } : {},
+    inputTokens: turn.usage.inputTokens,
+    outputTokens: turn.usage.outputTokens,
+    textLength: turn.text.length,
+    toolCalls: turn.toolCalls.length
+  }));
+}
+__name(traceLlmTurn, "traceLlmTurn");
+function traceToolExecution(runId, call, run) {
+  return spanned("tool.execution", runId, {
+    runId,
+    ...call
+  }, run, () => ({}));
+}
+__name(traceToolExecution, "traceToolExecution");
+function toModelMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: message.content,
+    ...message.toolCalls !== void 0 ? {
+      toolCalls: message.toolCalls
+    } : {},
+    ...message.toolResults !== void 0 ? {
+      toolResults: message.toolResults
+    } : {},
+    ...message.attachments !== void 0 ? {
+      attachments: message.attachments
+    } : {}
+  }));
+}
+__name(toModelMessages, "toModelMessages");
+function historyContext(input) {
+  return {
+    threadId: input.threadId,
+    actor: input.actor,
+    ...input.agentName !== void 0 ? {
+      agentName: input.agentName
+    } : {}
+  };
+}
+__name(historyContext, "historyContext");
+function splitHistory(policy, input, messages) {
+  return policy === void 0 ? {
+    keep: messages,
+    drop: []
+  } : policy.select(messages, historyContext(input));
+}
+__name(splitHistory, "splitHistory");
+async function loadSelectedHistory(deps, input, hooks) {
+  return hooks.step("load:thread", async () => {
+    const thread = await readThreadForTurn(deps, input.threadId);
+    const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(thread.messages));
+    return {
+      messages: keep,
+      dropped: deps.historyPolicy?.summarize === void 0 ? [] : drop,
+      title: thread.title,
+      hasAssistantMessage: thread.hasAssistantMessage
+    };
+  });
+}
+__name(loadSelectedHistory, "loadSelectedHistory");
+async function readThreadForTurn(deps, threadId) {
+  const windowing = deps.store;
+  if (typeof windowing.loadThreadForTurn === "function") {
+    const messageLimit = turnMessageLimit(deps.historyPolicy);
+    const page = await windowing.loadThreadForTurn({
+      threadId,
+      ...messageLimit !== void 0 ? {
+        messageLimit
+      } : {}
+    });
+    return page === null ? {
+      messages: [],
+      title: null,
+      hasAssistantMessage: false
+    } : {
+      messages: page.messages,
+      title: page.title,
+      hasAssistantMessage: page.hasAssistantMessage
+    };
+  }
+  const thread = await deps.store.getThread(threadId);
+  const stored = thread?.messages ?? [];
+  return {
+    messages: stored,
+    title: thread?.title ?? null,
+    hasAssistantMessage: stored.some((message) => message.role === "assistant")
+  };
+}
+__name(readThreadForTurn, "readThreadForTurn");
+function turnMessageLimit(policy) {
+  if (policy === void 0 || policy.summarize !== void 0) {
+    return void 0;
+  }
+  return policy.maxMessages;
+}
+__name(turnMessageLimit, "turnMessageLimit");
+async function loadWholeThread(deps, input, hooks) {
+  const thread = await hooks.step("load:thread", () => deps.store.getThread(input.threadId));
+  const stored = thread?.messages ?? [];
+  const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(stored));
+  return {
+    messages: keep,
+    dropped: drop,
+    title: thread?.title ?? null,
+    hasAssistantMessage: stored.some((message) => message.role === "assistant")
+  };
+}
+__name(loadWholeThread, "loadWholeThread");
+async function foldDroppedHistory(summarize, deps, input, hooks, history) {
+  const summary = await hooks.step("history:summarize", () => summarize(history.dropped, historyContext(input)));
+  if (summary.usage !== void 0) {
+    const usage = summary.usage;
+    await hooks.step("persist:usage:history", () => deps.store.recordUsage({
+      threadId: input.threadId,
+      actorRef: input.actor.id,
+      modelId: summary.modelId ?? deps.modelId ?? "unknown",
+      purpose: "history_summary",
+      usage
+    }));
+  }
+  return [
+    {
+      role: "system",
+      content: buildSummaryBlock(summary.text)
+    },
+    ...history.messages
+  ];
+}
+__name(foldDroppedHistory, "foldDroppedHistory");
+function processorContext(input, step) {
+  return {
+    threadId: input.threadId,
+    actor: input.actor,
+    step,
+    ...input.agentName !== void 0 ? {
+      agentName: input.agentName
+    } : {}
+  };
+}
+__name(processorContext, "processorContext");
+function restatementPrompt(messages, answer, fromTranscript) {
+  const restated = {
+    role: "assistant",
+    content: answer
+  };
+  if (fromTranscript) {
+    return [
+      ...messages,
+      restated
+    ];
+  }
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "user") {
+      return [
+        message,
+        restated
+      ];
+    }
+  }
+  return [
+    restated
+  ];
+}
+__name(restatementPrompt, "restatementPrompt");
+async function structureAnswer(schema, deps, input, hooks, messages, step) {
+  const instruction = deps.outputInstruction ?? DEFAULT_STRUCTURED_OUTPUT_INSTRUCTION;
+  const maxAttempts = 1 + (deps.outputRepairAttempts ?? 1);
+  const outputProcessors = deps.outputProcessors ?? [];
+  let issues = [];
+  let text = "";
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const system = attempt === 0 ? instruction : repairInstruction(instruction, issues);
+    const reply = await hooks.step(`structured:${step}:${attempt}`, () => spanned("structured-output", hooks.runId, {
+      runId: hooks.runId,
+      step,
+      attempt
+    }, async () => {
+      const discard = {
+        write: /* @__PURE__ */ __name(() => {
+        }, "write"),
+        end: /* @__PURE__ */ __name(() => {
+        }, "end"),
+        fail: /* @__PURE__ */ __name(() => {
+        }, "fail")
+      };
+      const turn = await deps.model.runTurn({
+        system,
+        messages,
+        tools: [],
+        sink: discard,
+        outputSchema: schema
+      });
+      return {
+        text: turn.text,
+        usage: turn.usage,
+        ...turn.object !== void 0 ? {
+          object: turn.object
+        } : {},
+        ...turn.modelId !== void 0 ? {
+          modelId: turn.modelId
+        } : {}
+      };
+    }, (result) => ({
+      inputTokens: result.usage.inputTokens,
+      outputTokens: result.usage.outputTokens,
+      textLength: result.text.length
+    })));
+    await hooks.step(`persist:usage:structured:${step}:${attempt}`, () => deps.store.recordUsage({
+      threadId: input.threadId,
+      actorRef: input.actor.id,
+      modelId: reply.modelId ?? deps.modelId ?? "unknown",
+      purpose: "structured_output",
+      usage: reply.usage
+    }));
+    text = reply.text;
+    if (outputProcessors.length > 0) {
+      const gate = await hooks.step(`process:output:structured:${step}:${attempt}`, () => runOutputProcessors(outputProcessors, {
+        text: reply.text,
+        toolCalls: []
+      }, processorContext(input, step)));
+      if (gate.rejection !== void 0) {
+        throw new OutputRejectedError(gate.rejection.processor, gate.rejection.reason);
+      }
+      text = gate.text;
+    }
+    const reported = text === reply.text ? reply.object : void 0;
+    const outcome = await validateStructured(schema, text, reported);
+    if (outcome.ok) {
+      return outcome.value;
+    }
+    issues = outcome.issues;
+  }
+  throw new StructuredOutputError(issues, text, maxAttempts);
+}
+__name(structureAnswer, "structureAnswer");
+function declaredKind(deps, name) {
+  if (deps.ask === true && name === ASK_TOOL_NAME) {
+    return "ask";
+  }
+  if (deps.skills !== void 0 && name === SKILL_TOOL_NAME) {
+    return "skill";
+  }
+  if (memoryIsWritable(deps) && name === REMEMBER_TOOL_NAME) {
+    return "memory";
+  }
+  return deps.registry.spec(name)?.kind ?? "read";
+}
+__name(declaredKind, "declaredKind");
+function memoryIsWritable(deps) {
+  return deps.memory?.provider.write !== void 0;
+}
+__name(memoryIsWritable, "memoryIsWritable");
+function withAskTool({ tools, ask }) {
+  return ask === true ? [
+    ...tools,
+    askToolDefinition()
+  ] : tools;
+}
+__name(withAskTool, "withAskTool");
+async function awaitElicitation(hooks, request, ctx) {
+  if (hooks.awaitAnswers !== void 0) {
+    return normalizeElicitationReply(await hooks.awaitAnswers(request, ctx));
+  }
+  return normalizeElicitationReply(await hooks.awaitApproval({
+    id: request.id,
+    name: ASK_TOOL_NAME,
+    input: request,
+    kind: "ask"
+  }, ctx));
+}
+__name(awaitElicitation, "awaitElicitation");
+function toolContext(deps, input, hooks) {
+  return {
+    actor: input.actor,
+    threadId: input.threadId,
+    runId: hooks.runId,
+    requestId: hooks.runId,
+    ...input.agentName !== void 0 ? {
+      agentName: input.agentName
+    } : {},
+    ...input.pageContext !== void 0 ? {
+      pageContext: input.pageContext
+    } : {},
+    ...deps.host !== void 0 ? {
+      host: deps.host
+    } : {}
+  };
+}
+__name(toolContext, "toolContext");
+function intakeApplies(intake, threadHasAssistant) {
+  return intake.when === "every-turn" || !threadHasAssistant;
+}
+__name(intakeApplies, "intakeApplies");
+async function runIntake(intake, deps, input, hooks, writer, threadHasAssistant) {
+  const preamble = intake.preamble ?? DEFAULT_INTAKE_PREAMBLE;
+  const request = {
+    id: `intake-${hooks.runId}`,
+    source: "intake",
+    preamble,
+    questions: intake.questions
+  };
+  const call = {
+    id: request.id,
+    name: ASK_TOOL_NAME,
+    input: {
+      preamble,
+      questions: intake.questions
+    },
+    kind: "ask"
+  };
+  const asked = await hooks.step("intake:ask", async () => {
+    if (!intakeApplies(intake, threadHasAssistant)) {
+      return null;
+    }
+    const message = await deps.store.appendMessage({
+      threadId: input.threadId,
+      role: "assistant",
+      content: preamble,
+      runId: hooks.runId,
+      toolCalls: [
+        call
+      ],
+      ...input.agentName !== void 0 ? {
+        agentName: input.agentName
+      } : {}
+    });
+    await deps.store.recordToolCall({
+      toolCallId: request.id,
+      messageId: message.id,
+      toolName: ASK_TOOL_NAME,
+      // The store knows read/action only. An unanswered question is work waiting on a human, which
+      // is what `action` + `pending_approval` already mean — so it surfaces in an approvals inbox
+      // rather than needing one of its own.
+      toolType: "action",
+      input: call.input,
+      status: "pending_approval",
+      runId: hooks.runId
+    });
+    await writer.write(encodeStreamEvent({
+      kind: "elicitation",
+      id: request.id,
+      request
+    }));
+    return {
+      messageId: message.id
+    };
+  });
+  if (asked === null) {
+    return null;
+  }
+  const messageId = asked.messageId;
+  const reply = await awaitElicitation(hooks, request, toolContext(deps, input, hooks));
+  const result = settleElicitation(request, reply);
+  await hooks.step("intake:answers", async () => {
+    await deps.store.updateToolCall({
+      toolCallId: request.id,
+      // A skip is not an answer. Both leave the agent holding the same values, but only one of them
+      // is evidence the user chose them, and a reader auditing what the agent was told has to be
+      // able to tell those apart.
+      status: result.skipped ? "rejected" : "executed",
+      output: result,
+      ...result.skipped ? {
+        error: "skipped by the user"
+      } : {},
+      ...reply.answeredByRef !== void 0 ? {
+        executedByRef: reply.answeredByRef
+      } : {}
+    });
+    await deps.store.setMessageToolResults(messageId, [
+      {
+        id: request.id,
+        name: ASK_TOOL_NAME,
+        output: result
+      }
+    ]);
+    await writer.write(encodeStreamEvent({
+      kind: "tool-output",
+      id: request.id,
+      output: result
+    }));
+  });
+  return {
+    role: "assistant",
+    content: preamble,
+    toolCalls: [
+      call
+    ],
+    toolResults: [
+      {
+        id: request.id,
+        name: ASK_TOOL_NAME,
+        output: result
+      }
+    ]
+  };
+}
+__name(runIntake, "runIntake");
+var PARALLEL_TOOLS_PATCH = "agent:parallel-tools";
+var CANCELLATION_PATCH = "agent:cancellation";
+var SELECTED_HISTORY_PATCH = "agent:selected-history";
+var PROMPT_STAGES_PATCH = "agent:prompt-stages";
+async function resolvePromptStages(deps, hooks) {
+  const configured = {
+    memory: deps.memory !== void 0,
+    retriever: deps.retriever !== void 0,
+    skills: deps.skills !== void 0
+  };
+  return await (hooks.patched?.(PROMPT_STAGES_PATCH) ?? Promise.resolve(true)) ? hooks.step("run:prompt-stages", () => Promise.resolve(configured)) : configured;
+}
+__name(resolvePromptStages, "resolvePromptStages");
+var UNSERVED_MEMORY = {
+  scopes: [],
+  entries: [],
+  omitted: 0,
+  pinnedOmitted: 0
+};
+var UNSERVED_SKILLS = {
+  scopes: [],
+  entries: [],
+  omitted: 0
+};
+async function haltIfCancelled(hooks, cancellable, name) {
+  const observe = hooks.cancelled;
+  if (!cancellable || observe === void 0) {
+    return;
+  }
+  if (await hooks.step(name, () => observe())) {
+    throw new RunCancelledError();
+  }
+}
+__name(haltIfCancelled, "haltIfCancelled");
+async function claimToolCall(turn, call) {
+  const { deps, input, hooks, messageId } = turn;
+  const persisted = await hooks.step(`persist:toolcall:${call.id}`, async () => {
+    const spec = deps.registry.spec(call.name);
+    const kind = declaredKind(deps, call.name);
+    const awaitsHuman = kind === "action" || kind === "ask";
+    await deps.store.recordToolCall({
+      toolCallId: call.id,
+      messageId,
+      toolName: call.name,
+      toolType: awaitsHuman ? "action" : "read",
+      input: call.input,
+      status: awaitsHuman ? "pending_approval" : "auto_executed",
+      runId: hooks.runId
+    });
+    return {
+      kind,
+      ...spec?.targetAgent !== void 0 ? {
+        targetAgent: spec.targetAgent
+      } : {},
+      // Only an `agent` spec ever carries this, and only when the author declared it — so a
+      // deployment with no detached edge writes the same bytes here it always has.
+      ...spec?.detached === true ? {
+        detached: true
+      } : {}
+    };
+  });
+  const toolType = persisted?.kind ?? call.kind ?? "read";
+  return {
+    call,
+    // What the rest of the turn — the dispatched tool envelope, the stream frames — sees as this
+    // call's kind, so it agrees with the branch actually taken instead of with a second lookup.
+    resolvedCall: call.kind === toolType ? call : {
+      ...call,
+      kind: toolType
+    },
+    toolType,
+    ...persisted?.targetAgent !== void 0 ? {
+      targetAgent: persisted.targetAgent
+    } : {},
+    ...persisted?.detached === true ? {
+      detached: true
+    } : {},
+    ctx: toolContext(deps, input, hooks)
+  };
+}
+__name(claimToolCall, "claimToolCall");
+async function loadSkillIntoTurn(turn, claimed, startedAt) {
+  const { deps, input, hooks } = turn;
+  const { call } = claimed;
+  const config = deps.skills;
+  const offer = turn.skills;
+  const outcome = await hooks.step(`tool:${call.id}`, async () => {
+    if (config === void 0 || offer === void 0) {
+      return {
+        ok: false,
+        error: "Skills are not available in this deployment."
+      };
+    }
+    const parsed = await skillInputSchema["~standard"].validate(call.input);
+    if (parsed.issues !== void 0) {
+      return {
+        ok: false,
+        error: `invalid skill input: ${parsed.issues.map((each) => `${(each.path ?? []).join(".") || "(root)"}: ${each.message}`).join("; ")}`
+      };
+    }
+    const loaded = await loadSkill(config, offer, parsed.value.name, skillContext(input));
+    if (!loaded.ok) {
+      return {
+        ok: false,
+        error: loaded.error
+      };
+    }
+    return {
+      ok: true,
+      output: {
+        name: loaded.skill.name,
+        scope: loaded.skill.scope,
+        body: loaded.skill.body,
+        ...loaded.shadows !== void 0 ? {
+          shadows: loaded.shadows
+        } : {}
+      }
+    };
+  });
+  return outcome.ok ? {
+    status: "executed",
+    output: outcome.output,
+    executionMs: Date.now() - startedAt
+  } : {
+    status: "failed",
+    error: outcome.error,
+    executionMs: Date.now() - startedAt
+  };
+}
+__name(loadSkillIntoTurn, "loadSkillIntoTurn");
+async function rememberIntoTurn(turn, claimed, startedAt) {
+  const { deps, input, hooks } = turn;
+  const { call } = claimed;
+  const config = deps.memory;
+  const digest = turn.memory;
+  const outcome = await hooks.step(`tool:${call.id}`, async () => {
+    if (config === void 0 || digest === void 0) {
+      return {
+        ok: false,
+        error: "Memory is not available in this deployment."
+      };
+    }
+    const parsed = await rememberInputSchema["~standard"].validate(call.input);
+    if (parsed.issues !== void 0) {
+      return {
+        ok: false,
+        error: `invalid remember input: ${parsed.issues.map((each) => `${(each.path ?? []).join(".") || "(root)"}: ${each.message}`).join("; ")}`
+      };
+    }
+    return await writeMemory({
+      config,
+      digest,
+      call: parsed.value,
+      ctx: skillContext(input),
+      runId: hooks.runId
+    });
+  });
+  if (!outcome.ok) {
+    return {
+      status: "failed",
+      error: outcome.error,
+      executionMs: Date.now() - startedAt
+    };
+  }
+  publishAgentMemoryWritten({
+    runId: hooks.runId,
+    scope: outcome.record.scope,
+    chars: outcome.record.text.length
+  });
+  return {
+    status: "executed",
+    output: outcome.record,
+    executionMs: Date.now() - startedAt
+  };
+}
+__name(rememberIntoTurn, "rememberIntoTurn");
+function skillContext(input) {
+  return {
+    actor: input.actor,
+    threadId: input.threadId,
+    ...input.agentName !== void 0 ? {
+      agentName: input.agentName
+    } : {},
+    ...input.pageContext !== void 0 ? {
+      pageContext: input.pageContext
+    } : {}
+  };
+}
+__name(skillContext, "skillContext");
+async function invokeClaimedTool(turn, claimed) {
+  const { deps, input, hooks } = turn;
+  const { call, resolvedCall, ctx } = claimed;
+  const toolType = claimed.toolType === "action" ? "action" : "read";
+  const startedAt = Date.now();
+  try {
+    if (claimed.toolType === "skill") {
+      return await loadSkillIntoTurn(turn, claimed, startedAt);
+    }
+    if (claimed.toolType === "memory") {
+      return await rememberIntoTurn(turn, claimed, startedAt);
+    }
+    let output;
+    if (hooks.dispatchTool) {
+      const stepCtx = {
+        actor: input.actor,
+        threadId: input.threadId,
+        runId: hooks.runId,
+        requestId: hooks.runId,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {},
+        ...input.pageContext !== void 0 ? {
+          pageContext: input.pageContext
+        } : {}
+      };
+      const envelope = {
+        toolName: call.name,
+        input: call.input,
+        ctx: stepCtx,
+        ...deps.toolTimeoutMs !== void 0 ? {
+          timeoutMs: deps.toolTimeoutMs
+        } : {},
+        // Numeric-only: the handler applies withToolTimeout AND its own local `classify` — see
+        // ToolStepEnvelope.transientRetry.
+        transientRetry: resolveToolTransientRetryNumbers(deps.toolTransientRetry)
+      };
+      output = await hooks.dispatchTool(resolvedCall, envelope);
+    } else {
+      const invocation = hooks.step(`tool:${call.id}`, () => traceToolExecution(hooks.runId, {
+        toolCallId: call.id,
+        toolName: call.name,
+        toolType
+      }, () => invokeWithTransientRetry(() => deps.registry.invoke(call.name, call.input, ctx, deps.rolesPolicy), deps.toolTransientRetry ?? {}, {
+        ...hooks.isControlFlowError !== void 0 ? {
+          isControlFlowError: hooks.isControlFlowError
+        } : {},
+        onRetry: /* @__PURE__ */ __name((attempt, retryError) => {
+          publishAgentToolRetry({
+            toolName: call.name,
+            toolCallId: call.id,
+            attempt,
+            message: retryError instanceof Error ? retryError.message : String(retryError)
+          });
+        }, "onRetry")
+      })));
+      output = deps.toolTimeoutMs !== void 0 ? await withToolTimeout(invocation, deps.toolTimeoutMs, call.name) : await invocation;
+    }
+    return {
+      status: "executed",
+      output,
+      executionMs: Date.now() - startedAt
+    };
+  } catch (error) {
+    if (hooks.isControlFlowError?.(error) === true || isControlFlowSignal(error) || isReplayIntegrityError(error)) {
+      throw error;
+    }
+    return {
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error),
+      executionMs: Date.now() - startedAt
+    };
+  }
+}
+__name(invokeClaimedTool, "invokeClaimedTool");
+async function recordToolOutcome(turn, claimed, outcome, deciderRef) {
+  const { deps, hooks } = turn;
+  const { call } = claimed;
+  const toolType = claimed.toolType === "action" ? "action" : "read";
+  if (outcome.status === "failed") {
+    await hooks.step(`persist:toolfail:${call.id}`, () => deps.store.updateToolCall({
+      toolCallId: call.id,
+      status: "failed",
+      error: outcome.error,
+      executionMs: outcome.executionMs
+    }));
+    publishAgentToolCall({
+      runId: hooks.runId,
+      toolName: call.name,
+      toolType,
+      status: "failed",
+      durationMs: outcome.executionMs
+    });
+    return {
+      id: call.id,
+      name: call.name,
+      output: null,
+      error: outcome.error
+    };
+  }
+  await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+    toolCallId: call.id,
+    status: "executed",
+    output: outcome.output,
+    executionMs: outcome.executionMs,
+    ...toolType === "action" ? {
+      executedByRef: deciderRef
+    } : {}
+  }));
+  publishAgentToolCall({
+    runId: hooks.runId,
+    toolName: call.name,
+    toolType,
+    status: "executed",
+    durationMs: outcome.executionMs
+  });
+  return {
+    id: call.id,
+    name: call.name,
+    output: outcome.output
+  };
+}
+__name(recordToolOutcome, "recordToolOutcome");
+async function delegateToolCall(turn, claimed) {
+  const { deps, input, hooks } = turn;
+  const { call, targetAgent = call.name } = claimed;
+  const task = extractTask(call.input);
+  const refusal = delegationRefusal({
+    deps,
+    input,
+    targetAgent
+  });
+  const start = claimed.detached === true && refusal === null ? hooks.startAgent : void 0;
+  publishAgentDelegated({
+    runId: hooks.runId,
+    toAgent: targetAgent,
+    ...input.agentName !== void 0 ? {
+      fromAgent: input.agentName
+    } : {},
+    ...start !== void 0 ? {
+      detached: true
+    } : {}
   });
+  let sub;
+  if (refusal !== null) {
+    sub = {
+      text: refusal
+    };
+  } else if (start !== void 0) {
+    const started = await start({
+      agentName: targetAgent,
+      task,
+      toolCallId: call.id
+    });
+    sub = detachedStarted({
+      agent: targetAgent,
+      runId: started.runId
+    });
+  } else if (hooks.runAgent) {
+    sub = await hooks.runAgent(targetAgent, task);
+  } else {
+    sub = {
+      text: `(no multi-agent support wired; cannot reach "${targetAgent}")`
+    };
+  }
+  await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+    toolCallId: call.id,
+    status: "executed",
+    output: sub
+  }));
   return {
-    followUps: parseFollowUps(turn.text, count),
-    usage: turn.usage,
-    ...turn.modelId !== void 0 ? {
-      modelId: turn.modelId
-    } : {}
+    id: call.id,
+    name: call.name,
+    output: sub
   };
 }
-__name(generateFollowUps, "generateFollowUps");
-async function spanned(event, runId, payload, run, summarize) {
-  let value;
-  await trace("agent", event, async () => {
-    value = await run();
-    return summarize(value);
-  }, payload, {
-    traceId: runId
+__name(delegateToolCall, "delegateToolCall");
+async function elicitToolCall(turn, claimed) {
+  const { deps, hooks } = turn;
+  const { call, ctx } = claimed;
+  const parsed = await askInputSchema["~standard"].validate(call.input);
+  if (parsed.issues !== void 0) {
+    const error = `invalid ask input: ${parsed.issues.map((each) => `${(each.path ?? []).join(".") || "(root)"}: ${each.message}`).join("; ")}`;
+    await hooks.step(`persist:toolfail:${call.id}`, () => deps.store.updateToolCall({
+      toolCallId: call.id,
+      status: "failed",
+      error
+    }));
+    return {
+      id: call.id,
+      name: call.name,
+      output: null,
+      error
+    };
+  }
+  const request = {
+    id: call.id,
+    source: "ask",
+    questions: parsed.value.questions,
+    ...parsed.value.preamble !== void 0 ? {
+      preamble: parsed.value.preamble
+    } : {}
+  };
+  await hooks.step(`stream:elicitation:${call.id}`, async () => {
+    await turn.writer.write(encodeStreamEvent({
+      kind: "elicitation",
+      id: call.id,
+      request
+    }));
   });
-  return value;
-}
-__name(spanned, "spanned");
-function traceLlmTurn(runId, step, run) {
-  return spanned("llm.turn", runId, {
-    runId,
-    step
-  }, run, (turn) => ({
-    ...turn.modelId !== void 0 ? {
-      modelId: turn.modelId
+  const reply = await awaitElicitation(hooks, request, ctx);
+  const result = settleElicitation(request, reply);
+  await hooks.step(result.skipped ? `persist:toolreject:${call.id}` : `persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
+    toolCallId: call.id,
+    status: result.skipped ? "rejected" : "executed",
+    output: result,
+    ...result.skipped ? {
+      error: "skipped by the user"
     } : {},
-    inputTokens: turn.usage.inputTokens,
-    outputTokens: turn.usage.outputTokens,
-    textLength: turn.text.length,
-    toolCalls: turn.toolCalls.length
+    ...reply.answeredByRef !== void 0 ? {
+      executedByRef: reply.answeredByRef
+    } : {}
   }));
+  publishAgentToolCall({
+    runId: hooks.runId,
+    toolName: call.name,
+    toolType: "action",
+    status: result.skipped ? "rejected" : "executed"
+  });
+  return {
+    id: call.id,
+    name: call.name,
+    output: result
+  };
 }
-__name(traceLlmTurn, "traceLlmTurn");
-function traceToolExecution(runId, call, run) {
-  return spanned("tool.execution", runId, {
-    runId,
-    ...call
-  }, run, () => ({}));
+__name(elicitToolCall, "elicitToolCall");
+async function runClaimedToolCall(turn, claimed) {
+  const { deps, input, hooks } = turn;
+  const { call, toolType, ctx } = claimed;
+  if (toolType === "agent") {
+    return delegateToolCall(turn, claimed);
+  }
+  if (toolType === "ask") {
+    return elicitToolCall(turn, claimed);
+  }
+  let deciderRef = input.actor.id;
+  if (toolType === "action") {
+    const decision = await hooks.awaitApproval(call, ctx);
+    deciderRef = decision.executedByRef ?? input.actor.id;
+    if (!decision.approved) {
+      await hooks.step(`persist:toolreject:${call.id}`, () => deps.store.updateToolCall({
+        toolCallId: call.id,
+        status: "rejected",
+        executedByRef: deciderRef,
+        ...decision.reason !== void 0 ? {
+          error: decision.reason
+        } : {}
+      }));
+      publishAgentToolCall({
+        runId: hooks.runId,
+        toolName: call.name,
+        toolType,
+        status: "rejected"
+      });
+      return {
+        id: call.id,
+        name: call.name,
+        output: {
+          rejected: true,
+          reason: decision.reason ?? "rejected by user"
+        },
+        error: "rejected"
+      };
+    }
+  }
+  return recordToolOutcome(turn, claimed, await invokeClaimedTool(turn, claimed), deciderRef);
 }
-__name(traceToolExecution, "traceToolExecution");
+__name(runClaimedToolCall, "runClaimedToolCall");
+async function invokeClaimedToolsTogether(turn, parallel, claimed) {
+  const settled = await parallel(claimed.map((entry) => () => invokeClaimedTool(turn, entry)));
+  for (const outcome of settled) {
+    if (!outcome.ok) {
+      throw outcome.error;
+    }
+  }
+  const results = [];
+  for (const [index, entry] of claimed.entries()) {
+    const outcome = settled[index];
+    if (outcome?.ok === true) {
+      results.push(await recordToolOutcome(turn, entry, outcome.value, turn.input.actor.id));
+    }
+  }
+  return results;
+}
+__name(invokeClaimedToolsTogether, "invokeClaimedToolsTogether");
 async function runAgentLoop(deps, input, hooks) {
   const maxSteps = deps.maxSteps ?? 8;
   let system = await resolveSystemPrompt(deps, input);
+  const inputProcessors = deps.inputProcessors ?? [];
+  const outputProcessors = deps.outputProcessors ?? [];
+  const gateMode = resolveOutputGateMode(outputProcessors);
+  const gated = gateMode !== "off";
+  const gateLookback = resolveGateLookback(outputProcessors);
+  let structured;
   if (deps.quota !== void 0) {
     const quota = deps.quota;
     const state = await hooks.step("quota:check", () => quota.check(input.actor.id, deps.day));
@@ -759,25 +3122,18 @@ async function runAgentLoop(deps, input, hooks) {
       threadId: input.threadId,
       role: "user",
       content: input.userText,
+      runId: hooks.runId,
       ...input.attachments !== void 0 ? {
         attachments: input.attachments
       } : {}
     }));
   }
-  const thread = await hooks.step("load:thread", () => deps.store.getThread(input.threadId));
-  const modelMessages = (thread?.messages ?? []).map((message) => ({
-    role: message.role,
-    content: message.content,
-    ...message.toolCalls !== void 0 ? {
-      toolCalls: message.toolCalls
-    } : {},
-    ...message.toolResults !== void 0 ? {
-      toolResults: message.toolResults
-    } : {},
-    ...message.attachments !== void 0 ? {
-      attachments: message.attachments
-    } : {}
-  }));
+  const history = await (hooks.patched?.(SELECTED_HISTORY_PATCH) ?? Promise.resolve(true)) ? await loadSelectedHistory(deps, input, hooks) : await loadWholeThread(deps, input, hooks);
+  let modelMessages = history.messages;
+  const summarize = deps.historyPolicy?.summarize?.bind(deps.historyPolicy);
+  if (summarize !== void 0 && history.dropped.length > 0) {
+    modelMessages = await foldDroppedHistory(summarize, deps, input, hooks, history);
+  }
   const writer = await hooks.openSink();
   let lastText = "";
   let steps = 0;
@@ -791,6 +3147,7 @@ async function runAgentLoop(deps, input, hooks) {
       agentName: input.agentName
     } : {}
   });
+  const stages = await resolvePromptStages(deps, hooks);
   const startedAt = await hooks.step("run:started-at", () => Promise.resolve(Date.now()));
   await hooks.step("persist:run:start", async () => {
     const promptHash = createHash("sha256").update(system).digest("hex");
@@ -801,20 +3158,52 @@ async function runAgentLoop(deps, input, hooks) {
       ...input.agentName !== void 0 ? {
         agentName: input.agentName
       } : {},
+      ...input.parentRunId !== void 0 ? {
+        parentRunId: input.parentRunId
+      } : {},
       promptHash
     });
   });
+  let memoryDigest;
+  if (stages.memory) {
+    const config = deps.memory;
+    memoryDigest = await hooks.step("memory:digest", () => config === void 0 ? Promise.resolve(UNSERVED_MEMORY) : offerMemories({
+      config,
+      ctx: skillContext(input),
+      query: input.userText
+    }));
+    const digest = memoryDigest;
+    const block = digest.entries.length > 0 ? buildMemoryBlock({
+      entries: digest.entries,
+      writable: memoryIsWritable(deps),
+      partial: digest.omitted > 0 || digest.recalled === true
+    }) : "";
+    if (block.length > 0) {
+      system = `${system}
+
+${block}`;
+    }
+    publishAgentMemoryResolved({
+      runId: hooks.runId,
+      scopes: digest.scopes.length,
+      offered: digest.entries.length,
+      omitted: digest.omitted,
+      pinnedOmitted: digest.pinnedOmitted,
+      recalled: digest.recalled === true,
+      promptChars: block.length
+    });
+  }
   let injectedPassages;
-  if (deps.retriever !== void 0) {
+  if (stages.retriever) {
     const retriever = deps.retriever;
     const topK = deps.retrievalTopK ?? 5;
     const passages = await hooks.step("retrieve", () => spanned("retrieval", hooks.runId, {
       runId: hooks.runId,
       queryLength: input.userText.length,
       topK
-    }, () => retriever.retrieve(input.userText, {
+    }, () => retriever?.retrieve(input.userText, {
       topK
-    }), (retrieved) => ({
+    }) ?? Promise.resolve([]), (retrieved) => ({
       count: retrieved.length
     })));
     if (passages.length > 0) {
@@ -829,6 +3218,24 @@ ${buildContextBlock(passages)}`;
       count: passages.length
     });
   }
+  let skillOffer;
+  if (stages.skills) {
+    const config = deps.skills;
+    skillOffer = await hooks.step("skills:catalog", () => config === void 0 ? Promise.resolve(UNSERVED_SKILLS) : offerSkills(config, skillContext(input)));
+    const block = skillOffer.entries.length > 0 ? buildSkillsBlock(skillOffer.entries) : "";
+    if (block.length > 0) {
+      system = `${system}
+
+${block}`;
+    }
+    publishAgentSkillsResolved({
+      runId: hooks.runId,
+      scopes: skillOffer.scopes.length,
+      offered: skillOffer.entries.length,
+      omitted: skillOffer.omitted,
+      promptChars: block.length
+    });
+  }
   let prices = [];
   if (deps.pricingStore !== void 0) {
     const pricingStore = deps.pricingStore;
@@ -838,36 +3245,124 @@ ${buildContextBlock(passages)}`;
     price.modelId,
     price
   ]));
+  if (deps.intake !== void 0) {
+    const asked = await runIntake(deps.intake, deps, input, hooks, writer, history.hasAssistantMessage);
+    if (asked !== null) {
+      modelMessages.push(asked);
+    }
+  }
+  const cancellable = hooks.cancelled !== void 0 && await (hooks.patched?.(CANCELLATION_PATCH) ?? Promise.resolve(true));
   for (let i = 0; i < maxSteps; i += 1) {
+    await haltIfCancelled(hooks, cancellable, `cancel:check:${i}`);
     await hooks.step(`stream:step-start:${i}`, async () => {
       await writer.write(encodeStreamEvent({
         kind: "step-start"
       }));
     });
+    let prompt = {
+      system,
+      messages: modelMessages
+    };
+    if (inputProcessors.length > 0) {
+      prompt = await hooks.step(`process:input:${i}`, () => runInputProcessors(inputProcessors, prompt, processorContext(input, i)));
+    }
     let turn;
     if (hooks.dispatchLlm) {
       turn = await hooks.dispatchLlm(i, {
         ...input.agentName !== void 0 ? {
           agentName: input.agentName
         } : {},
-        system,
-        messages: modelMessages,
-        actor: input.actor
+        system: prompt.system,
+        messages: prompt.messages,
+        actor: input.actor,
+        ...gated ? {
+          bufferOutput: true
+        } : {}
       });
     } else {
-      const tools = await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList);
-      turn = await hooks.step(`llm:${i}`, () => traceLlmTurn(hooks.runId, i, () => deps.model.runTurn({
-        system,
-        messages: modelMessages,
-        tools,
-        sink: writer
-      })));
+      const tools = withMemoryTool({
+        tools: withSkillTool({
+          tools: withAskTool({
+            tools: await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList),
+            ask: deps.ask
+          }),
+          enabled: deps.skills !== void 0
+        }),
+        enabled: memoryIsWritable(deps)
+      });
+      turn = await hooks.step(`llm:${i}`, async () => {
+        const incremental = gateMode === "incremental" ? createIncrementalGate({
+          processors: outputProcessors,
+          ctx: processorContext(input, i),
+          lookbackChars: gateLookback,
+          writer
+        }) : void 0;
+        const buffer = gateMode === "whole" ? createFrameBuffer() : void 0;
+        const result = await traceLlmTurn(hooks.runId, i, () => deps.model.runTurn({
+          system: prompt.system,
+          messages: prompt.messages,
+          tools,
+          sink: incremental?.writer ?? buffer?.writer ?? writer
+        }));
+        if (incremental !== void 0) {
+          await incremental.settled();
+          const refusal = incremental.rejection();
+          return {
+            ...result,
+            releasedText: incremental.released(),
+            ...refusal !== void 0 ? {
+              gateRejection: refusal
+            } : {}
+          };
+        }
+        return buffer === void 0 ? result : {
+          ...result,
+          bufferedFrames: buffer.frames()
+        };
+      });
+    }
+    let rejection;
+    if (gated) {
+      const gate = await hooks.step(`process:output:${i}`, async () => {
+        const released = turn.releasedText;
+        if (turn.gateRejection !== void 0) {
+          return {
+            text: turn.text,
+            rejection: turn.gateRejection
+          };
+        }
+        const settled = await runOutputProcessors(outputProcessors, {
+          text: turn.text,
+          toolCalls: turn.toolCalls
+        }, processorContext(input, i));
+        if (settled.rejection === void 0) {
+          if (released === void 0) {
+            for (const chunk of releaseGatedFrames(turn.bufferedFrames ?? [], settled.text)) {
+              await writer.write(chunk);
+            }
+          } else {
+            const tail = gateTail(outputProcessors, released, settled.text);
+            if (tail.length > 0) {
+              await writer.write(encodeStreamEvent({
+                kind: "text",
+                text: tail
+              }));
+            }
+          }
+        }
+        return settled;
+      });
+      rejection = gate.rejection;
+      turn = {
+        ...turn,
+        text: gate.text
+      };
     }
     const resolvedModelId = turn.modelId ?? deps.modelId ?? "unknown";
     const costUsd = resolveCostUsd(turn.usage, turn.costUsd, priceByModel.get(resolvedModelId));
     const toolCallsWithKind = turn.toolCalls.map((call) => ({
       ...call,
-      kind: deps.registry.spec(call.name)?.kind ?? "read"
+      kind: declaredKind(deps, call.name)
     }));
     await hooks.step(`persist:usage:${i}`, () => deps.store.recordUsage({
       threadId: input.threadId,
@@ -884,6 +3379,9 @@ ${buildContextBlock(passages)}`;
       const quota = deps.quota;
       await hooks.step(`quota:bump:${i}`, () => quota.bump(input.actor.id, deps.day, turn.usage.inputTokens + turn.usage.outputTokens));
     }
+    if (rejection !== void 0) {
+      throw new OutputRejectedError(rejection.processor, rejection.reason);
+    }
     steps += 1;
     totalInput += turn.usage.inputTokens;
     totalOutput += turn.usage.outputTokens;
@@ -895,6 +3393,9 @@ ${buildContextBlock(passages)}`;
       textLength: turn.text.length
     });
     const isFinalTurn = turn.toolCalls.length === 0;
+    if (isFinalTurn && deps.outputSchema !== void 0) {
+      structured = await structureAnswer(deps.outputSchema, deps, input, hooks, restatementPrompt(prompt.messages, turn.text, deps.outputFromTranscript === true), i);
+    }
     let followUps;
     if (isFinalTurn && deps.followUpsCount !== void 0 && deps.followUpsCount > 0) {
       const count = deps.followUpsCount;
@@ -916,8 +3417,12 @@ ${buildContextBlock(passages)}`;
           modelId: result.modelId
         } : {}
       })));
-      if (generated.followUps.length > 0) {
-        followUps = generated.followUps;
+      let suggestions = generated.followUps;
+      if (outputProcessors.length > 0) {
+        suggestions = await hooks.step(`process:output:followups:${i}`, () => gateFollowUps(outputProcessors, suggestions, processorContext(input, i)));
+      }
+      if (suggestions.length > 0) {
+        followUps = suggestions;
       }
       await hooks.step(`persist:usage:followups:${i}`, () => deps.store.recordUsage({
         threadId: input.threadId,
@@ -927,10 +3432,58 @@ ${buildContextBlock(passages)}`;
         usage: generated.usage
       }));
     }
+    const synthetic = [];
+    if (i === 0 && injectedPassages !== void 0) {
+      const call = {
+        id: `retrieve-${hooks.runId}`,
+        name: "retrieve",
+        input: {
+          query: input.userText
+        },
+        kind: "read"
+      };
+      const output = {
+        passages: injectedPassages
+      };
+      synthetic.push({
+        step: "persist:retrieval",
+        call,
+        result: {
+          id: call.id,
+          name: call.name,
+          output
+        }
+      });
+    }
+    if (structured !== void 0) {
+      const call = {
+        id: `structured-${hooks.runId}`,
+        name: "structured_output",
+        input: {},
+        kind: "read"
+      };
+      synthetic.push({
+        step: "persist:structured",
+        call,
+        result: {
+          id: call.id,
+          name: call.name,
+          output: structured
+        }
+      });
+    }
+    const messageCalls = [
+      ...toolCallsWithKind,
+      ...synthetic.map((entry) => entry.call)
+    ];
+    const syntheticResults = synthetic.map((entry) => entry.result);
     const assistant = await hooks.step(`persist:assistant:${i}`, () => deps.store.appendMessage({
       threadId: input.threadId,
       role: "assistant",
       content: turn.text,
+      // Stamps which turn wrote this message, so a reader does not have to infer it from
+      // timestamps — an inference a regenerate breaks, since it re-answers a surviving prompt.
+      runId: hooks.runId,
       usage: {
         ...turn.usage,
         costUsd
@@ -938,8 +3491,11 @@ ${buildContextBlock(passages)}`;
       ...input.agentName !== void 0 ? {
         agentName: input.agentName
       } : {},
-      ...toolCallsWithKind.length > 0 ? {
-        toolCalls: toolCallsWithKind
+      ...messageCalls.length > 0 ? {
+        toolCalls: messageCalls
+      } : {},
+      ...syntheticResults.length > 0 ? {
+        toolResults: syntheticResults
       } : {},
       ...followUps !== void 0 ? {
         followUps
@@ -948,33 +3504,43 @@ ${buildContextBlock(passages)}`;
     const assistantMessage = {
       role: "assistant",
       content: turn.text,
-      ...toolCallsWithKind.length > 0 ? {
-        toolCalls: toolCallsWithKind
+      ...messageCalls.length > 0 ? {
+        toolCalls: messageCalls
+      } : {},
+      ...syntheticResults.length > 0 ? {
+        toolResults: syntheticResults
       } : {}
     };
     modelMessages.push(assistantMessage);
-    if (i === 0 && injectedPassages !== void 0) {
-      const passages = injectedPassages;
-      const toolCallId = `retrieve-${assistant.id}`;
-      await hooks.step(`persist:retrieval:${assistant.id}`, async () => {
+    for (const entry of synthetic) {
+      const { call, result } = entry;
+      await hooks.step(`${entry.step}:${assistant.id}`, async () => {
         await deps.store.recordToolCall({
-          toolCallId,
+          toolCallId: call.id,
           messageId: assistant.id,
-          toolName: "retrieve",
+          toolName: call.name,
           toolType: "read",
-          input: {
-            query: input.userText
-          },
+          input: call.input,
           status: "auto_executed",
           runId: hooks.runId
         });
         await deps.store.updateToolCall({
-          toolCallId,
+          toolCallId: call.id,
           status: "executed",
-          output: {
-            passages
-          }
+          output: result.output
         });
+        await writer.write(encodeStreamEvent({
+          kind: "tool-input-available",
+          id: call.id,
+          name: call.name,
+          input: call.input,
+          toolKind: "read"
+        }));
+        await writer.write(encodeStreamEvent({
+          kind: "tool-output",
+          id: call.id,
+          output: result.output
+        }));
       });
     }
     if (isFinalTurn) {
@@ -987,218 +3553,46 @@ ${buildContextBlock(passages)}`;
       });
       break;
     }
+    await haltIfCancelled(hooks, cancellable, `cancel:tools:${i}`);
     const results = [];
-    for (const call of toolCallsWithKind) {
-      const spec = deps.registry.spec(call.name);
-      const toolType = call.kind ?? "read";
-      const ctx = {
-        actor: input.actor,
-        threadId: input.threadId,
-        runId: hooks.runId,
-        requestId: hooks.runId,
-        ...input.agentName !== void 0 ? {
-          agentName: input.agentName
-        } : {},
-        ...input.pageContext !== void 0 ? {
-          pageContext: input.pageContext
-        } : {},
-        ...deps.host !== void 0 ? {
-          host: deps.host
-        } : {}
-      };
-      if (toolType === "agent") {
-        const targetAgent = spec?.targetAgent ?? call.name;
-        const task = extractTask(call.input);
-        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
-          toolCallId: call.id,
-          messageId: assistant.id,
-          toolName: call.name,
-          toolType: "read",
-          input: call.input,
-          status: "auto_executed",
-          runId: hooks.runId
-        }));
-        const overDepth = (input.delegationDepth ?? 0) >= MAX_DELEGATION_DEPTH;
-        publishAgentDelegated({
-          runId: hooks.runId,
-          toAgent: targetAgent,
-          ...input.agentName !== void 0 ? {
-            fromAgent: input.agentName
-          } : {}
-        });
-        let sub;
-        if (overDepth) {
-          sub = {
-            text: `(delegation depth limit of ${MAX_DELEGATION_DEPTH} reached)`
-          };
-        } else if (hooks.runAgent) {
-          sub = await hooks.runAgent(targetAgent, task);
-        } else {
-          sub = {
-            text: `(no multi-agent support wired; cannot reach "${targetAgent}")`
-          };
-        }
-        await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
-          toolCallId: call.id,
-          status: "executed",
-          output: sub
-        }));
-        results.push({
-          id: call.id,
-          name: call.name,
-          output: sub
-        });
-        continue;
+    const turnCalls = {
+      deps,
+      input,
+      hooks,
+      messageId: assistant.id,
+      writer,
+      ...skillOffer !== void 0 ? {
+        skills: skillOffer
+      } : {},
+      ...memoryDigest !== void 0 ? {
+        memory: memoryDigest
+      } : {}
+    };
+    const parallel = hooks.parallel;
+    if (parallel !== void 0 && toolCallsWithKind.length > 1 && await (hooks.patched?.(PARALLEL_TOOLS_PATCH) ?? Promise.resolve(true))) {
+      const claimed = [];
+      for (const call of toolCallsWithKind) {
+        claimed.push(await claimToolCall(turnCalls, call));
       }
-      let deciderRef = input.actor.id;
-      if (toolType === "action") {
-        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
-          toolCallId: call.id,
-          messageId: assistant.id,
-          toolName: call.name,
-          toolType: "action",
-          input: call.input,
-          status: "pending_approval",
-          runId: hooks.runId
-        }));
-        const decision = await hooks.awaitApproval(call, ctx);
-        deciderRef = decision.executedByRef ?? input.actor.id;
-        if (!decision.approved) {
-          await hooks.step(`persist:toolreject:${call.id}`, () => deps.store.updateToolCall({
-            toolCallId: call.id,
-            status: "rejected",
-            executedByRef: deciderRef,
-            ...decision.reason !== void 0 ? {
-              error: decision.reason
-            } : {}
-          }));
-          results.push({
-            id: call.id,
-            name: call.name,
-            output: {
-              rejected: true,
-              reason: decision.reason ?? "rejected by user"
-            },
-            error: "rejected"
-          });
-          publishAgentToolCall({
-            runId: hooks.runId,
-            toolName: call.name,
-            toolType,
-            status: "rejected"
-          });
-          continue;
-        }
+      if (claimed.every((entry) => entry.toolType === "read" || entry.toolType === "skill" || entry.toolType === "memory")) {
+        results.push(...await invokeClaimedToolsTogether(turnCalls, parallel, claimed));
       } else {
-        await hooks.step(`persist:toolcall:${call.id}`, () => deps.store.recordToolCall({
-          toolCallId: call.id,
-          messageId: assistant.id,
-          toolName: call.name,
-          toolType: "read",
-          input: call.input,
-          status: "auto_executed",
-          runId: hooks.runId
-        }));
-      }
-      const startedAt2 = Date.now();
-      try {
-        let output;
-        if (hooks.dispatchTool) {
-          const stepCtx = {
-            actor: input.actor,
-            threadId: input.threadId,
-            runId: hooks.runId,
-            requestId: hooks.runId,
-            ...input.agentName !== void 0 ? {
-              agentName: input.agentName
-            } : {},
-            ...input.pageContext !== void 0 ? {
-              pageContext: input.pageContext
-            } : {}
-          };
-          const envelope = {
-            toolName: call.name,
-            input: call.input,
-            ctx: stepCtx,
-            ...deps.toolTimeoutMs !== void 0 ? {
-              timeoutMs: deps.toolTimeoutMs
-            } : {},
-            // Numeric-only: the handler applies withToolTimeout AND its own local `classify` — see
-            // ToolStepEnvelope.transientRetry.
-            transientRetry: resolveToolTransientRetryNumbers(deps.toolTransientRetry)
-          };
-          output = await hooks.dispatchTool(call, envelope);
-        } else {
-          const invocation = hooks.step(`tool:${call.id}`, () => traceToolExecution(hooks.runId, {
-            toolCallId: call.id,
-            toolName: call.name,
-            toolType
-          }, () => invokeWithTransientRetry(() => deps.registry.invoke(call.name, call.input, ctx, deps.rolesPolicy), deps.toolTransientRetry ?? {}, {
-            ...hooks.isControlFlowError !== void 0 ? {
-              isControlFlowError: hooks.isControlFlowError
-            } : {},
-            onRetry: /* @__PURE__ */ __name((attempt, retryError) => {
-              publishAgentToolRetry({
-                toolName: call.name,
-                toolCallId: call.id,
-                attempt,
-                message: retryError instanceof Error ? retryError.message : String(retryError)
-              });
-            }, "onRetry")
-          })));
-          output = deps.toolTimeoutMs !== void 0 ? await withToolTimeout(invocation, deps.toolTimeoutMs, call.name) : await invocation;
-        }
-        const executionMs = Date.now() - startedAt2;
-        await hooks.step(`persist:toolexec:${call.id}`, () => deps.store.updateToolCall({
-          toolCallId: call.id,
-          status: "executed",
-          output,
-          executionMs,
-          ...toolType === "action" ? {
-            executedByRef: deciderRef
-          } : {}
-        }));
-        results.push({
-          id: call.id,
-          name: call.name,
-          output
-        });
-        publishAgentToolCall({
-          runId: hooks.runId,
-          toolName: call.name,
-          toolType,
-          status: "executed",
-          durationMs: executionMs
-        });
-      } catch (error) {
-        if (hooks.isControlFlowError?.(error) === true) {
-          throw error;
+        for (const entry of claimed) {
+          results.push(await runClaimedToolCall(turnCalls, entry));
         }
-        const executionMs = Date.now() - startedAt2;
-        const message = error instanceof Error ? error.message : String(error);
-        await hooks.step(`persist:toolfail:${call.id}`, () => deps.store.updateToolCall({
-          toolCallId: call.id,
-          status: "failed",
-          error: message,
-          executionMs
-        }));
-        results.push({
-          id: call.id,
-          name: call.name,
-          output: null,
-          error: message
-        });
-        publishAgentToolCall({
-          runId: hooks.runId,
-          toolName: call.name,
-          toolType,
-          status: "failed",
-          durationMs: executionMs
-        });
+      }
+    } else {
+      for (const call of toolCallsWithKind) {
+        results.push(await runClaimedToolCall(turnCalls, await claimToolCall(turnCalls, call)));
       }
     }
-    assistantMessage.toolResults = results;
+    const settledResults = [
+      ...results,
+      ...syntheticResults
+    ];
+    assistantMessage.toolResults = settledResults;
     await hooks.step(`stream:tool-outputs:${i}`, async () => {
+      await deps.store.setMessageToolResults(assistant.id, settledResults);
       for (const result of results) {
         await writer.write(encodeStreamEvent(result.error !== void 0 ? {
           kind: "tool-output-error",
@@ -1219,9 +3613,34 @@ ${buildContextBlock(passages)}`;
       }));
     });
   }
-  if (thread !== null && (thread.title === "" || thread.title === "New chat")) {
+  if (history.title === "" || history.title === "New chat") {
     await hooks.step("persist:title", () => deps.store.setTitle(input.threadId, deriveTitle(input.userText)));
   }
+  const delivery = input.deliverTo;
+  if (delivery !== void 0) {
+    await hooks.step("deliver:detached", async () => {
+      if (await deps.store.getThread(delivery.threadId) === null) {
+        return;
+      }
+      const agent = input.agentName ?? "default";
+      await deps.store.appendMessage({
+        threadId: delivery.threadId,
+        role: "assistant",
+        content: lastText,
+        agentName: agent,
+        runId: hooks.runId
+      });
+      await deps.store.updateToolCall({
+        toolCallId: delivery.toolCallId,
+        status: "executed",
+        output: detachedDelivered({
+          agent,
+          runId: hooks.runId,
+          text: lastText
+        })
+      });
+    });
+  }
   await hooks.step("persist:run:end", async () => {
     await deps.store.recordRunEnd?.({
       runId: hooks.runId,
@@ -1238,7 +3657,10 @@ ${buildContextBlock(passages)}`;
     outputTokens: totalOutput
   });
   return {
-    text: lastText
+    text: lastText,
+    ...structured !== void 0 ? {
+      object: structured
+    } : {}
   };
 }
 __name(runAgentLoop, "runAgentLoop");
@@ -1252,6 +3674,7 @@ export {
   AGENT_DURABLE_RUNNER,
   AGENT_EMBEDDING_PROVIDER,
   AGENT_GOVERNANCE_QUERIES,
+  AGENT_MEMORY,
   AGENT_MODEL,
   AGENT_OPTIONS,
   AGENT_PRICING_STORE,
@@ -1262,53 +3685,131 @@ export {
   AGENT_ROLES_POLICY,
   AGENT_RUNNER,
   AGENT_SINK,
+  AGENT_SKILLS,
+  AGENT_SKILL_SOURCES,
   AGENT_SPAN_EVENTS,
   AGENT_STORE,
   AGENT_TOOL_REGISTRY,
+  ASK_TOOL_DESCRIPTION,
+  ASK_TOOL_NAME,
   AgentRegistry,
   AgentStreamError,
+  DEFAULT_HISTORY_SUMMARY_INSTRUCTION,
+  DEFAULT_INCREMENTAL_LOOKBACK_CHARS,
+  DEFAULT_INTAKE_PREAMBLE,
+  DEFAULT_MAX_FACT_CHARS,
+  DEFAULT_MAX_MEMORIES,
+  DEFAULT_MAX_SKILLS,
+  DEFAULT_STRUCTURED_OUTPUT_INSTRUCTION,
   DEFAULT_TOOL_TRANSIENT_RETRY_ATTEMPTS,
   DEFAULT_TOOL_TRANSIENT_RETRY_BACKOFF_MS,
   DefaultRolesPolicy,
+  GLOBAL_SCOPE,
+  MAX_ASK_QUESTIONS,
+  OutputRejectedError,
+  ProcessorFailedError,
   QuotaExceededError,
+  REMEMBER_TOOL_DESCRIPTION,
+  REMEMBER_TOOL_NAME,
+  RunCancelledError,
+  SKILL_TOOL_DESCRIPTION,
+  SKILL_TOOL_NAME,
+  StructuredOutputError,
   THREAD_DETAIL_CONTENT_CHARS,
   ToolDisabledError,
   ToolForbiddenError,
   ToolInputInvalidError,
   ToolNotFoundError,
   ToolRegistry,
+  actorScope,
   agentDiagnosticKey,
+  agentFailureCode,
+  askInputSchema,
+  askToolDefinition,
   bucketByActor,
   bucketByModel,
   bucketByThread,
   bucketUsageTrend,
+  buildMemoryBlock,
+  buildSkillsBlock,
   canActorUseTool,
+  compositeSkillProvider,
+  createFrameBuffer,
+  createIncrementalGate,
   dayBoundsUtc,
+  decodeStreamEvent,
+  defaultScopeResolver,
+  detachedDelivered,
+  detachedStarted,
+  detachedUnsettled,
   encodeStreamEvent,
   estimateCost,
+  estimateMessageTokens,
+  extractJson,
   filterToolsByAllowList,
   filterToolsByCanUse,
   filterToolsByEnabled,
   filterToolsByRole,
+  gateFollowUps,
+  gateTail,
   invokeWithTransientRetry,
+  isControlFlowSignal,
+  isReplayIntegrityError,
   isToolEnabled,
   isTransientToolError,
+  loadSkill,
+  memoryForgetVerdict,
+  memoryWriteVerdict,
+  normalizeDelegation,
+  normalizeElicitationReply,
+  offerMemories,
+  offerSkills,
   publishAgentDelegated,
+  publishAgentMemoryResolved,
+  publishAgentMemoryWritten,
   publishAgentMessage,
   publishAgentQuotaExceeded,
   publishAgentRetrieved,
   publishAgentRunFailed,
   publishAgentRunFinished,
   publishAgentRunStarted,
+  publishAgentSkillsResolved,
   publishAgentToolCall,
   publishAgentToolRetry,
+  releaseGatedFrames,
+  rememberInputSchema,
+  rememberToolDefinition,
+  renderElicitationAnswers,
+  repairInstruction,
+  resolveElicitation,
+  resolveGateLookback,
+  resolveMemoryDigest,
+  resolveOutputGateMode,
+  resolveSkillCatalog,
   resolveToolTransientRetryNumbers,
   rollupThreadUsage,
   runAgentLoop,
+  runInputProcessors,
+  runOutputProcessors,
   seedModelPrices,
+  settleAll,
+  settleElicitation,
+  settleUnsettledDelegation,
+  skillInputSchema,
+  skillToolDefinition,
+  skillWriteVerdict,
+  staticSkillProvider,
+  summarizeWithModel,
+  tenantScope,
   traceLlmTurn,
   traceToolExecution,
   truncateDetailContent,
-  withToolTimeout
+  validateStructured,
+  windowHistory,
+  withAskTool,
+  withMemoryTool,
+  withSkillTool,
+  withToolTimeout,
+  writeMemory
 };
 //# sourceMappingURL=index.js.map