@dudousxd/nestjs-agent 0.11.1 → 0.12.0

package/dist/durable/index.cjs

@@ -31,10 +31,10 @@ __export(durable_exports, {
 module.exports = __toCommonJS(durable_exports);
 
 // src/durable/agent-run.workflow.ts
-var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
-var import_nestjs_durable = require("@dudousxd/nestjs-durable");
+var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_durable2 = require("@dudousxd/nestjs-durable");
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
-var import_common = require("@nestjs/common");
+var import_common2 = require("@nestjs/common");
 
 // src/agent-deps.ts
 function utcDay(date = /* @__PURE__ */ new Date()) {
@@ -52,10 +52,10 @@ function childSinkWriter(writer) {
 }
 __name(childSinkWriter, "childSinkWriter");
 
-// src/durable/dispatched-steps.token.ts
-var AGENT_DISPATCHED_STEPS = Symbol.for("@dudousxd/nestjs-agent:dispatched-steps");
-
-// src/durable/agent-run.workflow.ts
+// src/durable/agent-run.steps.ts
+var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_durable = require("@dudousxd/nestjs-durable");
+var import_common = require("@nestjs/common");
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -73,34 +73,236 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
+var AgentRunSteps = class {
+  static {
+    __name(this, "AgentRunSteps");
+  }
+  factory;
+  constructor(factory) {
+    this.factory = factory;
+  }
+  /**
+  * Retryable: every side effect (persist/quota/stream markers) happens loop-side under
+  * `hooks.step`, so a durable retry only re-runs the model call and re-streams its tokens — never
+  * double-writes. NEVER call `writer.end()`/`fail()` here: the workflow owns the stream's lifecycle,
+  * across however many turns/retries it takes.
+  */
+  async llm(input) {
+    const deps = this.factory.forAgent(input.agentName);
+    const tools = (0, import_nestjs_agent_core.withMemoryTool)({
+      tools: (0, import_nestjs_agent_core.withSkillTool)({
+        tools: (0, import_nestjs_agent_core.withAskTool)({
+          tools: await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList),
+          ask: deps.ask
+        }),
+        enabled: deps.skills !== void 0
+      }),
+      enabled: deps.memory?.provider.write !== void 0
+    });
+    const buffer = input.bufferOutput === true ? (0, import_nestjs_agent_core.createFrameBuffer)() : void 0;
+    let writer;
+    if (buffer !== void 0) {
+      writer = buffer.writer;
+    } else {
+      const opened = await deps.sink.open(input.sinkRunId);
+      writer = input.childSink ? childSinkWriter(opened) : opened;
+    }
+    const turn = await (0, import_nestjs_agent_core.traceLlmTurn)(input.runId, input.step, () => deps.model.runTurn({
+      system: input.system,
+      messages: input.messages,
+      tools,
+      sink: writer
+    }));
+    return buffer === void 0 ? turn : {
+      ...turn,
+      bufferedFrames: buffer.frames()
+    };
+  }
+  /**
+  * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
+  * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
+  * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
+  * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
+  * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
+  * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
+  * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
+  * ATTEMPT, so a retried invocation gets its own fresh timeout window.
+  */
+  async tool(input) {
+    const deps = this.factory.forAgent(input.ctx.agentName);
+    if (deps.registry.spec(input.toolName)?.kind === "action" && input.toolType !== "action") {
+      throw new Error(`tool "${input.toolName}" is an action tool but was dispatched without approval: the dispatching process resolved its kind against a registry that does not have it`);
+    }
+    const ctx = {
+      ...input.ctx
+    };
+    const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
+    const transientRetry = input.transientRetry === false ? false : {
+      attempts: input.transientRetry.attempts,
+      backoffMs: input.transientRetry.backoffMs,
+      ...localClassify !== void 0 ? {
+        classify: localClassify
+      } : {}
+    };
+    return (0, import_nestjs_agent_core.traceToolExecution)(input.ctx.runId, {
+      toolCallId: input.toolCallId,
+      toolName: input.toolName,
+      toolType: input.toolType
+    }, () => (0, import_nestjs_agent_core.invokeWithTransientRetry)(() => {
+      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
+      return input.timeoutMs !== void 0 ? (0, import_nestjs_agent_core.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
+    }, transientRetry, {
+      onRetry: /* @__PURE__ */ __name((attempt, error) => {
+        (0, import_nestjs_agent_core.publishAgentToolRetry)({
+          toolName: input.toolName,
+          toolCallId: input.toolCallId,
+          attempt,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }, "onRetry")
+    }));
+  }
+};
+_ts_decorate([
+  (0, import_nestjs_durable.Step)({
+    retries: 3
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], AgentRunSteps.prototype, "llm", null);
+_ts_decorate([
+  (0, import_nestjs_durable.Step)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], AgentRunSteps.prototype, "tool", null);
+AgentRunSteps = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_DEPS_FACTORY)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
+  ])
+], AgentRunSteps);
+
+// src/durable/dispatched-steps.token.ts
+var AGENT_DISPATCHED_STEPS = Symbol.for("@dudousxd/nestjs-agent:dispatched-steps");
+
+// src/durable/agent-run.workflow.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
 var AgentRunWorkflow = class _AgentRunWorkflow {
   static {
     __name(this, "AgentRunWorkflow");
   }
   factory;
   store;
-  steps;
   dispatchedSteps;
-  constructor(factory, store, steps, dispatchedSteps) {
+  runs;
+  constructor(factory, store, dispatchedSteps, runs) {
     this.factory = factory;
     this.store = store;
-    this.steps = steps;
     this.dispatchedSteps = dispatchedSteps;
+    this.runs = runs;
+  }
+  /**
+  * Has someone asked this run to stop? Read from the runtime's own run status, which is where
+  * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
+  * `cancelled` once it has settled.
+  *
+  * Costs a run read at each of the loop's observation points (two per step). That is a row the
+  * control plane already has, against a turn that is otherwise making model calls, and it buys the
+  * property that matters: the answer comes from a place BOTH the canceller and every pod that might
+  * replay this run can see.
+  *
+  * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
+  * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs
+  * because a status read timed out. The loop journals that answer like any other, so two processes
+  * can never disagree about what was seen here.
+  */
+  async isCancelled(runId) {
+    try {
+      const status = (await this.runs?.getRunDetail(runId))?.run.status;
+      return status === "cancelled" || status === "cancelling";
+    } catch {
+      return false;
+    }
+  }
+  /**
+  * Settle the delegation a DETACHED run was started for, when that run ends without an answer.
+  *
+  * The loop delivers its own success (`deliver:detached`) but cannot catch its own crash, and the
+  * runtime settles the run row without knowing anything delegated it. Left alone, the card in the
+  * calling conversation says "started" for ever — the one state a reader can neither wait on nor
+  * act on. A no-op for every other run: only a detached one carries a delivery address.
+  */
+  async settleDetachedParent(ctx, input, outcome) {
+    const delivery = input.deliverTo;
+    if (delivery === void 0) {
+      return;
+    }
+    await ctx.localStep("deliver:detached:unsettled", () => (0, import_nestjs_agent_core2.settleUnsettledDelegation)({
+      store: this.store,
+      delivery,
+      agent: input.agentName ?? "default",
+      runId: ctx.runId,
+      status: outcome.status,
+      ...outcome.error !== void 0 ? {
+        error: outcome.error
+      } : {}
+    }));
   }
   async run(ctx, input) {
     const day = input.day ?? utcDay();
     const deps = this.factory.forAgent(input.agentName);
-    const dispatchSteps = this.dispatchedSteps ? this.steps : void 0;
-    if (input.sinkRunId !== void 0) {
+    const dispatchSteps = this.dispatchedSteps && await ctx.patched("agent:dispatched-steps");
+    if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
       await ctx.localStep("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
     }
     const sinkRunId = input.sinkRunId ?? ctx.runId;
+    const chainBelow = [
+      ...input.delegationPath ?? [],
+      ...input.agentName !== void 0 ? [
+        input.agentName
+      ] : []
+    ];
     const hooks = {
       runId: ctx.runId,
       // A child forwards into the top-level sink but must not end/fail it (the top-level run owns it).
       openSink: /* @__PURE__ */ __name(async () => input.sinkRunId !== void 0 ? childSinkWriter(await deps.sink.open(sinkRunId)) : deps.sink.open(ctx.runId), "openSink"),
       awaitApproval: /* @__PURE__ */ __name((call) => ctx.waitForSignal(`tool:${ctx.runId}:${call.id}`), "awaitApproval"),
+      // The same wait, on the same signal key, carrying a typed answer instead of a yes/no — so a
+      // question set and an approval reach a parked run through one path, and the HTTP surface that
+      // settles either one is the same `POST /agent/tool-call/*` family.
+      awaitAnswers: /* @__PURE__ */ __name((request) => ctx.waitForSignal(`tool:${ctx.runId}:${request.id}`), "awaitAnswers"),
       step: /* @__PURE__ */ __name((name, fn) => ctx.localStep(name, fn), "step"),
+      // Both durable step primitives take their checkpoint position on the CALL, before their first
+      // await, so launching a batch in one tick — what `settleAll` does — fixes the block of
+      // positions in call order however the tools then settle. `ctx.patched` keeps a run that
+      // recorded the one-call-at-a-time shape replaying against that shape.
+      parallel: import_nestjs_agent_core2.settleAll,
+      cancelled: /* @__PURE__ */ __name(() => this.isCancelled(ctx.runId), "cancelled"),
+      patched: /* @__PURE__ */ __name((id) => ctx.patched(id), "patched"),
       // Dispatched-step suspends must escape the loop's tool catch — control flow, not a tool
       // failure. Marker-based predicate, NOT instanceof: the signal's CLASS differs by runtime
       // (engine in-process throws durable-core's WorkflowSuspended/ContinueAsNew; the BullMQ thin
@@ -121,15 +323,54 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
           userText: task,
           day,
           delegationDepth: (input.delegationDepth ?? 0) + 1,
+          delegationPath: chainBelow,
+          parentRunId: ctx.runId,
           sinkRunId
         });
       }, "runAgent"),
+      // The same delegation, not awaited: `ctx.startChild` records a `spawn:<childRunId>` at this
+      // position and returns, so THIS turn ends while the child is still working. Two things the
+      // awaited form does are deliberately left off:
+      //   - no `sinkRunId`. A detached run owns its own stream. Forwarding it into the turn that
+      //     started it would write tokens, and a pending action-tool frame, into a stream whose
+      //     reader has already seen `done` — and would put the child's approval card in whatever
+      //     turn happened to be open. Its approval goes to the pending-approvals surface instead,
+      //     which it reaches for free: the call is persisted `pending_approval` against the child's
+      //     OWN runId, and that is what `runForToolCall` answers with.
+      //   - `deliverTo` instead. The parent's tool result is a receipt, so the answer needs an
+      //     address of its own, and by the time it exists nobody is holding one.
+      startAgent: /* @__PURE__ */ __name(async ({ agentName, task, toolCallId: toolCallId2 }) => {
+        const subThreadId = await ctx.localStep(`subthread:${agentName}`, async () => {
+          const thread = await this.store.createThread({
+            actor: input.actor,
+            transient: true
+          });
+          return thread.id;
+        });
+        const childRunId = await ctx.startChild(_AgentRunWorkflow, {
+          agentName,
+          threadId: subThreadId,
+          actor: input.actor,
+          userText: task,
+          day,
+          delegationDepth: (input.delegationDepth ?? 0) + 1,
+          delegationPath: chainBelow,
+          parentRunId: ctx.runId,
+          deliverTo: {
+            threadId: input.threadId,
+            toolCallId: toolCallId2
+          }
+        });
+        return {
+          runId: childRunId
+        };
+      }, "startAgent"),
       // Routes the two long steps through AgentRunSteps as engine-dispatched `ctx.step`s instead of
       // `ctx.localStep`s, so a turn isn't pinned to this workflow worker for the model call or a tool
       // execution. `sinkRunId`/`childSink` are sink routing this workflow already resolved above —
       // core's dispatchLlm signature stays sink-topology-agnostic, so we add them here, not in core.
-      ...dispatchSteps !== void 0 ? {
-        dispatchLlm: /* @__PURE__ */ __name((index, envelope) => ctx.step(dispatchSteps.llm, {
+      ...dispatchSteps ? {
+        dispatchLlm: /* @__PURE__ */ __name((index, envelope) => ctx.step(AgentRunSteps.prototype.llm, {
           ...envelope,
           runId: ctx.runId,
           step: index,
@@ -141,7 +382,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         // ('agent'-kind delegations branch to runAgent earlier in the loop), so anything that
         // isn't 'action' is defensively 'read' — the same posture core takes for an
         // unresolvable `kind`.
-        dispatchTool: /* @__PURE__ */ __name((call, envelope) => ctx.step(dispatchSteps.tool, {
+        dispatchTool: /* @__PURE__ */ __name((call, envelope) => ctx.step(AgentRunSteps.prototype.tool, {
           ...envelope,
           toolCallId: call.id,
           toolType: call.kind === "action" ? "action" : "read"
@@ -149,7 +390,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       } : {}
     };
     try {
-      const result = await (0, import_nestjs_agent_core.runAgentLoop)({
+      const result = await (0, import_nestjs_agent_core2.runAgentLoop)({
         ...deps,
         day
       }, input, hooks);
@@ -159,9 +400,28 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       if ((0, import_nestjs_durable_core.isWorkflowControlFlowSignal)(error)) {
         throw error;
       }
+      if (error instanceof import_nestjs_agent_core2.RunCancelledError) {
+        await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
+        await this.settleDetachedParent(ctx, input, {
+          status: "cancelled"
+        });
+        throw error;
+      }
+      if ((0, import_nestjs_agent_core2.isReplayIntegrityError)(error)) {
+        const failure = {
+          code: "run_failed",
+          message: error.message
+        };
+        (0, import_nestjs_agent_core2.publishAgentRunFailed)({
+          runId: ctx.runId,
+          ...failure
+        });
+        await (await hooks.openSink()).fail(failure);
+        throw error;
+      }
       const message = error instanceof Error ? error.message : String(error);
-      const code = error instanceof import_nestjs_agent_core.QuotaExceededError ? "quota_exceeded" : "run_failed";
-      (0, import_nestjs_agent_core.publishAgentRunFailed)({
+      const code = (0, import_nestjs_agent_core2.agentFailureCode)(error);
+      (0, import_nestjs_agent_core2.publishAgentRunFailed)({
         runId: ctx.runId,
         code,
         message
@@ -173,6 +433,10 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         errorMessage: message
       }) ?? Promise.resolve());
       await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
+      await this.settleDetachedParent(ctx, input, {
+        status: "failed",
+        error: message
+      });
       const writer = await hooks.openSink();
       await writer.fail({
         code,
@@ -182,143 +446,29 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     }
   }
 };
-AgentRunWorkflow = _ts_decorate([
-  (0, import_common.Injectable)(),
-  (0, import_nestjs_durable.Workflow)({
+AgentRunWorkflow = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  (0, import_nestjs_durable2.Workflow)({
     name: "agent.run",
     version: "1"
   }),
-  _ts_param(0, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_DEPS_FACTORY)),
-  _ts_param(1, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_STORE)),
-  _ts_param(2, (0, import_common.Optional)()),
-  _ts_param(3, (0, import_common.Inject)(AGENT_DISPATCHED_STEPS)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
-    typeof AgentStore === "undefined" ? Object : AgentStore,
-    Object,
-    Boolean
-  ])
-], AgentRunWorkflow);
-
-// src/durable/agent-run.steps.ts
-var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
-var import_nestjs_durable2 = require("@dudousxd/nestjs-durable");
-var import_common2 = require("@nestjs/common");
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate2, "_ts_decorate");
-function _ts_metadata2(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata2, "_ts_metadata");
-function _ts_param2(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param2, "_ts_param");
-var AgentRunSteps = class {
-  static {
-    __name(this, "AgentRunSteps");
-  }
-  factory;
-  constructor(factory) {
-    this.factory = factory;
-  }
-  /**
-  * Retryable: every side effect (persist/quota/stream markers) happens loop-side under
-  * `hooks.step`, so a durable retry only re-runs the model call and re-streams its tokens — never
-  * double-writes. NEVER call `writer.end()`/`fail()` here: the workflow owns the stream's lifecycle,
-  * across however many turns/retries it takes.
-  */
-  async llm(input) {
-    const deps = this.factory.forAgent(input.agentName);
-    const tools = await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList);
-    const opened = await deps.sink.open(input.sinkRunId);
-    const writer = input.childSink ? childSinkWriter(opened) : opened;
-    return (0, import_nestjs_agent_core2.traceLlmTurn)(input.runId, input.step, () => deps.model.runTurn({
-      system: input.system,
-      messages: input.messages,
-      tools,
-      sink: writer
-    }));
-  }
-  /**
-  * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
-  * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
-  * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
-  * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
-  * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
-  * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
-  * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
-  * ATTEMPT, so a retried invocation gets its own fresh timeout window.
-  */
-  async tool(input) {
-    const deps = this.factory.forAgent(input.ctx.agentName);
-    const ctx = {
-      ...input.ctx
-    };
-    const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
-    const transientRetry = input.transientRetry === false ? false : {
-      attempts: input.transientRetry.attempts,
-      backoffMs: input.transientRetry.backoffMs,
-      ...localClassify !== void 0 ? {
-        classify: localClassify
-      } : {}
-    };
-    return (0, import_nestjs_agent_core2.traceToolExecution)(input.ctx.runId, {
-      toolCallId: input.toolCallId,
-      toolName: input.toolName,
-      toolType: input.toolType
-    }, () => (0, import_nestjs_agent_core2.invokeWithTransientRetry)(() => {
-      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
-      return input.timeoutMs !== void 0 ? (0, import_nestjs_agent_core2.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
-    }, transientRetry, {
-      onRetry: /* @__PURE__ */ __name((attempt, error) => {
-        (0, import_nestjs_agent_core2.publishAgentToolRetry)({
-          toolName: input.toolName,
-          toolCallId: input.toolCallId,
-          attempt,
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }, "onRetry")
-    }));
-  }
-};
-_ts_decorate2([
-  (0, import_nestjs_durable2.Step)({
-    retries: 3
-  }),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
-  ]),
-  _ts_metadata2("design:returntype", Promise)
-], AgentRunSteps.prototype, "llm", null);
-_ts_decorate2([
-  (0, import_nestjs_durable2.Step)(),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
-  ]),
-  _ts_metadata2("design:returntype", Promise)
-], AgentRunSteps.prototype, "tool", null);
-AgentRunSteps = _ts_decorate2([
-  (0, import_common2.Injectable)(),
   _ts_param2(0, (0, import_common2.Inject)(import_nestjs_agent_core2.AGENT_DEPS_FACTORY)),
+  _ts_param2(1, (0, import_common2.Inject)(import_nestjs_agent_core2.AGENT_STORE)),
+  _ts_param2(2, (0, import_common2.Inject)(AGENT_DISPATCHED_STEPS)),
+  _ts_param2(3, (0, import_common2.Optional)()),
+  _ts_param2(3, (0, import_common2.Inject)(import_nestjs_durable2.RUN_GATEWAY)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    Boolean,
+    typeof RunGateway === "undefined" ? Object : RunGateway
   ])
-], AgentRunSteps);
+], AgentRunWorkflow);
 
 // src/durable/durable-agent-runner.ts
 var import_node_crypto = require("crypto");
+var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
 var import_nestjs_durable3 = require("@dudousxd/nestjs-durable");
 var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
 var import_common3 = require("@nestjs/common");
@@ -333,13 +483,26 @@ function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata3, "_ts_metadata");
-var DurableAgentRunner = class {
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var DurableAgentRunner = class _DurableAgentRunner {
   static {
     __name(this, "DurableAgentRunner");
   }
   workflows;
-  constructor(workflows) {
+  runs;
+  store;
+  sink;
+  logger = new import_common3.Logger(_DurableAgentRunner.name);
+  constructor(workflows, runs, store, sink) {
     this.workflows = workflows;
+    this.runs = runs;
+    this.store = store;
+    this.sink = sink;
   }
   async start(input) {
     const stamped = {
@@ -358,27 +521,62 @@ var DurableAgentRunner = class {
       runId
     };
   }
-  async signal(runId, toolCallId, decision) {
-    await this.workflows.signal(`tool:${runId}:${toolCallId}`, decision);
+  async signal(runId, toolCallId2, reply) {
+    await this.workflows.signal(`tool:${runId}:${toolCallId2}`, reply);
   }
-  async cancel(_runId) {
-    await Promise.resolve();
+  /**
+  * Stop a run, and settle what the durable runtime knows nothing about.
+  *
+  * `compensate: true` is the form that gives the BODY a chance: it moves the run to `cancelling`
+  * (which is what the workflow's own cancel observation reads) and then re-drives it, so a turn
+  * running in-process unwinds at its next safe point instead of finishing. It also guarantees the
+  * outcome for the turn that CANNOT observe anything — one parked on `waitForSignal`, suspended
+  * inside a position its journal already holds — because that re-drive re-suspends and the runtime
+  * settles the run `cancelled` regardless. The cascade to child runs comes with it.
+  *
+  * Neither of those settles the agent's own state, so this does: the run row gets its own terminal,
+  * and the subscriber gets a `cancelled` frame followed by a normal end. Both are keyed by runId
+  * alone, which is why they belong here rather than in the body — the body is the only place that
+  * knows which THREAD was streaming, so releasing that stays there (see `AgentRunWorkflow`).
+  *
+  * A tool already executing is not interrupted, here or anywhere: see `haltIfCancelled` in core.
+  */
+  async cancel(runId) {
+    this.logger.log(`cancelling agent run ${runId}`);
+    await this.runs.cancel(runId, {
+      compensate: true
+    });
+    const writer = await this.sink.open(runId);
+    await writer.write((0, import_nestjs_agent_core3.encodeStreamEvent)({
+      kind: "cancelled"
+    }));
+    await writer.end();
+    await this.store.recordRunEnd?.({
+      runId,
+      status: "cancelled"
+    });
   }
 };
 DurableAgentRunner = _ts_decorate3([
   (0, import_common3.Injectable)(),
+  _ts_param3(1, (0, import_common3.Inject)(import_nestjs_durable3.RUN_GATEWAY)),
+  _ts_param3(2, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_STORE)),
+  _ts_param3(3, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_SINK)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof import_nestjs_durable3.WorkflowService === "undefined" ? Object : import_nestjs_durable3.WorkflowService
+    typeof import_nestjs_durable3.WorkflowService === "undefined" ? Object : import_nestjs_durable3.WorkflowService,
+    typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink
   ])
 ], DurableAgentRunner);
 
 // src/durable/agent-durable.module.ts
-var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
 var import_common4 = require("@nestjs/common");
 
 // src/in-process-sink.ts
-var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
 var InProcessTokenStreamSink = class {
   static {
     __name(this, "InProcessTokenStreamSink");
@@ -433,7 +631,7 @@ var InProcessTokenStreamSink = class {
       }
       if (buf.ended) {
         if (buf.failure !== void 0) {
-          throw new import_nestjs_agent_core3.AgentStreamError(buf.failure);
+          throw new import_nestjs_agent_core4.AgentStreamError(buf.failure);
         }
         return;
       }
@@ -458,7 +656,7 @@ function runnerProviders() {
   return [
     DurableAgentRunner,
     {
-      provide: import_nestjs_agent_core4.AGENT_DURABLE_RUNNER,
+      provide: import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
       useExisting: DurableAgentRunner
     },
     {
@@ -471,8 +669,8 @@ function runnerProviders() {
         return enabled;
       }, "useFactory"),
       inject: [
-        import_nestjs_agent_core4.AGENT_OPTIONS,
-        import_nestjs_agent_core4.AGENT_SINK
+        import_nestjs_agent_core5.AGENT_OPTIONS,
+        import_nestjs_agent_core5.AGENT_SINK
       ]
     }
   ];
@@ -491,7 +689,7 @@ AgentDurableHttpModule = _ts_decorate4([
       ...runnerProviders()
     ],
     exports: [
-      import_nestjs_agent_core4.AGENT_DURABLE_RUNNER,
+      import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
       AgentRunWorkflow,
       AGENT_DISPATCHED_STEPS
     ]
@@ -531,7 +729,7 @@ AgentDurableModule = _ts_decorate4([
       ...runnerProviders()
     ],
     exports: [
-      import_nestjs_agent_core4.AGENT_DURABLE_RUNNER,
+      import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
       AgentRunWorkflow,
       AgentRunSteps,
       AGENT_DISPATCHED_STEPS
@@ -540,13 +738,13 @@ AgentDurableModule = _ts_decorate4([
 ], AgentDurableModule);
 
 // src/agent.module.ts
-var import_nestjs_agent_core17 = require("@dudousxd/nestjs-agent-core");
-var import_common17 = require("@nestjs/common");
-var import_core3 = require("@nestjs/core");
+var import_nestjs_agent_core23 = require("@dudousxd/nestjs-agent-core");
+var import_common20 = require("@nestjs/common");
+var import_core4 = require("@nestjs/core");
 
 // src/agent-deps.factory.ts
-var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
 var import_nestjs_agent_core6 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core7 = require("@dudousxd/nestjs-agent-core");
 var import_common5 = require("@nestjs/common");
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -559,14 +757,15 @@ function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata4, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
-function delegateToolName(target) {
-  return `ask_${target.replace(/[^a-zA-Z0-9]+/g, "_")}`;
+__name(_ts_param4, "_ts_param");
+function delegateToolName(args) {
+  const slug = args.target.replace(/[^a-zA-Z0-9]+/g, "_");
+  return args.detached === true ? `start_${slug}` : `ask_${slug}`;
 }
 __name(delegateToolName, "delegateToolName");
 var AgentDepsFactory2 = class {
@@ -583,7 +782,9 @@ var AgentDepsFactory2 = class {
   promptContributors;
   quota;
   pricingStore;
-  constructor(options, model, store, sink, rolesPolicy, registry, agents, promptContributors, quota, pricingStore) {
+  skills;
+  memory;
+  constructor(options, model, store, sink, rolesPolicy, registry, agents, promptContributors, quota, pricingStore, skills, memory) {
     this.options = options;
     this.model = model;
     this.store = store;
@@ -594,6 +795,16 @@ var AgentDepsFactory2 = class {
     this.promptContributors = promptContributors;
     this.quota = quota;
     this.pricingStore = pricingStore;
+    this.skills = skills;
+    this.memory = memory;
+  }
+  /** The turn's memory seam, shared with the read-back endpoint. Undefined → memory is not configured. */
+  memoryConfig() {
+    return this.memory;
+  }
+  /** The turn's skills seam, shared with the listing endpoint. Undefined → skills are not configured. */
+  skillsConfig() {
+    return this.skills;
   }
   /**
   * The agent a turn uses when the caller names none: the explicit `defaultAgent` option, else the
@@ -610,7 +821,13 @@ var AgentDepsFactory2 = class {
     if (definition === void 0) {
       return void 0;
     }
-    const delegated = (definition.delegatesTo ?? []).map(delegateToolName);
+    const delegated = (definition.delegatesTo ?? []).map((edge) => {
+      const { agent, detached } = (0, import_nestjs_agent_core6.normalizeDelegation)(edge);
+      return delegateToolName({
+        target: agent,
+        detached
+      });
+    });
     if (definition.tools === void 0 && delegated.length === 0) {
       return void 0;
     }
@@ -625,6 +842,8 @@ var AgentDepsFactory2 = class {
     const toolAllowList = this.effectiveTools(definition);
     const followUpsCount = this.followUpsCount();
     const retrieval = this.options.retrieval;
+    const historyPolicy = this.historyPolicy(definition);
+    const ask = definition?.ask ?? this.options.ask;
     return {
       model: this.model,
       store: this.store,
@@ -634,6 +853,12 @@ var AgentDepsFactory2 = class {
       promptContributors: this.promptContributors,
       systemPrompt: definition?.systemPrompt ?? "You are a helpful assistant.",
       maxSteps: definition?.maxSteps ?? 8,
+      ...definition?.maxDelegationDepth !== void 0 ? {
+        maxDelegationDepth: definition.maxDelegationDepth
+      } : {},
+      ...definition?.maxAgentAppearances !== void 0 ? {
+        maxAgentAppearances: definition.maxAgentAppearances
+      } : {},
       ...definition?.modelId !== void 0 ? {
         modelId: definition.modelId
       } : {},
@@ -643,6 +868,37 @@ var AgentDepsFactory2 = class {
       ...this.pricingStore !== void 0 ? {
         pricingStore: this.pricingStore
       } : {},
+      ...historyPolicy !== void 0 ? {
+        historyPolicy
+      } : {},
+      inputProcessors: this.options.inputProcessors ?? [],
+      outputProcessors: this.options.outputProcessors ?? [],
+      ...definition?.outputSchema !== void 0 ? {
+        outputSchema: definition.outputSchema
+      } : {},
+      ...definition?.outputRepairAttempts !== void 0 ? {
+        outputRepairAttempts: definition.outputRepairAttempts
+      } : {},
+      ...definition?.intake !== void 0 ? {
+        intake: definition.intake
+      } : {},
+      // Most specific wins, exactly as `historyPolicy` resolves: the agent's own `@Agent({ ask })`,
+      // else the module-wide flag. Both are module config, so every process of a deployment agrees.
+      ...ask === true ? {
+        ask: true
+      } : {},
+      // Module-wide, never per-agent: a skill is a procedure, not a persona, and an agent that could
+      // opt out of one would make the catalog depend on which agent a turn happened to select — a
+      // per-turn fact the worker re-deriving the tool list cannot see.
+      ...this.skills !== void 0 ? {
+        skills: this.skills
+      } : {},
+      // Module-wide, never per-agent, for the same reason skills are: which memories a turn carries
+      // cannot depend on which persona answered it, or the worker re-deriving a dispatched turn's
+      // tool list would disagree with the loop about whether `remember` was offered.
+      ...this.memory !== void 0 ? {
+        memory: this.memory
+      } : {},
       ...toolAllowList !== void 0 ? {
         toolAllowList
       } : {},
@@ -663,6 +919,36 @@ var AgentDepsFactory2 = class {
       } : {}
     };
   }
+  /**
+  * The ceiling on how much of a thread this agent's turns carry, most specific wins: the agent's
+  * own `@Agent({ history })`, else a module-wide custom `historyPolicy`, else the module-wide
+  * `history` window. Undefined → unbounded, the behaviour of a module that configures none.
+  */
+  historyPolicy(definition) {
+    if (definition?.history !== void 0) {
+      return this.window(definition.history);
+    }
+    if (this.options.historyPolicy !== void 0) {
+      return this.options.historyPolicy;
+    }
+    return this.options.history === void 0 ? void 0 : this.window(this.options.history);
+  }
+  /** Build the built-in window policy from the declarative `{ maxMessages, maxTokens, summarize }`. */
+  window(config) {
+    return (0, import_nestjs_agent_core6.windowHistory)({
+      ...config.maxMessages !== void 0 ? {
+        maxMessages: config.maxMessages
+      } : {},
+      ...config.maxTokens !== void 0 ? {
+        maxTokens: config.maxTokens
+      } : {},
+      // The shared module model, not a per-agent one: an agent's `modelId` is an accounting label,
+      // and only one provider is ever bound.
+      ...config.summarize === true ? {
+        summarize: (0, import_nestjs_agent_core6.summarizeWithModel)(this.model)
+      } : {}
+    });
+  }
   /** Normalize the `followUps` option (`true` → 3, `{ count }` → count) to a number, or undefined. */
   followUpsCount() {
     const followUps = this.options.followUps;
@@ -677,17 +963,21 @@ var AgentDepsFactory2 = class {
 };
 AgentDepsFactory2 = _ts_decorate5([
   (0, import_common5.Injectable)(),
-  _ts_param3(0, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_OPTIONS)),
-  _ts_param3(1, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_MODEL)),
-  _ts_param3(2, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_STORE)),
-  _ts_param3(3, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_SINK)),
-  _ts_param3(4, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_ROLES_POLICY)),
-  _ts_param3(5, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_TOOL_REGISTRY)),
-  _ts_param3(6, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_REGISTRY)),
-  _ts_param3(7, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_PROMPT_CONTRIBUTORS)),
-  _ts_param3(8, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_QUOTA_STORE)),
-  _ts_param3(9, (0, import_common5.Optional)()),
-  _ts_param3(9, (0, import_common5.Inject)(import_nestjs_agent_core5.AGENT_PRICING_STORE)),
+  _ts_param4(0, (0, import_common5.Inject)(import_nestjs_agent_core7.AGENT_OPTIONS)),
+  _ts_param4(1, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_MODEL)),
+  _ts_param4(2, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_STORE)),
+  _ts_param4(3, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_SINK)),
+  _ts_param4(4, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_ROLES_POLICY)),
+  _ts_param4(5, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_TOOL_REGISTRY)),
+  _ts_param4(6, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_REGISTRY)),
+  _ts_param4(7, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_PROMPT_CONTRIBUTORS)),
+  _ts_param4(8, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_QUOTA_STORE)),
+  _ts_param4(9, (0, import_common5.Optional)()),
+  _ts_param4(9, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_PRICING_STORE)),
+  _ts_param4(10, (0, import_common5.Optional)()),
+  _ts_param4(10, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_SKILLS)),
+  _ts_param4(11, (0, import_common5.Optional)()),
+  _ts_param4(11, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_MEMORY)),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
@@ -695,16 +985,18 @@ AgentDepsFactory2 = _ts_decorate5([
     typeof AgentStore === "undefined" ? Object : AgentStore,
     typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
     typeof RolesPolicy === "undefined" ? Object : RolesPolicy,
-    typeof import_nestjs_agent_core5.ToolRegistry === "undefined" ? Object : import_nestjs_agent_core5.ToolRegistry,
-    typeof import_nestjs_agent_core5.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core5.AgentRegistry,
+    typeof import_nestjs_agent_core6.ToolRegistry === "undefined" ? Object : import_nestjs_agent_core6.ToolRegistry,
+    typeof import_nestjs_agent_core6.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core6.AgentRegistry,
     Array,
     Object,
+    Object,
+    Object,
     Object
   ])
 ], AgentDepsFactory2);
 
 // src/agent.service.ts
-var import_nestjs_agent_core7 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core8 = require("@dudousxd/nestjs-agent-core");
 var import_common6 = require("@nestjs/common");
 function _ts_decorate6(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -717,12 +1009,12 @@ function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata5, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__name(_ts_param5, "_ts_param");
 var AgentService = class {
   static {
     __name(this, "AgentService");
@@ -731,14 +1023,17 @@ var AgentService = class {
   store;
   deps;
   quota;
-  constructor(runner, store, deps, quota) {
+  staging;
+  constructor(runner, store, deps, quota, staging) {
     this.runner = runner;
     this.store = store;
     this.deps = deps;
     this.quota = quota;
+    this.staging = staging;
   }
   async chat(params) {
     const agentName = await this.resolveAgentName(params.agentName, params.threadId);
+    const attachments = await this.resolveAttachments(params.actor, params.attachments ?? []);
     let threadId = params.threadId;
     if (threadId === void 0) {
       if (params.regenerate === true) {
@@ -763,8 +1058,8 @@ var AgentService = class {
       ...params.regenerate === true ? {
         regenerate: true
       } : {},
-      ...params.attachments !== void 0 ? {
-        attachments: params.attachments
+      ...attachments.length > 0 ? {
+        attachments
       } : {},
       ...params.pageContext !== void 0 ? {
         pageContext: params.pageContext
@@ -777,18 +1072,66 @@ var AgentService = class {
       threadId
     };
   }
+  /**
+  * Rebuild this turn's attachments from the staging store, keyed by the ids the caller claimed.
+  * The model provider fetches {@link MessageAttachment.url} verbatim, so that url is only ever
+  * allowed to come from the host's own store — a caller that could name it could point the server
+  * at anything it can reach (cloud metadata, internal services) and read the response back out of
+  * the model's answer.
+  *
+  * No store bound means no way to tell an id the actor owns from one they don't, so a turn simply
+  * cannot carry attachments: 501 rather than trusting the request.
+  */
+  async resolveAttachments(actor, refs) {
+    if (refs.length === 0) {
+      return [];
+    }
+    const staging = this.staging;
+    if (staging === void 0 || typeof staging.resolve !== "function") {
+      throw new import_common6.NotImplementedException("Message attachments require an AGENT_ATTACHMENT_STAGING provider implementing resolve(); attachment urls are never taken from the request.");
+    }
+    const resolved = [];
+    for (const ref of refs) {
+      const attachment = await staging.resolve({
+        mediaId: ref.mediaId,
+        actor
+      });
+      if (attachment === null) {
+        throw new import_common6.ForbiddenException(`attachment ${ref.mediaId} is not available to this actor`);
+      }
+      resolved.push(attachment);
+    }
+    return resolved;
+  }
+  /**
+  * The run's live token stream, WITHOUT an ownership check — for in-process callers that are
+  * already authorized (the MCP bridge, a host's own job code), the same split as
+  * {@link signalToolCall} vs {@link approve}. Anything reachable from a request must go through
+  * {@link subscribeAs} instead: a runId is the only thing standing between a caller and another
+  * actor's answer, tool arguments and tool results.
+  */
   subscribe(runId) {
     return this.deps.forAgent().sink.subscribe(runId);
   }
-  async approve(actor, toolCallId) {
-    await this.assertOwnsToolCall(actor, toolCallId);
-    return this.signalToolCall(toolCallId, {
+  /**
+  * {@link subscribe}, gated the way {@link cancel} is: only the actor whose thread is currently
+  * streaming this run may read it. A run that has already finished is reported missing rather than
+  * replayed — the runner clears the thread's active stream as the run ends, and that field is what
+  * ownership is derived from.
+  */
+  async subscribeAs(actor, runId) {
+    await this.assertOwnsActiveStream(actor, runId);
+    return this.subscribe(runId);
+  }
+  async approve(actor, toolCallId2) {
+    await this.assertOwnsToolCall(actor, toolCallId2);
+    return this.signalToolCall(toolCallId2, {
       approved: true
     });
   }
-  async reject(actor, toolCallId, reason) {
-    await this.assertOwnsToolCall(actor, toolCallId);
-    return this.signalToolCall(toolCallId, {
+  async reject(actor, toolCallId2, reason) {
+    await this.assertOwnsToolCall(actor, toolCallId2);
+    return this.signalToolCall(toolCallId2, {
       approved: false,
       ...reason !== void 0 ? {
         reason
@@ -796,6 +1139,34 @@ var AgentService = class {
     });
   }
   /**
+  * Answer a parked question set. An omitted question takes the request's own pre-picked default —
+  * resolved by the LOOP against the request it already holds, so "the user just submitted" and
+  * "the user picked exactly the defaults" persist as the same answers, and no client has to
+  * re-send what it was shown.
+  */
+  async answer(actor, toolCallId2, answers2 = {}) {
+    await this.assertOwnsToolCall(actor, toolCallId2);
+    const reply = {
+      answers: answers2,
+      answeredByRef: actor.id
+    };
+    return this.signalToolCall(toolCallId2, reply);
+  }
+  /**
+  * Decline to answer and let the agent proceed on its own assumptions. NOT the same as confirming
+  * them: the run records this as a rejection, so a reader auditing what the agent was told can
+  * tell a choice the user made from one they refused to make.
+  */
+  async skip(actor, toolCallId2) {
+    await this.assertOwnsToolCall(actor, toolCallId2);
+    const reply = {
+      answers: {},
+      skipped: true,
+      answeredByRef: actor.id
+    };
+    return this.signalToolCall(toolCallId2, reply);
+  }
+  /**
   * The decision core behind approve/reject, WITHOUT an ownership check: resolves the run
   * currently awaiting `toolCallId` and signals it. `approve`/`reject` above call this after their
   * own `assertOwnsToolCall` gate; the console `AgentApprovalPort` adapter (bound by `AgentModule`)
@@ -803,9 +1174,9 @@ var AgentService = class {
   * re-deriving thread ownership here would reject a legitimate operator decision (an operator is
   * not the thread's own actor).
   */
-  async signalToolCall(toolCallId, decision) {
-    const runId = await this.resolveRunForToolCall(toolCallId);
-    return this.runner.signal(runId, toolCallId, decision);
+  async signalToolCall(toolCallId2, reply) {
+    const runId = await this.resolveRunForToolCall(toolCallId2);
+    return this.runner.signal(runId, toolCallId2, reply);
   }
   async cancel(actor, runId) {
     await this.assertOwnsActiveStream(actor, runId);
@@ -872,20 +1243,33 @@ var AgentService = class {
   /**
   * Agent-selection precedence for a `chat()` call with no explicit `agentName`: the thread's own
   * `defaultAgent` (if the thread exists and one is set) wins over the module's configured default.
-  * Skips the thread lookup entirely when the caller already named an agent or there's no thread yet.
+  * Skips the store entirely when the caller already named an agent or there's no thread yet.
+  *
+  * What this needs is one nullable scalar, so it asks for one. `getThread` returns the entire
+  * transcript — every message, every persisted tool output — and this discards all of it; on a
+  * long thread with large tool results that is hundreds of kilobytes read per turn, outside the
+  * workflow, for a string. A store predating {@link ThreadDefaultAgentReader} still answers, via
+  * the full read.
   */
   async resolveAgentName(agentName, threadId) {
     if (agentName !== void 0) {
       return agentName;
     }
     if (threadId !== void 0) {
-      const thread = await this.store.getThread(threadId);
-      if (thread?.defaultAgent !== void 0 && thread.defaultAgent !== null) {
-        return thread.defaultAgent;
+      const threadDefault = await this.threadDefaultAgent(threadId);
+      if (threadDefault !== null) {
+        return threadDefault;
       }
     }
     return this.deps.defaultAgentName();
   }
+  async threadDefaultAgent(threadId) {
+    const projecting = this.store;
+    if (typeof projecting.defaultAgentForThread === "function") {
+      return projecting.defaultAgentForThread(threadId);
+    }
+    return (await this.store.getThread(threadId))?.defaultAgent ?? null;
+  }
   async toSummaryView(thread) {
     return {
       ...thread,
@@ -908,13 +1292,74 @@ var AgentService = class {
     return this.store.promoteThread(threadId);
   }
   /**
-  * Drop a message and everything after it — the "edit and resend" / "delete from here" primitive.
-  * The client then sends a fresh turn on the truncated thread. Ownership-gated like the other
-  * thread-scoped mutations.
+  * Drop a message and everything after it — the "edit and resend" / "delete from here" primitive.
+  * The client then sends a fresh turn on the truncated thread. Ownership-gated like the other
+  * thread-scoped mutations.
+  */
+  async truncateThreadFrom(actor, threadId, messageId) {
+    await this.assertOwnsThread(actor, threadId);
+    return this.store.truncateFrom(threadId, messageId);
+  }
+  /**
+  * Every file this actor has staged, newest first — across threads, including uploads that were
+  * never sent, which nothing else on this surface can see.
+  *
+  * Metadata only. A url is minted per turn by `resolve` so it can be short-lived, and handing one
+  * back per entry would undo that for the price of rendering a list.
+  */
+  async listAttachments(actor, options = {}) {
+    const list = this.attachmentInventory();
+    return list({
+      actor,
+      ...options.limit !== void 0 ? {
+        limit: options.limit
+      } : {}
+    });
+  }
+  /**
+  * This actor's staged media that no live message references and that is old enough not to be an
+  * upload in flight — the candidate set for a sweep. Returns them; never deletes them. The bytes
+  * are the host's, and so is the decision.
+  *
+  * `olderThan` is required and has no default. How long a composer may sit open with a file
+  * attached is the host's knowledge, and a library-chosen grace period would eventually delete a
+  * file someone was about to send. The staging store is asked to apply it, and the result is
+  * filtered again here: a store that ignores the hint would otherwise turn this into exactly that
+  * bug, silently.
+  *
+  * Both halves must be answerable or this refuses. An unanswerable reference query means "cannot
+  * tell", and treating it as "nothing is referenced" would hand back every attachment the actor
+  * ever sent, marked safe to delete.
+  */
+  async collectableAttachments(actor, options) {
+    const list = this.attachmentInventory();
+    const referencedMediaIds = this.store.referencedMediaIds?.bind(this.store);
+    if (referencedMediaIds === void 0) {
+      throw new import_common6.NotImplementedException("Collecting attachments requires an AgentStore that implements referencedMediaIds(); the bound store cannot say which media a message still references, and guessing would delete files that are in use.");
+    }
+    const stagedBefore = options.olderThan.toISOString();
+    const inventory = await list({
+      actor,
+      stagedBefore,
+      ...options.limit !== void 0 ? {
+        limit: options.limit
+      } : {}
+    });
+    const aged = inventory.filter((entry) => entry.createdAt < stagedBefore);
+    const referenced = new Set(await referencedMediaIds(actor.id, aged.map((entry) => entry.mediaId)));
+    return aged.filter((entry) => !referenced.has(entry.mediaId));
+  }
+  /**
+  * The bound staging store's `list`, or a refusal. Absence is never answered with an empty list:
+  * "this host keeps no inventory" and "this actor has no files" are opposite facts that would
+  * otherwise render identically — as a clean file list, and as a sweep that collects nothing.
   */
-  async truncateThreadFrom(actor, threadId, messageId) {
-    await this.assertOwnsThread(actor, threadId);
-    return this.store.truncateFrom(threadId, messageId);
+  attachmentInventory() {
+    const list = this.staging?.list?.bind(this.staging);
+    if (list === void 0) {
+      throw new import_common6.NotImplementedException("Listing attachments requires an AGENT_ATTACHMENT_STAGING provider implementing list(); the host owns the staged bytes, so only it can enumerate them.");
+    }
+    return list;
   }
   /**
   * The day's usage for the badge: tokens + summed USD cost from the store, and the configured
@@ -958,24 +1403,26 @@ var AgentService = class {
   * out from run resolution (see {@link resolveRunForToolCall}) so the console `AgentApprovalPort`
   * adapter can resolve+signal a decision WITHOUT this check — it is authorized upstream instead.
   */
-  async assertOwnsToolCall(actor, toolCallId) {
-    const owner = await this.store.ownerOfToolCall(toolCallId);
+  async assertOwnsToolCall(actor, toolCallId2) {
+    const owner = await this.store.ownerOfToolCall(toolCallId2);
     if (owner === null) {
-      throw new import_common6.NotFoundException(`tool call ${toolCallId} not found`);
+      throw new import_common6.NotFoundException(`tool call ${toolCallId2} not found`);
     }
     if (owner !== actor.id) {
       throw new import_common6.ForbiddenException("tool call belongs to another actor");
     }
   }
   /**
-  * Resolve the run currently awaiting `toolCallId` (its thread's active stream). That run is the
-  * sub-agent's own child run when the pending call belongs to a delegated agent — the client never
-  * knows or supplies a runId; it is derived here from the tool call alone.
+  * Resolve the run awaiting `toolCallId`. Derived server-side from the tool call alone — the client
+  * never knows or supplies a runId, and that run is the sub-agent's own child run when the pending
+  * call belongs to a delegated agent. The store answers from the CALL'S OWN `runId` where it has
+  * one; see `AgentStore.runForToolCall` for why that matters once a thread can hold more than one
+  * live run.
   */
-  async resolveRunForToolCall(toolCallId) {
-    const runId = await this.store.runForToolCall(toolCallId);
+  async resolveRunForToolCall(toolCallId2) {
+    const runId = await this.store.runForToolCall(toolCallId2);
     if (runId === null) {
-      throw new import_common6.NotFoundException(`tool call ${toolCallId} has no active run to signal`);
+      throw new import_common6.NotFoundException(`tool call ${toolCallId2} has no active run to signal`);
     }
     return runId;
   }
@@ -992,16 +1439,19 @@ var AgentService = class {
 };
 AgentService = _ts_decorate6([
   (0, import_common6.Injectable)(),
-  _ts_param4(0, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_RUNNER)),
-  _ts_param4(1, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_STORE)),
-  _ts_param4(2, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_DEPS_FACTORY)),
-  _ts_param4(3, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_QUOTA_STORE)),
+  _ts_param5(0, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_RUNNER)),
+  _ts_param5(1, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_STORE)),
+  _ts_param5(2, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_DEPS_FACTORY)),
+  _ts_param5(3, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_QUOTA_STORE)),
+  _ts_param5(4, (0, import_common6.Optional)()),
+  _ts_param5(4, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_ATTACHMENT_STAGING)),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
     typeof AgentRunner === "undefined" ? Object : AgentRunner,
     typeof AgentStore === "undefined" ? Object : AgentStore,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
-    Object
+    Object,
+    typeof AttachmentStagingStore === "undefined" ? Object : AttachmentStagingStore
   ])
 ], AgentService);
 
@@ -1026,16 +1476,16 @@ var AgentApprovalPortAdapter = class {
   constructor(agent) {
     this.agent = agent;
   }
-  async approve(toolCallId, opts) {
-    await this.agent.signalToolCall(toolCallId, {
+  async approve(toolCallId2, opts) {
+    await this.agent.signalToolCall(toolCallId2, {
       approved: true,
       ...opts?.executedByRef !== void 0 ? {
         executedByRef: opts.executedByRef
       } : {}
     });
   }
-  async reject(toolCallId, opts) {
-    await this.agent.signalToolCall(toolCallId, {
+  async reject(toolCallId2, opts) {
+    await this.agent.signalToolCall(toolCallId2, {
       approved: false,
       ...opts?.executedByRef !== void 0 ? {
         executedByRef: opts.executedByRef
@@ -1055,7 +1505,7 @@ AgentApprovalPortAdapter = _ts_decorate7([
 ], AgentApprovalPortAdapter);
 
 // src/controller/agents.controller.ts
-var import_nestjs_agent_core8 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core9 = require("@dudousxd/nestjs-agent-core");
 var import_common8 = require("@nestjs/common");
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1068,12 +1518,12 @@ function _ts_metadata7(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata7, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param6, "_ts_param");
 var AgentsController = class {
   static {
     __name(this, "AgentsController");
@@ -1103,17 +1553,17 @@ _ts_decorate8([
 ], AgentsController.prototype, "list", null);
 AgentsController = _ts_decorate8([
   (0, import_common8.Controller)("agents"),
-  _ts_param5(0, (0, import_common8.Inject)(import_nestjs_agent_core8.AGENT_REGISTRY)),
-  _ts_param5(1, (0, import_common8.Inject)(import_nestjs_agent_core8.AGENT_DEPS_FACTORY)),
+  _ts_param6(0, (0, import_common8.Inject)(import_nestjs_agent_core9.AGENT_REGISTRY)),
+  _ts_param6(1, (0, import_common8.Inject)(import_nestjs_agent_core9.AGENT_DEPS_FACTORY)),
   _ts_metadata7("design:type", Function),
   _ts_metadata7("design:paramtypes", [
-    typeof import_nestjs_agent_core8.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core8.AgentRegistry,
+    typeof import_nestjs_agent_core9.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core9.AgentRegistry,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
   ])
 ], AgentsController);
 
 // src/controller/attachments.controller.ts
-var import_nestjs_agent_core9 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core10 = require("@dudousxd/nestjs-agent-core");
 var import_common9 = require("@nestjs/common");
 var import_platform_express = require("@nestjs/platform-express");
 function _ts_decorate9(decorators, target, key, desc) {
@@ -1127,13 +1577,15 @@ function _ts_metadata8(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata8, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+function _ts_param7(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param7, "_ts_param");
 var DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+var HARD_MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+var ATTACHMENT_PAGE_SIZE = 50;
 var DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES = [
   "image/png",
   "image/jpeg",
@@ -1149,10 +1601,12 @@ var AttachmentsController = class {
   }
   options;
   actorResolver;
+  agents;
   staging;
-  constructor(options, actorResolver, staging) {
+  constructor(options, actorResolver, agents, staging) {
     this.options = options;
     this.actorResolver = actorResolver;
+    this.agents = agents;
     this.staging = staging;
   }
   /**
@@ -1166,6 +1620,21 @@ var AttachmentsController = class {
       throw new Error("AgentModule: attachments.upload is true but no AGENT_ATTACHMENT_STAGING provider is bound. Bind one (e.g. `{ provide: AGENT_ATTACHMENT_STAGING, useClass: MyStagingStore }`) in a module imported alongside AgentModule, or set attachments.upload to false.");
     }
   }
+  /**
+  * The caller's own staged files, newest first — the one question `GET /agent/threads/:id` cannot
+  * answer, since an upload that was never sent belongs to no thread.
+  *
+  * Scoped by the RESOLVED actor and nothing else. There is deliberately no `threadId` filter: a
+  * thread's attachments already ride on its messages in the thread payload, and re-serving them
+  * from here would add a second ownership path to get wrong for information the client already
+  * holds. Metadata only — see {@link StagedAttachment}.
+  */
+  async list(req) {
+    const actor = await this.actorResolver.resolve(req);
+    return this.agents.listAttachments(actor, {
+      limit: ATTACHMENT_PAGE_SIZE
+    });
+  }
   async upload(req, file) {
     if (this.staging === void 0) {
       throw new import_common9.NotImplementedException("Attachment upload is not configured on this server.");
@@ -1191,11 +1660,24 @@ var AttachmentsController = class {
     });
   }
 };
+_ts_decorate9([
+  (0, import_common9.Get)(),
+  _ts_param7(0, (0, import_common9.Req)()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request
+  ]),
+  _ts_metadata8("design:returntype", Promise)
+], AttachmentsController.prototype, "list", null);
 _ts_decorate9([
   (0, import_common9.Post)(),
-  (0, import_common9.UseInterceptors)((0, import_platform_express.FileInterceptor)("file")),
-  _ts_param6(0, (0, import_common9.Req)()),
-  _ts_param6(1, (0, import_common9.UploadedFile)()),
+  (0, import_common9.UseInterceptors)((0, import_platform_express.FileInterceptor)("file", {
+    limits: {
+      fileSize: HARD_MAX_ATTACHMENT_BYTES
+    }
+  })),
+  _ts_param7(0, (0, import_common9.Req)()),
+  _ts_param7(1, (0, import_common9.UploadedFile)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -1205,20 +1687,21 @@ _ts_decorate9([
 ], AttachmentsController.prototype, "upload", null);
 AttachmentsController = _ts_decorate9([
   (0, import_common9.Controller)("attachments"),
-  _ts_param6(0, (0, import_common9.Inject)(import_nestjs_agent_core9.AGENT_OPTIONS)),
-  _ts_param6(1, (0, import_common9.Inject)(import_nestjs_agent_core9.AGENT_ACTOR_RESOLVER)),
-  _ts_param6(2, (0, import_common9.Optional)()),
-  _ts_param6(2, (0, import_common9.Inject)(import_nestjs_agent_core9.AGENT_ATTACHMENT_STAGING)),
+  _ts_param7(0, (0, import_common9.Inject)(import_nestjs_agent_core10.AGENT_OPTIONS)),
+  _ts_param7(1, (0, import_common9.Inject)(import_nestjs_agent_core10.AGENT_ACTOR_RESOLVER)),
+  _ts_param7(3, (0, import_common9.Optional)()),
+  _ts_param7(3, (0, import_common9.Inject)(import_nestjs_agent_core10.AGENT_ATTACHMENT_STAGING)),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
+    typeof AgentService === "undefined" ? Object : AgentService,
     Object
   ])
 ], AttachmentsController);
 
 // src/controller/chat.controller.ts
-var import_nestjs_agent_core10 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core11 = require("@dudousxd/nestjs-agent-core");
 var import_common10 = require("@nestjs/common");
 function _ts_decorate10(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1231,12 +1714,37 @@ function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata9, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
+__name(_ts_param8, "_ts_param");
+var MAX_ATTACHMENTS_PER_MESSAGE = 10;
+function attachmentRefs(claimed) {
+  if (claimed === void 0) {
+    return [];
+  }
+  if (!Array.isArray(claimed)) {
+    throw new import_common10.BadRequestException("attachments must be an array of { mediaId }");
+  }
+  if (claimed.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+    throw new import_common10.BadRequestException(`a message may carry at most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments`);
+  }
+  return claimed.map((entry) => {
+    if (typeof entry !== "object" || entry === null || !("mediaId" in entry)) {
+      throw new import_common10.BadRequestException("each attachment must be an object with a mediaId");
+    }
+    const { mediaId } = entry;
+    if (typeof mediaId !== "string" || mediaId.length === 0) {
+      throw new import_common10.BadRequestException("each attachment must carry a non-empty string mediaId");
+    }
+    return {
+      mediaId
+    };
+  });
+}
+__name(attachmentRefs, "attachmentRefs");
 var ChatController = class {
   static {
     __name(this, "ChatController");
@@ -1249,6 +1757,7 @@ var ChatController = class {
   }
   async chat(req, res, body) {
     const actor = await this.actorResolver.resolve(req);
+    const attachments = attachmentRefs(body.attachments);
     const { runId, threadId } = await this.agent.chat({
       actor,
       message: body.message,
@@ -1258,8 +1767,8 @@ var ChatController = class {
       ...body.agent !== void 0 ? {
         agentName: body.agent
       } : {},
-      ...body.attachments !== void 0 ? {
-        attachments: body.attachments
+      ...attachments.length > 0 ? {
+        attachments
       } : {},
       ...body.pageContext !== void 0 ? {
         pageContext: body.pageContext
@@ -1271,10 +1780,11 @@ var ChatController = class {
         transient: true
       } : {}
     });
-    await this.pipe(res, runId, threadId);
+    await this.pipe(res, runId, this.agent.subscribe(runId), threadId);
   }
-  async stream(runId, res) {
-    await this.pipe(res, runId);
+  async stream(req, runId, res) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.pipe(res, runId, await this.agent.subscribeAs(actor, runId));
   }
   async cancel(req, runId) {
     const actor = await this.actorResolver.resolve(req);
@@ -1283,7 +1793,7 @@ var ChatController = class {
       aborted: true
     };
   }
-  async pipe(res, runId, threadId) {
+  async pipe(res, runId, events, threadId) {
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
@@ -1301,7 +1811,7 @@ data: ${JSON.stringify({
     const decoder = new TextDecoder();
     let buffer = "";
     try {
-      for await (const chunk of this.agent.subscribe(runId)) {
+      for await (const chunk of events) {
         buffer += decoder.decode(chunk, {
           stream: true
         });
@@ -1324,7 +1834,7 @@ data: ${JSON.stringify({
       }
       res.write("event: done\ndata: {}\n\n");
     } catch (error) {
-      const payload = error instanceof import_nestjs_agent_core10.AgentStreamError ? {
+      const payload = error instanceof import_nestjs_agent_core11.AgentStreamError ? {
         code: error.code,
         message: error.message
       } : {
@@ -1341,9 +1851,9 @@ data: ${JSON.stringify(payload)}
 };
 _ts_decorate10([
   (0, import_common10.Post)("chat"),
-  _ts_param7(0, (0, import_common10.Req)()),
-  _ts_param7(1, (0, import_common10.Res)()),
-  _ts_param7(2, (0, import_common10.Body)()),
+  _ts_param8(0, (0, import_common10.Req)()),
+  _ts_param8(1, (0, import_common10.Res)()),
+  _ts_param8(2, (0, import_common10.Body)()),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -1354,10 +1864,12 @@ _ts_decorate10([
 ], ChatController.prototype, "chat", null);
 _ts_decorate10([
   (0, import_common10.Get)("chat/:runId/stream"),
-  _ts_param7(0, (0, import_common10.Param)("runId")),
-  _ts_param7(1, (0, import_common10.Res)()),
+  _ts_param8(0, (0, import_common10.Req)()),
+  _ts_param8(1, (0, import_common10.Param)("runId")),
+  _ts_param8(2, (0, import_common10.Res)()),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
     String,
     typeof Response === "undefined" ? Object : Response
   ]),
@@ -1365,8 +1877,8 @@ _ts_decorate10([
 ], ChatController.prototype, "stream", null);
 _ts_decorate10([
   (0, import_common10.Post)("chat/:runId/cancel"),
-  _ts_param7(0, (0, import_common10.Req)()),
-  _ts_param7(1, (0, import_common10.Param)("runId")),
+  _ts_param8(0, (0, import_common10.Req)()),
+  _ts_param8(1, (0, import_common10.Param)("runId")),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -1376,7 +1888,7 @@ _ts_decorate10([
 ], ChatController.prototype, "cancel", null);
 ChatController = _ts_decorate10([
   (0, import_common10.Controller)(),
-  _ts_param7(1, (0, import_common10.Inject)(import_nestjs_agent_core10.AGENT_ACTOR_RESOLVER)),
+  _ts_param8(1, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_ACTOR_RESOLVER)),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -1384,8 +1896,8 @@ ChatController = _ts_decorate10([
   ])
 ], ChatController);
 
-// src/controller/quota.controller.ts
-var import_nestjs_agent_core11 = require("@dudousxd/nestjs-agent-core");
+// src/controller/memories.controller.ts
+var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
 var import_common11 = require("@nestjs/common");
 function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1398,12 +1910,138 @@ function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata10, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
+__name(_ts_param9, "_ts_param");
+var MemoriesController = class {
+  static {
+    __name(this, "MemoriesController");
+  }
+  actorResolver;
+  memory;
+  constructor(actorResolver, memory) {
+    this.actorResolver = actorResolver;
+    this.memory = memory;
+  }
+  /**
+  * Every memory this actor can reach, most specific first, each carrying its origin and whatever
+  * wider value it outranks.
+  *
+  * DELIBERATELY IGNORES `maxMemories`. That ceiling is a budget on what one TURN carries; applying
+  * it here would mean a person could not see — and so could not delete — a belief the assistant is
+  * one write away from acting on again. Showing someone more than the model sees is harmless;
+  * showing them less is the failure this endpoint exists to prevent.
+  */
+  async list(req, threadId) {
+    if (this.memory === void 0) {
+      return [];
+    }
+    const actor = await this.actorResolver.resolve(req);
+    return (await this.unbounded(threadId ?? "", actor)).entries;
+  }
+  /**
+  * Forget one. Authorized against the actor's OWN resolved list, the same way a `skill` load is
+  * authorized against the turn's catalog: an id this actor cannot see is answered as missing rather
+  * than refused, so the endpoint cannot be used to find out which memories exist about other people.
+  */
+  async forget(req, id) {
+    if (this.memory === void 0) {
+      throw new import_common11.NotFoundException("No memory is configured in this deployment.");
+    }
+    const actor = await this.actorResolver.resolve(req);
+    const digest = await this.unbounded("", actor);
+    const entry = digest.entries.find((candidate) => candidate.id === id);
+    if (entry === void 0) {
+      throw new import_common11.NotFoundException(`No memory with id "${id}".`);
+    }
+    const verdict = (0, import_nestjs_agent_core12.memoryForgetVerdict)({
+      record: entry,
+      actor
+    });
+    if (!verdict.allowed) {
+      throw new import_common11.ForbiddenException(verdict.reason);
+    }
+    return {
+      forgotten: await this.memory.provider.forget({
+        id: entry.id,
+        ctx: {
+          actor,
+          threadId: ""
+        }
+      })
+    };
+  }
+  async unbounded(threadId, actor) {
+    const config = this.memory;
+    return await (0, import_nestjs_agent_core12.offerMemories)({
+      config: {
+        ...config,
+        maxMemories: Number.POSITIVE_INFINITY
+      },
+      ctx: {
+        actor,
+        threadId
+      }
+    });
+  }
+};
+_ts_decorate11([
+  (0, import_common11.Get)(),
+  _ts_param9(0, (0, import_common11.Req)()),
+  _ts_param9(1, (0, import_common11.Query)("threadId")),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata10("design:returntype", Promise)
+], MemoriesController.prototype, "list", null);
+_ts_decorate11([
+  (0, import_common11.Delete)(":id"),
+  _ts_param9(0, (0, import_common11.Req)()),
+  _ts_param9(1, (0, import_common11.Param)("id")),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata10("design:returntype", Promise)
+], MemoriesController.prototype, "forget", null);
+MemoriesController = _ts_decorate11([
+  (0, import_common11.Controller)("memories"),
+  _ts_param9(0, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_ACTOR_RESOLVER)),
+  _ts_param9(1, (0, import_common11.Optional)()),
+  _ts_param9(1, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_MEMORY)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof ActorResolver === "undefined" ? Object : ActorResolver,
+    Object
+  ])
+], MemoriesController);
+
+// src/controller/quota.controller.ts
+var import_nestjs_agent_core13 = require("@dudousxd/nestjs-agent-core");
+var import_common12 = require("@nestjs/common");
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param10, "_ts_param");
 var QuotaController = class {
   static {
     __name(this, "QuotaController");
@@ -1419,45 +2057,110 @@ var QuotaController = class {
     return this.agent.quotaToday(actor.id);
   }
 };
-_ts_decorate11([
-  (0, import_common11.Get)("today"),
-  _ts_param8(0, (0, import_common11.Req)()),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+_ts_decorate12([
+  (0, import_common12.Get)("today"),
+  _ts_param10(0, (0, import_common12.Req)()),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata10("design:returntype", Promise)
+  _ts_metadata11("design:returntype", Promise)
 ], QuotaController.prototype, "today", null);
-QuotaController = _ts_decorate11([
-  (0, import_common11.Controller)("quota"),
-  _ts_param8(1, (0, import_common11.Inject)(import_nestjs_agent_core11.AGENT_ACTOR_RESOLVER)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+QuotaController = _ts_decorate12([
+  (0, import_common12.Controller)("quota"),
+  _ts_param10(1, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], QuotaController);
 
+// src/controller/skills.controller.ts
+var import_nestjs_agent_core14 = require("@dudousxd/nestjs-agent-core");
+var import_common13 = require("@nestjs/common");
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var SkillsController = class {
+  static {
+    __name(this, "SkillsController");
+  }
+  actorResolver;
+  skills;
+  constructor(actorResolver, skills) {
+    this.actorResolver = actorResolver;
+    this.skills = skills;
+  }
+  async list(req, threadId) {
+    if (this.skills === void 0) {
+      return [];
+    }
+    const actor = await this.actorResolver.resolve(req);
+    const offer = await (0, import_nestjs_agent_core14.offerSkills)(this.skills, {
+      actor,
+      threadId: threadId ?? ""
+    });
+    return offer.entries;
+  }
+};
+_ts_decorate13([
+  (0, import_common13.Get)(),
+  _ts_param11(0, (0, import_common13.Req)()),
+  _ts_param11(1, (0, import_common13.Query)("threadId")),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata12("design:returntype", Promise)
+], SkillsController.prototype, "list", null);
+SkillsController = _ts_decorate13([
+  (0, import_common13.Controller)("skills"),
+  _ts_param11(0, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_ACTOR_RESOLVER)),
+  _ts_param11(1, (0, import_common13.Optional)()),
+  _ts_param11(1, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_SKILLS)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof ActorResolver === "undefined" ? Object : ActorResolver,
+    Object
+  ])
+], SkillsController);
+
 // src/controller/threads.controller.ts
-var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
-var import_common12 = require("@nestjs/common");
-function _ts_decorate12(decorators, target, key, desc) {
+var import_nestjs_agent_core15 = require("@dudousxd/nestjs-agent-core");
+var import_common14 = require("@nestjs/common");
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
-function _ts_metadata11(k, v) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata13(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
-function _ts_param9(paramIndex, decorator) {
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param9, "_ts_param");
+__name(_ts_param12, "_ts_param");
 var ThreadsController = class {
   static {
     __name(this, "ThreadsController");
@@ -1521,117 +2224,173 @@ var ThreadsController = class {
     };
   }
 };
-_ts_decorate12([
-  (0, import_common12.Get)(),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Get)(),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "list", null);
-_ts_decorate12([
-  (0, import_common12.Get)(":id"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Get)(":id"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "detail", null);
-_ts_decorate12([
-  (0, import_common12.Delete)(":id"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Delete)(":id"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "remove", null);
-_ts_decorate12([
-  (0, import_common12.Post)(":id/fork-from/:messageId"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_param9(2, (0, import_common12.Param)("messageId")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Post)(":id/fork-from/:messageId"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_param12(2, (0, import_common14.Param)("messageId")),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "fork", null);
-_ts_decorate12([
-  (0, import_common12.Patch)(":id"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_param9(2, (0, import_common12.Body)()),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Patch)(":id"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_param12(2, (0, import_common14.Body)()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     typeof UpdateThreadBody === "undefined" ? Object : UpdateThreadBody
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "update", null);
-_ts_decorate12([
-  (0, import_common12.Post)(":id/promote"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Post)(":id/promote"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "promote", null);
-_ts_decorate12([
-  (0, import_common12.Delete)(":id/from/:messageId"),
-  _ts_param9(0, (0, import_common12.Req)()),
-  _ts_param9(1, (0, import_common12.Param)("id")),
-  _ts_param9(2, (0, import_common12.Param)("messageId")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+_ts_decorate14([
+  (0, import_common14.Delete)(":id/from/:messageId"),
+  _ts_param12(0, (0, import_common14.Req)()),
+  _ts_param12(1, (0, import_common14.Param)("id")),
+  _ts_param12(2, (0, import_common14.Param)("messageId")),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], ThreadsController.prototype, "truncateFrom", null);
-ThreadsController = _ts_decorate12([
-  (0, import_common12.Controller)("threads"),
-  _ts_param9(1, (0, import_common12.Inject)(import_nestjs_agent_core12.AGENT_ACTOR_RESOLVER)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+ThreadsController = _ts_decorate14([
+  (0, import_common14.Controller)("threads"),
+  _ts_param12(1, (0, import_common14.Inject)(import_nestjs_agent_core15.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], ThreadsController);
 
 // src/controller/tool-call.controller.ts
-var import_nestjs_agent_core13 = require("@dudousxd/nestjs-agent-core");
-var import_common13 = require("@nestjs/common");
-function _ts_decorate13(decorators, target, key, desc) {
+var import_nestjs_agent_core16 = require("@dudousxd/nestjs-agent-core");
+var import_common15 = require("@nestjs/common");
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
-function _ts_metadata12(k, v) {
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata14(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata12, "_ts_metadata");
-function _ts_param10(paramIndex, decorator) {
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param10, "_ts_param");
+__name(_ts_param13, "_ts_param");
+var MAX_ANSWERED_QUESTIONS = 100;
+var MAX_VALUES_PER_QUESTION = 100;
+var MAX_ANSWER_VALUE_LENGTH = 4096;
+var MAX_REJECT_REASON_LENGTH = 4096;
+function toolCallId(claimed) {
+  if (typeof claimed !== "string" || claimed.length === 0) {
+    throw new import_common15.BadRequestException("toolCallId must be a non-empty string");
+  }
+  return claimed;
+}
+__name(toolCallId, "toolCallId");
+function rejectReason(claimed) {
+  if (claimed === void 0) {
+    return void 0;
+  }
+  if (typeof claimed !== "string") {
+    throw new import_common15.BadRequestException("reason must be a string");
+  }
+  if (claimed.length > MAX_REJECT_REASON_LENGTH) {
+    throw new import_common15.BadRequestException(`reason must be at most ${MAX_REJECT_REASON_LENGTH} characters`);
+  }
+  return claimed;
+}
+__name(rejectReason, "rejectReason");
+function answers(claimed) {
+  if (claimed === void 0) {
+    return void 0;
+  }
+  if (typeof claimed !== "object" || claimed === null || Array.isArray(claimed)) {
+    throw new import_common15.BadRequestException("answers must be an object of questionId \u2192 chosen values");
+  }
+  const entries = Object.entries(claimed);
+  if (entries.length > MAX_ANSWERED_QUESTIONS) {
+    throw new import_common15.BadRequestException(`answers may cover at most ${MAX_ANSWERED_QUESTIONS} questions`);
+  }
+  const validated = /* @__PURE__ */ Object.create(null);
+  for (const [questionId, values] of entries) {
+    if (!Array.isArray(values)) {
+      throw new import_common15.BadRequestException(`answers["${questionId}"] must be an array of chosen values`);
+    }
+    if (values.length > MAX_VALUES_PER_QUESTION) {
+      throw new import_common15.BadRequestException(`answers["${questionId}"] may carry at most ${MAX_VALUES_PER_QUESTION} values`);
+    }
+    for (const value of values) {
+      if (typeof value !== "string") {
+        throw new import_common15.BadRequestException(`answers["${questionId}"] must contain only strings`);
+      }
+      if (value.length > MAX_ANSWER_VALUE_LENGTH) {
+        throw new import_common15.BadRequestException(`answers["${questionId}"] values must be at most ${MAX_ANSWER_VALUE_LENGTH} characters`);
+      }
+    }
+    validated[questionId] = values;
+  }
+  return validated;
+}
+__name(answers, "answers");
 var ToolCallController = class {
   static {
     __name(this, "ToolCallController");
@@ -1644,54 +2403,96 @@ var ToolCallController = class {
   }
   async approve(req, body) {
     const actor = await this.actorResolver.resolve(req);
-    await this.agent.approve(actor, body.toolCallId);
+    await this.agent.approve(actor, toolCallId(body.toolCallId));
     return {
       ok: true
     };
   }
   async reject(req, body) {
     const actor = await this.actorResolver.resolve(req);
-    await this.agent.reject(actor, body.toolCallId, body.reason);
+    await this.agent.reject(actor, toolCallId(body.toolCallId), rejectReason(body.reason));
+    return {
+      ok: true
+    };
+  }
+  /**
+  * Settle a parked question set. Alongside `approve`/`reject` rather than under a surface of its
+  * own: an elicitation IS a parked tool call, gated by the same ownership check and delivered
+  * through the same signal.
+  */
+  async answer(req, body) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.answer(actor, toolCallId(body.toolCallId), answers(body.answers));
+    return {
+      ok: true
+    };
+  }
+  /** Decline to answer and let the agent proceed on the answers it pre-picked. */
+  async skip(req, body) {
+    const actor = await this.actorResolver.resolve(req);
+    await this.agent.skip(actor, toolCallId(body.toolCallId));
     return {
       ok: true
     };
   }
 };
-_ts_decorate13([
-  (0, import_common13.Post)("approve"),
-  _ts_param10(0, (0, import_common13.Req)()),
-  _ts_param10(1, (0, import_common13.Body)()),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+_ts_decorate15([
+  (0, import_common15.Post)("approve"),
+  _ts_param13(0, (0, import_common15.Req)()),
+  _ts_param13(1, (0, import_common15.Body)()),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof ApproveBody === "undefined" ? Object : ApproveBody
   ]),
-  _ts_metadata12("design:returntype", Promise)
+  _ts_metadata14("design:returntype", Promise)
 ], ToolCallController.prototype, "approve", null);
-_ts_decorate13([
-  (0, import_common13.Post)("reject"),
-  _ts_param10(0, (0, import_common13.Req)()),
-  _ts_param10(1, (0, import_common13.Body)()),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+_ts_decorate15([
+  (0, import_common15.Post)("reject"),
+  _ts_param13(0, (0, import_common15.Req)()),
+  _ts_param13(1, (0, import_common15.Body)()),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof RejectBody === "undefined" ? Object : RejectBody
   ]),
-  _ts_metadata12("design:returntype", Promise)
+  _ts_metadata14("design:returntype", Promise)
 ], ToolCallController.prototype, "reject", null);
-ToolCallController = _ts_decorate13([
-  (0, import_common13.Controller)("tool-call"),
-  _ts_param10(1, (0, import_common13.Inject)(import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER)),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+_ts_decorate15([
+  (0, import_common15.Post)("answer"),
+  _ts_param13(0, (0, import_common15.Req)()),
+  _ts_param13(1, (0, import_common15.Body)()),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof AnswerBody === "undefined" ? Object : AnswerBody
+  ]),
+  _ts_metadata14("design:returntype", Promise)
+], ToolCallController.prototype, "answer", null);
+_ts_decorate15([
+  (0, import_common15.Post)("skip"),
+  _ts_param13(0, (0, import_common15.Req)()),
+  _ts_param13(1, (0, import_common15.Body)()),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    typeof ApproveBody === "undefined" ? Object : ApproveBody
+  ]),
+  _ts_metadata14("design:returntype", Promise)
+], ToolCallController.prototype, "skip", null);
+ToolCallController = _ts_decorate15([
+  (0, import_common15.Controller)("tool-call"),
+  _ts_param13(1, (0, import_common15.Inject)(import_nestjs_agent_core16.AGENT_ACTOR_RESOLVER)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], ToolCallController);
 
 // src/discovery/agent-discovery.service.ts
-var import_nestjs_agent_core14 = require("@dudousxd/nestjs-agent-core");
-var import_common14 = require("@nestjs/common");
+var import_nestjs_agent_core17 = require("@dudousxd/nestjs-agent-core");
+var import_common16 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/decorator/agent.decorator.ts
@@ -1708,23 +2509,23 @@ var SYSTEM_PROMPT_METADATA = Symbol.for("@dudousxd/nestjs-agent:system-prompt");
 var SYSTEM_PROMPT_CONTRIBUTOR_METADATA = Symbol.for("@dudousxd/nestjs-agent:system-prompt-contributor");
 
 // src/discovery/agent-discovery.service.ts
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
-function _ts_metadata13(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata15(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata13, "_ts_metadata");
-function _ts_param11(paramIndex, decorator) {
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param14(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param11, "_ts_param");
+__name(_ts_param14, "_ts_param");
 var AgentDiscoveryService = class _AgentDiscoveryService {
   static {
     __name(this, "AgentDiscoveryService");
@@ -1733,7 +2534,7 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   scanner;
   registry;
   contributors;
-  logger = new import_common14.Logger(_AgentDiscoveryService.name);
+  logger = new import_common16.Logger(_AgentDiscoveryService.name);
   constructor(discovery, scanner, registry, contributors) {
     this.discovery = discovery;
     this.scanner = scanner;
@@ -1772,23 +2573,53 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
       ...meta.maxSteps !== void 0 ? {
         maxSteps: meta.maxSteps
       } : {},
+      ...meta.maxDelegationDepth !== void 0 ? {
+        maxDelegationDepth: meta.maxDelegationDepth
+      } : {},
+      ...meta.maxAgentAppearances !== void 0 ? {
+        maxAgentAppearances: meta.maxAgentAppearances
+      } : {},
+      ...meta.history !== void 0 ? {
+        history: meta.history
+      } : {},
+      ...meta.outputSchema !== void 0 ? {
+        outputSchema: meta.outputSchema
+      } : {},
+      ...meta.intake !== void 0 ? {
+        intake: meta.intake
+      } : {},
+      ...meta.ask !== void 0 ? {
+        ask: meta.ask
+      } : {},
+      ...meta.outputRepairAttempts !== void 0 ? {
+        outputRepairAttempts: meta.outputRepairAttempts
+      } : {},
       ...meta.handoff !== void 0 ? {
-        delegatesTo: this.handoffNames(meta)
+        delegatesTo: this.handoffEdges(meta)
       } : {}
     };
   }
-  /** Resolve each handoff `@Agent` class to its registered name (skipping non-agent classes). */
-  handoffNames(meta) {
-    const names = [];
-    for (const target of meta.handoff ?? []) {
+  /**
+  * Resolve each handoff entry to an {@link AgentDelegation} — its target's registered name, plus
+  * whether that edge detaches (skipping non-agent classes). A bare name is kept for a plain edge
+  * rather than an always-object form, so a definition an older host built by hand still reads.
+  */
+  handoffEdges(meta) {
+    const edges = [];
+    for (const entry of meta.handoff ?? []) {
+      const target = typeof entry === "function" ? entry : entry.agent;
+      const detached = typeof entry === "function" ? false : entry.detached === true;
       const targetMeta = readAgentMetadata(target);
       if (targetMeta === void 0) {
         this.logger.warn(`Agent "${meta.name}" hands off to ${target.name}, which is not an @Agent \u2014 skipped.`);
         continue;
       }
-      names.push(targetMeta.name);
+      edges.push(detached ? {
+        agent: targetMeta.name,
+        detached: true
+      } : targetMeta.name);
     }
-    return names;
+    return edges;
   }
   /** Push every `@SystemPromptContributor()` method on `instance` (bound) into the contributor list. */
   collectContributors(instance) {
@@ -1821,22 +2652,22 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
     return (ctx) => candidate.call(instance, ctx);
   }
 };
-AgentDiscoveryService = _ts_decorate14([
-  (0, import_common14.Injectable)(),
-  _ts_param11(2, (0, import_common14.Inject)(import_nestjs_agent_core14.AGENT_REGISTRY)),
-  _ts_param11(3, (0, import_common14.Inject)(import_nestjs_agent_core14.AGENT_PROMPT_CONTRIBUTORS)),
-  _ts_metadata13("design:type", Function),
-  _ts_metadata13("design:paramtypes", [
+AgentDiscoveryService = _ts_decorate16([
+  (0, import_common16.Injectable)(),
+  _ts_param14(2, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_REGISTRY)),
+  _ts_param14(3, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_PROMPT_CONTRIBUTORS)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
     typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
-    typeof import_nestjs_agent_core14.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core14.AgentRegistry,
+    typeof import_nestjs_agent_core17.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core17.AgentRegistry,
     Array
   ])
 ], AgentDiscoveryService);
 
 // src/discovery/ai-tool-discovery.service.ts
-var import_nestjs_agent_core15 = require("@dudousxd/nestjs-agent-core");
-var import_common15 = require("@nestjs/common");
+var import_nestjs_agent_core18 = require("@dudousxd/nestjs-agent-core");
+var import_common17 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
 var import_zod = require("zod");
 
@@ -1856,23 +2687,23 @@ function isBrandedFunctionalTool(value) {
 __name(isBrandedFunctionalTool, "isBrandedFunctionalTool");
 
 // src/discovery/ai-tool-discovery.service.ts
-function _ts_decorate15(decorators, target, key, desc) {
+function _ts_decorate17(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate15, "_ts_decorate");
-function _ts_metadata14(k, v) {
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata16(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata14, "_ts_metadata");
-function _ts_param12(paramIndex, decorator) {
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param12, "_ts_param");
+__name(_ts_param15, "_ts_param");
 var AiToolDiscoveryService = class _AiToolDiscoveryService {
   static {
     __name(this, "AiToolDiscoveryService");
@@ -1881,7 +2712,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   registry;
   agents;
   options;
-  logger = new import_common15.Logger(_AiToolDiscoveryService.name);
+  logger = new import_common17.Logger(_AiToolDiscoveryService.name);
   constructor(discovery, registry, agents, options) {
     this.discovery = discovery;
     this.registry = registry;
@@ -1948,22 +2779,30 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
     }
     let delegates = 0;
     for (const definition of this.agents.list()) {
-      for (const target of definition.delegatesTo ?? []) {
+      for (const edge of definition.delegatesTo ?? []) {
+        const { agent: target, detached } = (0, import_nestjs_agent_core18.normalizeDelegation)(edge);
         const targetDefinition = this.agents.get(target);
         if (targetDefinition === void 0) {
           throw new Error(`Agent "${definition.name}" hands off to "${target}", which is not a registered @Agent. Declare it as an @Agent provider or fix the reference.`);
         }
-        const name = delegateToolName(target);
+        const name = delegateToolName({
+          target,
+          detached
+        });
         if (this.registry.has(name)) {
           continue;
         }
         const targetBlurb = typeof targetDefinition.systemPrompt === "string" ? ` It is: ${targetDefinition.systemPrompt}` : "";
+        const description = detached ? `Start the "${target}" agent working on a task in the BACKGROUND. Returns immediately with a receipt, NOT an answer \u2014 the answer is delivered to this conversation as a separate message later. Use it for work the user does not need to sit and wait for.${targetBlurb}` : `Delegate a task to the "${target}" agent and get its answer.${targetBlurb}`;
         this.registry.register(
           {
             name,
             kind: "agent",
             targetAgent: target,
-            description: `Delegate a task to the "${target}" agent and get its answer.${targetBlurb}`,
+            ...detached ? {
+              detached: true
+            } : {},
+            description,
             inputSchema: import_zod.z.object({
               task: import_zod.z.string()
             })
@@ -1991,13 +2830,13 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
     return true;
   }
 };
-AiToolDiscoveryService = _ts_decorate15([
-  (0, import_common15.Injectable)(),
-  _ts_param12(1, (0, import_common15.Inject)(import_nestjs_agent_core15.AGENT_TOOL_REGISTRY)),
-  _ts_param12(2, (0, import_common15.Inject)(import_nestjs_agent_core15.AGENT_REGISTRY)),
-  _ts_param12(3, (0, import_common15.Inject)(import_nestjs_agent_core15.AGENT_OPTIONS)),
-  _ts_metadata14("design:type", Function),
-  _ts_metadata14("design:paramtypes", [
+AiToolDiscoveryService = _ts_decorate17([
+  (0, import_common17.Injectable)(),
+  _ts_param15(1, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_TOOL_REGISTRY)),
+  _ts_param15(2, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_REGISTRY)),
+  _ts_param15(3, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_OPTIONS)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
     typeof import_core2.DiscoveryService === "undefined" ? Object : import_core2.DiscoveryService,
     typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
     typeof AgentRegistry === "undefined" ? Object : AgentRegistry,
@@ -2005,6 +2844,95 @@ AiToolDiscoveryService = _ts_decorate15([
   ])
 ], AiToolDiscoveryService);
 
+// src/discovery/skill-discovery.service.ts
+var import_nestjs_agent_core20 = require("@dudousxd/nestjs-agent-core");
+var import_common18 = require("@nestjs/common");
+var import_core3 = require("@nestjs/core");
+
+// src/decorator/skill.decorator.ts
+var import_reflect_metadata4 = require("reflect-metadata");
+var import_nestjs_agent_core19 = require("@dudousxd/nestjs-agent-core");
+var SKILL_METADATA = Symbol.for("@dudousxd/nestjs-agent:skill-metadata");
+function readSkillMetadata(target) {
+  return Reflect.getMetadata(SKILL_METADATA, target);
+}
+__name(readSkillMetadata, "readSkillMetadata");
+function skillScope(options) {
+  return options.scope ?? import_nestjs_agent_core19.GLOBAL_SCOPE;
+}
+__name(skillScope, "skillScope");
+
+// src/discovery/skill-discovery.service.ts
+function _ts_decorate18(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param16(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param16, "_ts_param");
+var SkillDiscoveryService = class _SkillDiscoveryService {
+  static {
+    __name(this, "SkillDiscoveryService");
+  }
+  discovery;
+  declared;
+  logger = new import_common18.Logger(_SkillDiscoveryService.name);
+  constructor(discovery, declared) {
+    this.discovery = discovery;
+    this.declared = declared;
+  }
+  onModuleInit() {
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance = wrapper.instance;
+      if (instance === null || typeof instance !== "object") {
+        continue;
+      }
+      const meta = readSkillMetadata(instance.constructor);
+      if (meta === void 0) {
+        continue;
+      }
+      const body = this.bodyOf(instance, meta.body);
+      if (body === void 0) {
+        this.logger.warn(`Skill "${meta.name}" declares no body \u2014 add a \`body()\` method or \`@Skill({ body })\`. Skipped.`);
+        continue;
+      }
+      this.declared.push({
+        name: meta.name,
+        description: meta.description,
+        scope: skillScope(meta),
+        body
+      });
+    }
+  }
+  /** The instance's `body()` method (bound), else the flat string, else nothing to offer. */
+  bodyOf(instance, flat) {
+    const candidate = instance.body;
+    if (typeof candidate === "function") {
+      return (ctx) => candidate.call(instance, ctx);
+    }
+    return flat === void 0 ? void 0 : () => flat;
+  }
+};
+SkillDiscoveryService = _ts_decorate18([
+  (0, import_common18.Injectable)(),
+  _ts_param16(1, (0, import_common18.Inject)(import_nestjs_agent_core20.AGENT_SKILL_SOURCES)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof import_core3.DiscoveryService === "undefined" ? Object : import_core3.DiscoveryService,
+    Array
+  ])
+], SkillDiscoveryService);
+
 // src/ledger-quota-store.ts
 var LedgerQuotaStore = class {
   static {
@@ -2024,38 +2952,44 @@ var LedgerQuotaStore = class {
       withinLimit: usedTokens < this.limitTokens
     };
   }
-  async bump() {
+  async bump(_actorRef, _day, _tokens) {
   }
 };
 
 // src/runner/inline-agent-runner.ts
-var import_nestjs_agent_core16 = require("@dudousxd/nestjs-agent-core");
-var import_common16 = require("@nestjs/common");
-function _ts_decorate16(decorators, target, key, desc) {
+var import_nestjs_agent_core21 = require("@dudousxd/nestjs-agent-core");
+var import_common19 = require("@nestjs/common");
+function _ts_decorate19(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate16, "_ts_decorate");
-function _ts_metadata15(k, v) {
+__name(_ts_decorate19, "_ts_decorate");
+function _ts_metadata18(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata15, "_ts_metadata");
-function _ts_param13(paramIndex, decorator) {
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param13, "_ts_param");
+__name(_ts_param17, "_ts_param");
 var InlineAgentRunner = class _InlineAgentRunner {
   static {
     __name(this, "InlineAgentRunner");
   }
   factory;
   store;
-  logger = new import_common16.Logger(_InlineAgentRunner.name);
+  logger = new import_common19.Logger(_InlineAgentRunner.name);
   pending = /* @__PURE__ */ new Map();
+  /**
+  * Runs someone has asked to stop. In-process, like `pending`, and for the same reason: this runner
+  * is single-replica by construction, so the request is readable by the only loop that could be
+  * running it. A cancelled id is dropped once the run settles, so the set tracks live runs only.
+  */
+  cancelled = /* @__PURE__ */ new Set();
   constructor(factory, store) {
     this.factory = factory;
     this.store = store;
@@ -2064,15 +2998,31 @@ var InlineAgentRunner = class _InlineAgentRunner {
     const runId = crypto.randomUUID();
     const day = input.day ?? utcDay();
     const deps = this.factory.forAgent(input.agentName);
-    const hooks = this.topLevelHooks(runId, deps, input.actor, day);
-    void (0, import_nestjs_agent_core16.runAgentLoop)({
+    const hooks = this.topLevelHooks({
+      runId,
+      deps,
+      actor: input.actor,
+      day,
+      threadId: input.threadId,
+      chainBelow: [
+        ...input.delegationPath ?? [],
+        ...input.agentName !== void 0 ? [
+          input.agentName
+        ] : []
+      ]
+    });
+    void (0, import_nestjs_agent_core21.runAgentLoop)({
       ...deps,
       day
     }, input, hooks).then(() => this.store.setActiveStream(input.threadId, null)).catch(async (error) => {
+      if (error instanceof import_nestjs_agent_core21.RunCancelledError) {
+        await this.settleCancelled(runId, input.threadId, deps);
+        return;
+      }
       const message = error instanceof Error ? error.message : String(error);
-      const code = error instanceof import_nestjs_agent_core16.QuotaExceededError ? "quota_exceeded" : "run_failed";
+      const code = (0, import_nestjs_agent_core21.agentFailureCode)(error);
       this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
-      (0, import_nestjs_agent_core16.publishAgentRunFailed)({
+      (0, import_nestjs_agent_core21.publishAgentRunFailed)({
         runId,
         code,
         message
@@ -2089,33 +3039,216 @@ var InlineAgentRunner = class _InlineAgentRunner {
         code,
         message
       });
-    });
+    }).finally(() => this.cancelled.delete(runId));
     return {
       runId
     };
   }
-  async signal(runId, toolCallId, decision) {
-    const key = `${runId}:${toolCallId}`;
-    const resolve = this.pending.get(key);
-    if (resolve !== void 0) {
+  async signal(runId, toolCallId2, reply) {
+    const key = `${runId}:${toolCallId2}`;
+    const waiter = this.pending.get(key);
+    if (waiter !== void 0) {
       this.pending.delete(key);
-      resolve(decision);
+      waiter.resolve(reply);
     }
   }
+  /**
+  * Ask a run to stop, and settle whatever it was parked on.
+  *
+  * The loop observes the request at its next safe point (between steps, before the turn's tools) and
+  * unwinds from there — so a tool already executing is left to finish, and its result is recorded
+  * exactly as it would have been. What this cannot wait for is a turn parked on a human: that wait
+  * is a promise nobody is going to resolve, so it is REJECTED here with the same
+  * {@link RunCancelledError} the loop would have thrown, and the run unwinds through the identical
+  * path.
+  *
+  * Settlement — the run row, the thread's active stream, the stream's terminal — belongs to the
+  * `RunCancelledError` catch in `start`, so a cancel and an ordinary failure settle in one place
+  * each and can never both write.
+  */
   async cancel(runId) {
-    const deps = this.factory.forAgent();
+    this.cancelled.add(runId);
+    for (const [key, waiter] of this.pending) {
+      if (key.startsWith(`${runId}:`)) {
+        this.pending.delete(key);
+        waiter.reject(new import_nestjs_agent_core21.RunCancelledError());
+      }
+    }
+    await Promise.resolve();
+  }
+  /**
+  * The single place a cancelled run's state is settled: recorded as its own terminal (never
+  * `failed` — a user pressing Stop must not land in someone's error rate), the thread released, and
+  * the stream ENDED after a `cancelled` frame rather than failed, so a client that retries failed
+  * streams does not retry this one.
+  */
+  async settleCancelled(runId, threadId, deps) {
+    this.logger.log(`agent run ${runId} cancelled`);
+    await this.store.setActiveStream(threadId, null);
     const writer = await deps.sink.open(runId);
+    await writer.write((0, import_nestjs_agent_core21.encodeStreamEvent)({
+      kind: "cancelled"
+    }));
     await writer.end();
+    await this.store.recordRunEnd?.({
+      runId,
+      status: "cancelled"
+    });
+  }
+  /**
+  * Park a run on a human, keyed by run + tool call. One map for approvals and for question-set
+  * answers alike: both wait on the same key, and `signal` cannot tell (or need to tell) which
+  * shape it is delivering — the loop asked for one and only ever gets what the caller sent. A
+  * cancel settles the wait too, by rejecting it.
+  */
+  park(runId, toolCallId2) {
+    return new Promise((resolve, reject) => {
+      this.pending.set(`${runId}:${toolCallId2}`, {
+        resolve,
+        reject
+      });
+    });
   }
-  topLevelHooks(runId, deps, actor, day) {
+  topLevelHooks(args) {
+    const { runId, deps, actor, day, threadId, chainBelow } = args;
     return {
       runId,
       openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => new Promise((resolve) => {
-        this.pending.set(`${runId}:${call.id}`, resolve);
-      }), "awaitApproval"),
+      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
+      step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
+      parallel: import_nestjs_agent_core21.settleAll,
+      cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
+      runAgent: /* @__PURE__ */ __name((agentName, task) => this.runNested({
+        agentName,
+        task,
+        actor,
+        day,
+        depth: 1,
+        path: chainBelow,
+        sinkRunId: runId,
+        parentRunId: runId
+      }), "runAgent"),
+      startAgent: /* @__PURE__ */ __name(({ agentName, task, toolCallId: toolCallId2 }) => this.startDetached({
+        agentName,
+        task,
+        actor,
+        day,
+        depth: 1,
+        path: chainBelow,
+        parentRunId: runId,
+        deliverTo: {
+          threadId,
+          toolCallId: toolCallId2
+        }
+      }), "startAgent")
+    };
+  }
+  /**
+  * Delegate WITHOUT waiting: a nested loop nobody awaits, on its own thread and its own sink, which
+  * posts its answer back into the delegating thread when it lands (`deliverTo`, settled by the
+  * loop). The calling turn gets the run id straight back and finishes.
+  *
+  * No `sinkRunId`, unlike {@link runNested}: forwarding into the stream the human is watching would
+  * write into a turn that has already ended. Its own approvals resolve through the shared pending
+  * map keyed by its own runId — which is what the pending-approvals surface routes to.
+  */
+  async startDetached(args) {
+    const { agentName, task, actor, day, depth, path, parentRunId, deliverTo } = args;
+    const subThread = await this.store.createThread({
+      actor,
+      transient: true
+    });
+    const runId = crypto.randomUUID();
+    await this.store.setActiveStream(subThread.id, runId);
+    const deps = this.factory.forAgent(agentName);
+    const hooks = {
+      runId,
+      openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
+      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
       step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
-      runAgent: /* @__PURE__ */ __name((agentName, task) => this.runNested(agentName, task, actor, day, 1, runId), "runAgent")
+      parallel: import_nestjs_agent_core21.settleAll,
+      cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
+      runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested({
+        agentName: childName,
+        task: childTask,
+        actor,
+        day,
+        depth: depth + 1,
+        path: [
+          ...path,
+          agentName
+        ],
+        // A detached run owns a stream of its own, so ITS sub-agents forward into that one.
+        sinkRunId: runId,
+        parentRunId: runId
+      }), "runAgent"),
+      startAgent: /* @__PURE__ */ __name(({ agentName: childName, task: childTask, toolCallId: toolCallId2 }) => this.startDetached({
+        agentName: childName,
+        task: childTask,
+        actor,
+        day,
+        depth: depth + 1,
+        path: [
+          ...path,
+          agentName
+        ],
+        parentRunId: runId,
+        deliverTo: {
+          threadId: subThread.id,
+          toolCallId: toolCallId2
+        }
+      }), "startAgent")
+    };
+    void (0, import_nestjs_agent_core21.runAgentLoop)({
+      ...deps,
+      day
+    }, {
+      threadId: subThread.id,
+      actor,
+      userText: task,
+      agentName,
+      day,
+      delegationDepth: depth,
+      delegationPath: path,
+      parentRunId,
+      deliverTo
+    }, hooks).catch(async (error) => {
+      const cancelled = error instanceof import_nestjs_agent_core21.RunCancelledError;
+      const message = error instanceof Error ? error.message : String(error);
+      if (!cancelled) {
+        this.logger.error(`detached agent run ${runId} failed: ${message}`);
+        (0, import_nestjs_agent_core21.publishAgentRunFailed)({
+          runId,
+          code: (0, import_nestjs_agent_core21.agentFailureCode)(error),
+          message
+        });
+      }
+      await this.store.recordRunEnd?.({
+        runId,
+        status: cancelled ? "cancelled" : "failed",
+        ...cancelled ? {} : {
+          errorCode: (0, import_nestjs_agent_core21.agentFailureCode)(error),
+          errorMessage: message
+        }
+      });
+      await (0, import_nestjs_agent_core21.settleUnsettledDelegation)({
+        store: this.store,
+        delivery: deliverTo,
+        agent: agentName,
+        runId,
+        status: cancelled ? "cancelled" : "failed",
+        ...cancelled ? {} : {
+          error: message
+        }
+      });
+    }).finally(async () => {
+      this.cancelled.delete(runId);
+      await this.store.setActiveStream(subThread.id, null);
+    });
+    return {
+      runId
     };
   }
   /**
@@ -2123,7 +3256,8 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * (the top-level run the human is watching) so its output and any pending action tool are visible,
   * and its own approvals resolve through the shared pending map keyed by its own runId.
   */
-  async runNested(agentName, task, actor, day, depth, sinkRunId) {
+  async runNested(args) {
+    const { agentName, task, actor, day, depth, path, sinkRunId, parentRunId } = args;
     const subThread = await this.store.createThread({
       actor,
       transient: true
@@ -2135,14 +3269,45 @@ var InlineAgentRunner = class _InlineAgentRunner {
       runId,
       // Forward into the top-level stream; the top-level run owns end/fail on that shared sink.
       openSink: /* @__PURE__ */ __name(async () => childSinkWriter(await deps.sink.open(sinkRunId)), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => new Promise((resolve) => {
-        this.pending.set(`${runId}:${call.id}`, resolve);
-      }), "awaitApproval"),
+      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
       step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
-      runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested(childName, childTask, actor, day, depth + 1, sinkRunId), "runAgent")
+      parallel: import_nestjs_agent_core21.settleAll,
+      // A child stops when it is cancelled OR when the run a human is actually watching is: the
+      // canceller names the top-level run, which is the only id that ever left the server.
+      cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId) || this.cancelled.has(sinkRunId), "cancelled"),
+      runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested({
+        agentName: childName,
+        task: childTask,
+        actor,
+        day,
+        depth: depth + 1,
+        path: [
+          ...path,
+          agentName
+        ],
+        sinkRunId,
+        parentRunId: runId
+      }), "runAgent"),
+      startAgent: /* @__PURE__ */ __name(({ agentName: childName, task: childTask, toolCallId: toolCallId2 }) => this.startDetached({
+        agentName: childName,
+        task: childTask,
+        actor,
+        day,
+        depth: depth + 1,
+        path: [
+          ...path,
+          agentName
+        ],
+        parentRunId: runId,
+        deliverTo: {
+          threadId: subThread.id,
+          toolCallId: toolCallId2
+        }
+      }), "startAgent")
     };
     try {
-      return await (0, import_nestjs_agent_core16.runAgentLoop)({
+      return await (0, import_nestjs_agent_core21.runAgentLoop)({
         ...deps,
         day
       }, {
@@ -2152,6 +3317,8 @@ var InlineAgentRunner = class _InlineAgentRunner {
         agentName,
         day,
         delegationDepth: depth,
+        delegationPath: path,
+        parentRunId,
         sinkRunId
       }, hooks);
     } finally {
@@ -2159,112 +3326,177 @@ var InlineAgentRunner = class _InlineAgentRunner {
     }
   }
 };
-InlineAgentRunner = _ts_decorate16([
-  (0, import_common16.Injectable)(),
-  _ts_param13(0, (0, import_common16.Inject)(import_nestjs_agent_core16.AGENT_DEPS_FACTORY)),
-  _ts_param13(1, (0, import_common16.Inject)(import_nestjs_agent_core16.AGENT_STORE)),
-  _ts_metadata15("design:type", Function),
-  _ts_metadata15("design:paramtypes", [
+InlineAgentRunner = _ts_decorate19([
+  (0, import_common19.Injectable)(),
+  _ts_param17(0, (0, import_common19.Inject)(import_nestjs_agent_core21.AGENT_DEPS_FACTORY)),
+  _ts_param17(1, (0, import_common19.Inject)(import_nestjs_agent_core21.AGENT_STORE)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentStore === "undefined" ? Object : AgentStore
   ])
 ], InlineAgentRunner);
 
+// src/skills-config.ts
+var import_nestjs_agent_core22 = require("@dudousxd/nestjs-agent-core");
+function declaredSkillProvider(declared) {
+  return {
+    list: /* @__PURE__ */ __name(({ scopes }) => declared.filter((skill) => scopes.includes(skill.scope)).map(({ name, description, scope }) => ({
+      name,
+      description,
+      scope
+    })), "list"),
+    load: /* @__PURE__ */ __name(async ({ name, scope, ctx }) => {
+      const match = declared.find((skill) => skill.name === name && skill.scope === scope);
+      return match === void 0 ? null : await match.body(ctx);
+    }, "load")
+  };
+}
+__name(declaredSkillProvider, "declaredSkillProvider");
+function resolveSkillsConfig(options, declared) {
+  if (options === void 0) {
+    return void 0;
+  }
+  const providers = options.provider === void 0 ? [
+    declaredSkillProvider(declared)
+  ] : [
+    options.provider,
+    declaredSkillProvider(declared)
+  ];
+  return {
+    provider: providers.length === 1 ? providers[0] : (0, import_nestjs_agent_core22.compositeSkillProvider)(providers),
+    ...options.scopes !== void 0 ? {
+      scopes: options.scopes
+    } : {},
+    ...options.maxSkills !== void 0 ? {
+      maxSkills: options.maxSkills
+    } : {}
+  };
+}
+__name(resolveSkillsConfig, "resolveSkillsConfig");
+
 // src/agent.module.ts
-function _ts_decorate17(decorators, target, key, desc) {
+function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate17, "_ts_decorate");
+__name(_ts_decorate20, "_ts_decorate");
 var DEFAULT_PATH = "agent";
 function sharedProviders(durable, includeStore) {
   const providers = [
     {
-      provide: import_nestjs_agent_core17.AGENT_TOOL_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core17.ToolRegistry(), "useFactory")
+      provide: import_nestjs_agent_core23.AGENT_TOOL_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core23.ToolRegistry(), "useFactory")
     },
     // Starts empty; AgentDiscoveryService populates it from `@Agent`-decorated providers at boot.
     {
-      provide: import_nestjs_agent_core17.AGENT_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core17.AgentRegistry(), "useFactory")
+      provide: import_nestjs_agent_core23.AGENT_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core23.AgentRegistry(), "useFactory")
     },
     // A shared, mutable list AgentDiscoveryService fills with `@SystemPromptContributor()` methods.
     {
-      provide: import_nestjs_agent_core17.AGENT_PROMPT_CONTRIBUTORS,
+      provide: import_nestjs_agent_core23.AGENT_PROMPT_CONTRIBUTORS,
+      useFactory: /* @__PURE__ */ __name(() => [], "useFactory")
+    },
+    // Likewise for `@Skill`-decorated providers — filled by SkillDiscoveryService at onModuleInit,
+    // read lazily by the AGENT_SKILLS provider below (which DI builds before discovery has run).
+    {
+      provide: import_nestjs_agent_core23.AGENT_SKILL_SOURCES,
       useFactory: /* @__PURE__ */ __name(() => [], "useFactory")
     },
     {
-      provide: import_nestjs_agent_core17.AGENT_SINK,
+      // One resolution, shared by the loop's deps and the listing endpoint: a second one would
+      // drift, and a user would be offered a skill the agent cannot reach. `undefined` when the
+      // host configured none — which is what keeps the turn's checkpoint sequence unchanged.
+      provide: import_nestjs_agent_core23.AGENT_SKILLS,
+      useFactory: /* @__PURE__ */ __name((options, declared) => resolveSkillsConfig(options.skills, declared), "useFactory"),
+      inject: [
+        import_nestjs_agent_core23.AGENT_OPTIONS,
+        import_nestjs_agent_core23.AGENT_SKILL_SOURCES
+      ]
+    },
+    {
+      // One resolution, shared by the loop's deps and the read-back endpoint: a person has to be
+      // shown what the model was shown, and two resolutions would eventually disagree about that.
+      provide: import_nestjs_agent_core23.AGENT_MEMORY,
+      useFactory: /* @__PURE__ */ __name((options) => options.memory, "useFactory"),
+      inject: [
+        import_nestjs_agent_core23.AGENT_OPTIONS
+      ]
+    },
+    {
+      provide: import_nestjs_agent_core23.AGENT_SINK,
       useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS
+        import_nestjs_agent_core23.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core17.AGENT_ROLES_POLICY,
-      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core17.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
+      provide: import_nestjs_agent_core23.AGENT_ROLES_POLICY,
+      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core23.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS
+        import_nestjs_agent_core23.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core17.AGENT_ACTOR_RESOLVER,
+      provide: import_nestjs_agent_core23.AGENT_ACTOR_RESOLVER,
       useFactory: /* @__PURE__ */ __name((options) => options.actorResolver, "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS
+        import_nestjs_agent_core23.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core17.AGENT_MODEL,
+      provide: import_nestjs_agent_core23.AGENT_MODEL,
       useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS
+        import_nestjs_agent_core23.AGENT_OPTIONS
       ]
     },
     {
       // An explicit `quota` wins; otherwise `quotaLimitTokens` binds the built-in ledger-backed
       // store; otherwise quotas are off (undefined). The ledger store reads the same usage rows
       // the loop already writes, so enforcement needs no extra shared state across replicas.
-      provide: import_nestjs_agent_core17.AGENT_QUOTA_STORE,
+      provide: import_nestjs_agent_core23.AGENT_QUOTA_STORE,
       useFactory: /* @__PURE__ */ __name((o, store) => o.quota ?? (o.quotaLimitTokens !== void 0 ? new LedgerQuotaStore(store, o.quotaLimitTokens) : void 0), "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS,
-        import_nestjs_agent_core17.AGENT_STORE
+        import_nestjs_agent_core23.AGENT_OPTIONS,
+        import_nestjs_agent_core23.AGENT_STORE
       ]
     },
     AgentDepsFactory2,
     {
-      provide: import_nestjs_agent_core17.AGENT_DEPS_FACTORY,
+      provide: import_nestjs_agent_core23.AGENT_DEPS_FACTORY,
       useExisting: AgentDepsFactory2
     },
     // Populates the registry + contributors (onModuleInit) BEFORE AiToolDiscoveryService synthesizes
     // handoff tools (onApplicationBootstrap) reads the registry.
     AgentDiscoveryService,
     AiToolDiscoveryService,
+    SkillDiscoveryService,
     InlineAgentRunner,
     AgentService,
     // Bound ALWAYS (durable or inline) — the console's cross-thread approvals inbox routes decisions
     // through AgentService.signalToolCall, which reaches whichever AGENT_RUNNER is bound above.
     AgentApprovalPortAdapter,
     {
-      provide: import_nestjs_agent_core17.AGENT_APPROVAL_PORT,
+      provide: import_nestjs_agent_core23.AGENT_APPROVAL_PORT,
       useExisting: AgentApprovalPortAdapter
     }
   ];
   if (includeStore) {
     providers.push({
-      provide: import_nestjs_agent_core17.AGENT_STORE,
+      provide: import_nestjs_agent_core23.AGENT_STORE,
       useFactory: /* @__PURE__ */ __name((o) => o.store, "useFactory"),
       inject: [
-        import_nestjs_agent_core17.AGENT_OPTIONS
+        import_nestjs_agent_core23.AGENT_OPTIONS
       ]
     });
   }
   if (durable) {
     providers.push({
-      provide: import_nestjs_agent_core17.AGENT_RUNNER,
+      provide: import_nestjs_agent_core23.AGENT_RUNNER,
       useFactory: /* @__PURE__ */ __name((durableRunner) => {
         if (durableRunner === void 0) {
           throw new Error("AgentModule.forRoot({ durable: true }) requires importing AgentDurableModule from '@dudousxd/nestjs-agent/durable' (alongside a configured DurableModule). It was not found.");
@@ -2273,14 +3505,14 @@ function sharedProviders(durable, includeStore) {
       }, "useFactory"),
       inject: [
         {
-          token: import_nestjs_agent_core17.AGENT_DURABLE_RUNNER,
+          token: import_nestjs_agent_core23.AGENT_DURABLE_RUNNER,
           optional: true
         }
       ]
     });
   } else {
     providers.push({
-      provide: import_nestjs_agent_core17.AGENT_RUNNER,
+      provide: import_nestjs_agent_core23.AGENT_RUNNER,
       useExisting: InlineAgentRunner
     });
   }
@@ -2289,23 +3521,25 @@ function sharedProviders(durable, includeStore) {
 __name(sharedProviders, "sharedProviders");
 function exportsFor(includeStore) {
   return [
-    import_nestjs_agent_core17.AGENT_OPTIONS,
-    import_nestjs_agent_core17.AGENT_TOOL_REGISTRY,
-    import_nestjs_agent_core17.AGENT_REGISTRY,
-    import_nestjs_agent_core17.AGENT_SINK,
-    import_nestjs_agent_core17.AGENT_ROLES_POLICY,
-    import_nestjs_agent_core17.AGENT_ACTOR_RESOLVER,
-    import_nestjs_agent_core17.AGENT_MODEL,
+    import_nestjs_agent_core23.AGENT_OPTIONS,
+    import_nestjs_agent_core23.AGENT_TOOL_REGISTRY,
+    import_nestjs_agent_core23.AGENT_REGISTRY,
+    import_nestjs_agent_core23.AGENT_SINK,
+    import_nestjs_agent_core23.AGENT_ROLES_POLICY,
+    import_nestjs_agent_core23.AGENT_ACTOR_RESOLVER,
+    import_nestjs_agent_core23.AGENT_MODEL,
     ...includeStore ? [
-      import_nestjs_agent_core17.AGENT_STORE
+      import_nestjs_agent_core23.AGENT_STORE
     ] : [],
-    import_nestjs_agent_core17.AGENT_QUOTA_STORE,
-    import_nestjs_agent_core17.AGENT_PROMPT_CONTRIBUTORS,
-    import_nestjs_agent_core17.AGENT_DEPS_FACTORY,
+    import_nestjs_agent_core23.AGENT_QUOTA_STORE,
+    import_nestjs_agent_core23.AGENT_PROMPT_CONTRIBUTORS,
+    import_nestjs_agent_core23.AGENT_SKILLS,
+    import_nestjs_agent_core23.AGENT_MEMORY,
+    import_nestjs_agent_core23.AGENT_DEPS_FACTORY,
     AgentDepsFactory2,
     AgentService,
     InlineAgentRunner,
-    import_nestjs_agent_core17.AGENT_APPROVAL_PORT
+    import_nestjs_agent_core23.AGENT_APPROVAL_PORT
   ];
 }
 __name(exportsFor, "exportsFor");
@@ -2314,7 +3548,9 @@ var BASE_CONTROLLERS = [
   ThreadsController,
   ToolCallController,
   QuotaController,
-  AgentsController
+  AgentsController,
+  SkillsController,
+  MemoriesController
 ];
 var GUARDABLE_CONTROLLERS = [
   ...BASE_CONTROLLERS,
@@ -2346,7 +3582,7 @@ function guardProviders(guards) {
 }
 __name(guardProviders, "guardProviders");
 function routerFor(path) {
-  return import_core3.RouterModule.register([
+  return import_core4.RouterModule.register([
     {
       path,
       module: AgentModule
@@ -2373,13 +3609,13 @@ var AgentModule = class _AgentModule {
       module: _AgentModule,
       global: true,
       imports: [
-        import_core3.DiscoveryModule,
+        import_core4.DiscoveryModule,
         routerFor(path)
       ],
       controllers: controllersForSurface(options.surface, options.attachments?.upload === true),
       providers: [
         {
-          provide: import_nestjs_agent_core17.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core23.AGENT_OPTIONS,
           useValue: options
         },
         ...sharedProviders(options.durable ?? false, includeStore),
@@ -2397,14 +3633,14 @@ var AgentModule = class _AgentModule {
       module: _AgentModule,
       global: true,
       imports: [
-        import_core3.DiscoveryModule,
+        import_core4.DiscoveryModule,
         routerFor(path),
         ...options.imports ?? []
       ],
       controllers: controllersForSurface(options.surface, options.attachmentsUpload === true),
       providers: [
         {
-          provide: import_nestjs_agent_core17.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core23.AGENT_OPTIONS,
           // Stamp the STATIC wiring flags onto the factory result: `durable`/`dispatchedSteps`/
           // `surface` are authoritative on the async config object (they decided the actual wiring
           // above), and `AgentDurableModule` derives the effective dispatched-steps value from
@@ -2429,9 +3665,9 @@ var AgentModule = class _AgentModule {
     };
   }
 };
-AgentModule = _ts_decorate17([
-  (0, import_common17.Global)(),
-  (0, import_common17.Module)({})
+AgentModule = _ts_decorate20([
+  (0, import_common20.Global)(),
+  (0, import_common20.Module)({})
 ], AgentModule);
 
 // src/durable/agent-durable.ts