tnega 0.3.0 → 0.4.1

package/dist/coding-agent.js

@@ -2484,9 +2484,9 @@ var require_validate = __commonJS({
       }
     }
     function returnResults(it) {
-      const { gen, schemaEnv, validateName, ValidationError, opts } = it;
+      const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it;
       if (schemaEnv.$async) {
-        gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
+        gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError2}(${names_1.default.vErrors})`));
       } else {
         gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
         if (opts.unevaluated)
@@ -2838,14 +2838,14 @@ var require_validation_error = __commonJS({
   "node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    var ValidationError = class extends Error {
+    var ValidationError2 = class extends Error {
       constructor(errors) {
         super("validation failed");
         this.errors = errors;
         this.ajv = this.validation = true;
       }
     };
-    exports.default = ValidationError;
+    exports.default = ValidationError2;
   }
 });
 
@@ -10322,7 +10322,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const catchall = def.catchall;
   let value;
   const memo2 = globalConfig.memoizer;
@@ -10330,7 +10330,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -10449,7 +10449,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return doc.compile();
   };
   let fastpass;
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -10458,7 +10458,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -18045,7 +18045,7 @@ function copyMessages(messages) {
       copy.tool_calls = message.tool_calls.map((call) => ({
         id: call.id,
         name: call.name,
-        arguments: call.arguments
+        arguments: structuredClone(call.arguments)
       }));
     }
     return copy;
@@ -18076,6 +18076,75 @@ function copyCompletion(completion) {
   }
   return copy;
 }
+function canonicalMessages(messages) {
+  return JSON.stringify(messages.map((message) => ({
+    role: message.role,
+    content: message.content,
+    ...message.name ? { name: message.name } : {},
+    ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {},
+    ...message.tool_calls?.length ? { tool_calls: message.tool_calls } : {},
+    ...message.toolOk !== void 0 ? { toolOk: message.toolOk } : {},
+    ...message.toolError ? {
+      toolError: { name: message.toolError.name, message: message.toolError.message }
+    } : {}
+  })));
+}
+function freezeRequestData(data) {
+  const visited = /* @__PURE__ */ new Set();
+  const freeze = (value) => {
+    if (typeof value !== "object" || value === null || visited.has(value)) return;
+    visited.add(value);
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  };
+  freeze(data);
+}
+function lockStreamRequest(request) {
+  freezeRequestData(request.messages);
+  request.tools = Object.freeze(request.tools.map((tool) => {
+    const schema = structuredClone(tool.schema);
+    freezeRequestData(schema);
+    return Object.freeze({ ...tool, schema });
+  }));
+  Object.freeze(request.options);
+  Object.freeze(request);
+}
+function requestHeaderFor(request, input) {
+  const system = input.find((message) => message.role === "system")?.content;
+  const tools = request.tools.map((tool) => ({
+    name: tool.schema.name,
+    description: tool.schema.description,
+    ...tool.schema.parameters ? { parameters: tool.schema.parameters } : {}
+  }));
+  const config2 = {
+    ...request.options.provider ? { provider: request.options.provider } : {},
+    ...request.options.model ? { model: request.options.model } : {},
+    ...request.options.temperature !== void 0 ? { temperature: request.options.temperature } : {}
+  };
+  return {
+    ...Object.keys(config2).length ? { config: config2 } : {},
+    ...system !== void 0 ? { system } : {},
+    ...tools.length ? { tools } : {}
+  };
+}
+async function* completeAsStream(llm, messages, tools, options) {
+  const id = randomUUID();
+  yield { type: "message_start", id };
+  const completion = await llm.complete(messages, tools, options);
+  if (completion.content) yield { type: "message_delta", id, delta: completion.content };
+  for (let index = 0; index < (completion.toolCalls?.length ?? 0); index += 1) {
+    const call = completion.toolCalls[index];
+    yield { type: "toolcall_start", id: call.id, index, name: call.name };
+    yield {
+      type: "toolcall_end",
+      id: call.id,
+      index,
+      name: call.name,
+      arguments: call.arguments
+    };
+  }
+  yield { type: "message_stop", id, finishReason: completion.finishReason };
+}
 function isCancelCause(value) {
   if (typeof value !== "object" || value === null) return false;
   const record2 = value;
@@ -18096,6 +18165,13 @@ function cancelCauseFromSignal(signal) {
   if (isCancelCause(reason)) return reason;
   return { type: "abort" };
 }
+function abortedToolError(signal) {
+  const cause = cancelCauseFromSignal(signal);
+  return {
+    name: "AbortError",
+    message: `tool call aborted: ${cause?.type ?? "abort"}`
+  };
+}
 function toTurnEndReason(fields) {
   const { cancelled, turnError, finishReason, cancelCause } = fields;
   if (cancelled || finishReason === "cancelled") {
@@ -18140,6 +18216,78 @@ async function cancellableDelay(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
+var AssistantStreamAttempt = class {
+  constructor(session, turn, step, nextRevision) {
+    this.session = session;
+    this.turn = turn;
+    this.step = step;
+    this.nextRevision = nextRevision;
+  }
+  session;
+  turn;
+  step;
+  nextRevision;
+  attemptId = randomUUID();
+  records = [];
+  ended = false;
+  start() {
+    return { type: "assistant/stream", frame: {
+      type: "start",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      turn: this.turn,
+      step: this.step
+    } };
+  }
+  push(chunk) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const record2 = { time: Date.now(), chunk: structuredClone(chunk) };
+    const index = this.records.length;
+    this.records.push(record2);
+    return { type: "assistant/stream", frame: {
+      type: "chunk",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index,
+      ...structuredClone(record2)
+    } };
+  }
+  async settle(message) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const eventType = message ? "assistant/message" : "assistant/attempt";
+    let event;
+    try {
+      event = message ? await this.session.append("assistant/message", { ...message, stream: this.records }) : await this.session.append("assistant/attempt", { turn: this.turn, step: this.step, stream: this.records });
+    } catch (cause) {
+      this.ended = true;
+      const frame = { type: "assistant/stream", frame: {
+        type: "end",
+        attemptId: this.attemptId,
+        revision: this.nextRevision(),
+        index: this.records.length,
+        outcome: { kind: "abandoned" }
+      } };
+      throw new AttemptSettlementError(cause, frame);
+    }
+    this.ended = true;
+    return { type: "assistant/stream", frame: {
+      type: "end",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index: this.records.length,
+      outcome: { kind: "committed", eventType, seq: event.seq }
+    } };
+  }
+};
+var AttemptSettlementError = class extends Error {
+  constructor(cause, frame) {
+    super("assistant attempt settlement failed");
+    this.cause = cause;
+    this.frame = frame;
+  }
+  cause;
+  frame;
+};
 var AgentService = class {
   constructor(ctx, config2 = {}) {
     this.ctx = ctx;
@@ -18148,9 +18296,24 @@ var AgentService = class {
   }
   ctx;
   config;
+  async *settleAttempt(attempt, message) {
+    try {
+      yield await attempt.settle(message);
+    } catch (error2) {
+      if (error2 instanceof AttemptSettlementError) {
+        yield error2.frame;
+        throw error2.cause;
+      }
+      throw error2;
+    }
+  }
   inbox;
   _seriesStarted = false;
   _persistedRequest = false;
+  _streamRevision = 0;
+  _attempt(session, turn, step) {
+    return new AssistantStreamAttempt(session, turn, step, () => ++this._streamRevision);
+  }
   /** Call when a request begins an explicit new model-message series. */
   startSeries() {
     this._seriesStarted = true;
@@ -18164,7 +18327,7 @@ var AgentService = class {
     return this._persistedRequest;
   }
   async run(input, options = {}) {
-    return consumeAgentStream(this._stream(input, options, false));
+    return consumeAgentStream(this._stream(input, options));
   }
   async *runStream(input, options = {}) {
     const iterator = this._stream(input, options)[Symbol.asyncIterator]();
@@ -18174,7 +18337,7 @@ var AgentService = class {
       yield next.value;
     }
   }
-  async *_stream(input, options = {}, useStream = true) {
+  async *_stream(input, options = {}) {
     const claimed = input ?? this.inbox.claim();
     if (!claimed) throw new AgentError("no agent input available");
     await this.config.hooks?.beforeRun?.(claimed, options);
@@ -18182,26 +18345,32 @@ var AgentService = class {
     const tools = this._tools();
     const llm = this._llm();
     if (!llm) throw new AgentError("no LLM adapter available");
+    const streamAdapter = llm.stream;
+    const persistChunks = streamAdapter !== void 0;
     const maxTurns = options.maxTurns ?? this.config.maxTurns ?? 64;
     const maxSteps = options.maxSteps ?? this.config.maxSteps ?? 64;
     const contextBudget = options.contextBudget ?? this.config.contextBudget;
     const injected = this.inbox.injected();
     this.ctx.emit("agent/start", { input: claimed, options, injected });
     let messages = await this._initialMessages(claimed);
+    let claimedMessages = messages.filter((message) => message.role === "user");
     const steps = [];
     let output = "";
     let finishReason = "stop";
+    let lengthReached = false;
     this.ctx.emit("agent/turn-start", {
       input: claimed,
       messages: copyMessages(messages),
       injected
     });
-    const turn = await session.nextTurn();
-    await session.append("turn/start", {
-      turn,
-      input: claimed.text ?? claimed,
-      reason: "user"
-    });
+    const turn = options.turn ?? await session.nextTurn();
+    if (options.turn === void 0) {
+      await session.append("turn/start", {
+        turn,
+        input: claimed.text ?? claimed,
+        reason: "user"
+      });
+    }
     let index = 0;
     let finalTurnGranted = false;
     let currentStepIndex;
@@ -18220,20 +18389,22 @@ var AgentService = class {
           messages = await this._enforceContextBudget(session, contextBudget, messages);
         }
         const stepInput = copyMessages(messages);
-        const preStep = this.ctx.waterfall("agent/pre-step", {
+        const preStep = await this.ctx.waterfallAsync("agent/pre-step", {
           index,
           turn,
           step: index,
           messages: stepInput,
+          claimedMessages: copyMessages(claimedMessages),
           ...options.signal ? { signal: options.signal } : {}
         }, (payload) => payload);
-        if (!preStep || !Array.isArray(preStep.messages) || !preStep.messages.length) {
+        if (!preStep || preStep.admission === "reject" || !Array.isArray(preStep.messages) || !preStep.messages.length) {
           break;
         }
         if (preStep.startsRequestSeries) this._seriesStarted = true;
         await session.append("step/start", { turn, step: index });
         currentStepIndex = index;
         const requestedInput = copyMessages(preStep.messages);
+        const admittedHistory = await session.deriveMessages();
         this.ctx.emit("agent/step", {
           index,
           turn,
@@ -18245,93 +18416,85 @@ var AgentService = class {
           maxSteps: maxSteps - steps.length
         };
         if (options.signal) completeOptions.signal = options.signal;
-        const request = this.ctx.waterfall("agent/request", {
-          index,
-          messages: requestedInput,
-          tools: availableTools,
-          options: completeOptions
-        }, (payload) => payload);
-        if (!request || !request.options || !request.tools) {
-          throw new AgentError("agent/request must return a request payload");
-        }
         let llmMessages = copyMessages(requestedInput);
         let completion;
-        const streamMethod = useStream ? llm.stream : void 0;
+        let activeAttempt;
         let attempt = 0;
-        let persistedStepInput = false;
         while (true) {
           if (options.signal?.aborted) {
             finishReason = "cancelled";
             break;
           }
           const streamEvents = [];
+          activeAttempt = this._attempt(session, turn, index);
+          yield activeAttempt.start();
+          const streamRequest = {
+            index,
+            messages: copyMessages(requestedInput),
+            tools: [...availableTools],
+            options: { ...completeOptions }
+          };
           try {
-            if (streamMethod) {
-              const streamRequest = {
-                index,
-                messages: llmMessages,
-                tools: request.tools,
-                options: request.options
-              };
-              const stream = await this.ctx.waterfallAsync(
-                "llm/stream",
-                streamRequest,
-                async (payload) => {
-                  if (!streamMethod) {
-                    throw new AgentError("llm.stream is required for streaming runs");
-                  }
-                  return streamMethod(payload.messages, payload.tools, payload.options);
-                }
-              );
-              if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
-                throw new AgentError("llm/stream must return an async iterable stream");
-              }
+            const request = await this.ctx.waterfallAsync("agent/request", {
+              index,
+              messages: copyMessages(requestedInput),
+              tools: streamRequest.tools,
+              options: streamRequest.options
+            }, (payload) => payload);
+            if (!request || !request.options || !request.tools) {
+              throw new AgentError("agent/request must return a request payload");
+            }
+            streamRequest.tools = request.tools;
+            streamRequest.options = request.options;
+            let preparation;
+            const prepareRequest = () => preparation ??= (async () => {
+              lockStreamRequest(streamRequest);
               llmMessages = copyMessages(streamRequest.messages);
-              if (!persistedStepInput) {
-                await this._persistStepInput(session, request, llmMessages);
-                if (this.config.assertReplayable) {
-                  await this._assertReplayable(session, llmMessages);
-                }
-                persistedStepInput = true;
-              }
-              let chunkIndex = 0;
-              for await (const event of stream) {
-                streamEvents.push(event);
-                if (event.type === "message_delta") {
-                  await session.append("assistant/chunk", {
-                    id: event.id,
-                    content: event.delta,
-                    index: chunkIndex
-                  });
-                  chunkIndex += 1;
-                }
-                yield event;
-              }
-              completion = completionFromStreamEvents(streamEvents);
-            } else {
-              if (!persistedStepInput) {
-                await this._persistStepInput(session, request, llmMessages);
-                if (this.config.assertReplayable) {
-                  await this._assertReplayable(session, llmMessages);
-                }
-                persistedStepInput = true;
+              await this._persistStepInput(session, streamRequest, llmMessages, admittedHistory);
+              await this._assertReplayable(session, streamRequest, llmMessages);
+            })();
+            const stream = await this.ctx.waterfallAsync(
+              "llm/stream",
+              streamRequest,
+              (payload) => (async function* () {
+                await prepareRequest();
+                yield* streamAdapter ? streamAdapter.call(llm, payload.messages, payload.tools, payload.options) : completeAsStream(llm, payload.messages, payload.tools, payload.options);
+              })()
+            );
+            if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+              throw new AgentError("llm/stream must return an async iterable stream");
+            }
+            await prepareRequest();
+            let chunkIndex = 0;
+            for await (const event of stream) {
+              streamEvents.push(structuredClone(event));
+              yield activeAttempt.push(event);
+              if (persistChunks && event.type === "message_delta") {
+                await session.append("assistant/chunk", {
+                  id: event.id,
+                  content: event.delta,
+                  index: chunkIndex
+                });
+                chunkIndex += 1;
               }
-              completion = await llm.complete(llmMessages, request.tools, request.options);
+              yield event;
+            }
+            completion = completionFromStreamEvents(streamEvents);
+            if (completion.finishReason === "error" || completion.finishReason === "cancelled") {
+              const terminalReason = completion.finishReason;
+              completion = void 0;
+              throw new AgentError(`LLM stream finished with ${terminalReason}`);
             }
             break;
           } catch (error2) {
-            const content = partialStreamContent(streamEvents);
-            if (content) {
-              await session.append("assistant/message", {
-                content,
-                interrupted: true
-              });
-              llmMessages = await session.deriveMessages();
-            }
+            yield activeAttempt.push({ type: "stream_error", error: toToolError(error2) });
             if (options.signal?.aborted) {
+              const content = partialStreamContent(streamEvents);
+              yield* this.settleAttempt(activeAttempt, content ? { content, interrupted: true } : void 0);
               finishReason = "cancelled";
               break;
             }
+            yield* this.settleAttempt(activeAttempt);
             attempt += 1;
             const failure = toToolError(error2);
             const decision = await this.ctx.waterfallAsync(
@@ -18340,14 +18503,14 @@ var AgentService = class {
                 index,
                 turn,
                 step: index,
-                messages: copyMessages(llmMessages),
-                tools: request.tools,
-                options: request.options,
+                messages: copyMessages(streamRequest.messages),
+                tools: [...streamRequest.tools],
+                options: { ...streamRequest.options },
                 attempt,
                 error: error2,
                 failure,
-                ...request.options.provider ? { provider: request.options.provider } : {},
-                ...request.options.model ? { model: request.options.model } : {},
+                ...streamRequest.options.provider ? { provider: streamRequest.options.provider } : {},
+                ...streamRequest.options.model ? { model: streamRequest.options.model } : {},
                 ...options.signal ? { signal: options.signal } : {}
               },
               () => void 0
@@ -18372,16 +18535,30 @@ var AgentService = class {
             await session.append("llm/retry-started", { retryId, retry: attempt });
           }
         }
-        if (options.signal?.aborted) break;
-        if (!completion) throw new AgentError("LLM adapter did not produce a completion");
+        if (!completion || !activeAttempt) {
+          if (options.signal?.aborted) {
+            finishReason = "cancelled";
+            break;
+          }
+          throw new AgentError("LLM adapter did not produce a completion");
+        }
         const toolCalls = completion.toolCalls ?? [];
-        if (finalTurnGranted && toolCalls.length) {
+        if (completion.finishReason === "length") lengthReached = true;
+        if (options.signal?.aborted && toolCalls.length === 0) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AbortError", message: "stream aborted" } });
+          yield* this.settleAttempt(activeAttempt);
+          finishReason = "cancelled";
+          break;
+        }
+        if (finalTurnGranted && toolCalls.length && !options.signal?.aborted) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AgentError", message: "maximum turns reached" } });
+          yield* this.settleAttempt(activeAttempt);
           finishReason = "max_turns";
           break;
         }
         const toolResults = [];
         if (toolCalls.length) {
-          await session.append("assistant/message", {
+          yield* this.settleAttempt(activeAttempt, {
             content: completion.content ?? "",
             toolCalls: toolCalls.map((call) => ({
               id: call.id,
@@ -18402,18 +18579,30 @@ var AgentService = class {
           if (options.signal) toolOptions.signal = options.signal;
           const startedAt = Date.now();
           let result;
-          try {
-            result = await tools.execute(call.name, call.arguments, toolOptions);
-          } catch (error2) {
+          if (options.signal?.aborted) {
             result = {
               ok: false,
               name: call.name,
               callId: call.id,
               input: call.arguments,
-              error: toToolError(error2),
+              error: abortedToolError(options.signal),
               startedAt,
               durationMs: Date.now() - startedAt
             };
+          } else {
+            try {
+              result = await tools.execute(call.name, call.arguments, toolOptions);
+            } catch (error2) {
+              result = {
+                ok: false,
+                name: call.name,
+                callId: call.id,
+                input: call.arguments,
+                error: toToolError(error2),
+                startedAt,
+                durationMs: Date.now() - startedAt
+              };
+            }
           }
           toolResults.push(result);
           const toolResultPayload = {
@@ -18455,7 +18644,7 @@ var AgentService = class {
           output = completion.content;
         }
         if (!toolCalls.length) {
-          await session.append("assistant/message", { content: completion.content ?? "" });
+          yield* this.settleAttempt(activeAttempt, { content: completion.content ?? "" });
         }
         await session.append("step/end", {
           turn,
@@ -18466,19 +18655,19 @@ var AgentService = class {
         currentStepIndex = void 0;
         const nextMessages = this._extendMessages(llmMessages, completion, toolResults);
         const concludesTurn = toolResults.some((result) => result.concludesTurn === true);
-        if (concludesTurn) {
-          finishReason = "stop";
-          break;
-        }
-        if (toolCalls.length === 0) {
-          finishReason = completion.finishReason === "length" ? "length" : completion.finishReason === "error" ? "error" : "stop";
+        let nextStepMessages = await this._claimNextStepMessages();
+        if ((toolCalls.length === 0 || concludesTurn) && nextStepMessages.length === 0) {
+          finishReason = lengthReached ? "length" : completion.finishReason === "error" ? "error" : "stop";
           const keepGoing = await this.ctx.serial("agent/turn-stopping", {
             index,
             turn,
             steps: copySteps(steps),
             finishReason
           });
-          if (!keepGoing) break;
+          if (!keepGoing) {
+            nextStepMessages = await this._claimNextStepMessages();
+            if (nextStepMessages.length === 0) break;
+          }
         }
         if (index + 1 >= maxTurns && !finalTurnGranted) {
           finalTurnGranted = true;
@@ -18488,7 +18677,8 @@ var AgentService = class {
         }
         if (toolCalls.length) finishReason = "tool_calls";
         index += 1;
-        messages = nextMessages;
+        messages = [...nextMessages, ...nextStepMessages];
+        claimedMessages = nextStepMessages.filter((message) => message.role === "user");
       }
     } catch (error2) {
       turnError = error2;
@@ -18574,23 +18764,22 @@ var AgentService = class {
     });
     return compactMessages.map((message) => copyMessages([message])[0]);
   }
-  async _persistStepInput(session, request, input) {
-    const system = input.find((message) => message.role === "system")?.content;
-    const tools = request.tools.map((tool) => ({
-      name: tool.schema.name,
-      description: tool.schema.description,
-      ...tool.schema.parameters ? { parameters: tool.schema.parameters } : {}
-    }));
-    const config2 = {
-      ...request.options.provider ? { provider: request.options.provider } : {},
-      ...request.options.model ? { model: request.options.model } : {},
-      ...request.options.temperature !== void 0 ? { temperature: request.options.temperature } : {}
-    };
-    const nextHeader = {
-      ...Object.keys(config2).length ? { config: config2 } : {},
-      ...system !== void 0 ? { system } : {},
-      ...tools.length ? { tools } : {}
-    };
+  async _persistStepInput(session, request, input, admittedHistory) {
+    const surface = await session.deriveMessages();
+    const owned = admittedHistory.filter((message) => !isUserOrSystemMessage(message));
+    let ownerIndex = 0;
+    for (const message of input) {
+      if (isUserOrSystemMessage(message)) continue;
+      const actual = canonicalMessages([message]);
+      while (ownerIndex < owned.length && canonicalMessages([owned[ownerIndex]]) !== actual) {
+        ownerIndex += 1;
+      }
+      if (ownerIndex === owned.length) {
+        throw new AgentError("request is not reconstructable from session log: unowned or reordered assistant/tool message");
+      }
+      ownerIndex += 1;
+    }
+    const nextHeader = requestHeaderFor(request, input);
     const previousHeader = session.requestHeader();
     const isFirstRequest = !this._persistedRequest;
     const isResume = isFirstRequest && previousHeader !== void 0;
@@ -18620,19 +18809,23 @@ var AgentService = class {
       ...request.options.provider ? { provider: request.options.provider } : {},
       ...request.options.model ? { model: request.options.model } : {}
     };
+    if (request.options.contextWindow !== void 0) {
+      nextContext.contextWindow = request.options.contextWindow;
+    }
     const llmService = this.ctx.reflect.get("llm", false);
     const routeCapacity = llmService?.routeCapacity?.();
-    if (routeCapacity?.contextWindow !== void 0) {
+    if (nextContext.contextWindow === void 0 && routeCapacity?.contextWindow !== void 0) {
       nextContext.contextWindow = routeCapacity.contextWindow;
     }
     const previousContext = session.requestContext();
     if (previousContext?.provider !== nextContext.provider || previousContext?.model !== nextContext.model || previousContext?.contextWindow !== nextContext.contextWindow || previousContext === void 0) {
       await session.append("request/context", nextContext);
     }
-    const requested = input.filter(isUserOrSystemMessage);
-    const surface = await session.deriveMessages();
-    const appendDurable = async (messages) => {
-      for (const message of messages) {
+    const isSurfacePrefix = (messages) => canonicalMessages(messages.slice(0, surface.length)) === canonicalMessages(surface);
+    const requested = surface.length > 0 && input[0]?.role === "system" && input[0].content === nextHeader.system && isSurfacePrefix(input.slice(1)) ? input.slice(1) : input;
+    const tail = requested.slice(surface.length);
+    if (isSurfacePrefix(requested) && tail.every(isUserOrSystemMessage)) {
+      for (const message of tail) {
         if (message.role === "user") {
           await session.append("user/message", {
             content: message.content,
@@ -18645,45 +18838,37 @@ var AgentService = class {
           });
         }
       }
-    };
-    if (surface.length === 0) {
-      await appendDurable(requested);
       return;
     }
-    const durableUsers = surface.filter((message) => message.role === "user").length;
-    let seenUsers = 0;
-    const newTail = [];
-    for (const message of requested) {
-      if (message.role === "user") seenUsers += 1;
-      if (seenUsers <= durableUsers) continue;
-      newTail.push(message);
-    }
-    await appendDurable(newTail);
+    const nodes = await session.surfaceEvents();
+    await session.append("checkpoint", {
+      messages: copyMessages(requested),
+      surfaceOp: { op: "replace", start: nodes[0].seq, end: nodes.at(-1).seq }
+    });
   }
-  async _assertReplayable(session, input) {
+  async _assertReplayable(session, request, input) {
     const reconstructed = await session.deriveMessages();
-    const canonical = (messages) => messages.filter((message) => message.role !== "system").map((message) => ({
-      role: message.role,
-      content: message.content,
-      ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {},
-      ...message.name ? { name: message.name } : {},
-      ...message.tool_calls?.length ? { tool_calls: message.tool_calls.map((call) => ({
-        id: call.id,
-        name: call.name,
-        args: JSON.stringify(call.arguments ?? {})
-      })) } : {}
-    }));
-    const actual = canonical(input);
-    const replay = canonical(reconstructed);
-    if (JSON.stringify(actual) !== JSON.stringify(replay)) {
+    const actual = canonicalMessages(input);
+    const replay = canonicalMessages(reconstructed);
+    const header = session.requestHeader();
+    const headerOwnsPrefix = input[0]?.role === "system" && input[0].content === header?.system && canonicalMessages(input.slice(1)) === replay;
+    if (actual !== replay && !headerOwnsPrefix) {
       throw new AgentError(
-        `request is not reconstructable from session log: actual=${JSON.stringify(actual)} replay=${JSON.stringify(replay)}`
+        `request is not reconstructable from session log: actual=${actual} replay=${replay}`
       );
     }
+    const expected = requestHeaderFor(request, input);
+    if (header?.system !== expected.system || JSON.stringify(header?.tools ?? []) !== JSON.stringify(expected.tools ?? []) || JSON.stringify(header?.config ?? {}) !== JSON.stringify(expected.config ?? {})) {
+      throw new AgentError("request envelope is not reconstructable from session log");
+    }
+  }
+  async _claimNextStepMessages() {
+    const inputs = await this.config.claimNextStep?.() ?? [];
+    return inputs.flatMap((input) => input.messages?.length ? copyMessages(input.messages) : input.text ? [{ role: "user", content: input.text }] : input.context !== void 0 ? [{ role: "user", content: stringify(input.context) }] : []);
   }
   async _initialMessages(input) {
     const promptService = this.ctx.reflect.get("systemPrompt", false);
-    const assembled = promptService ? (await promptService.assemble()).text.trim() : void 0;
+    const assembled = promptService ? (await promptService.assemble({}, this.ctx)).text.trim() : void 0;
     const systemPrompt = assembled || this.inbox.injected().get("agentSystem");
     const systemMessage = typeof systemPrompt === "string" && systemPrompt ? [{ role: "system", content: systemPrompt }] : [];
     if (input.messages?.length) {
@@ -18708,7 +18893,7 @@ var AgentService = class {
         arguments: call.arguments
       }));
     }
-    next.push(assistant);
+    if (assistant.content || toolCalls.length) next.push(assistant);
     for (const call of toolCalls) {
       const result = toolResults.find((candidate) => candidate.callId === call.id);
       const content = result ? result.ok ? stringify(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
@@ -18738,7 +18923,8 @@ var AgentService = class {
     return session;
   }
   _tools() {
-    const tools = this.ctx.tools;
+    const scoped = this.ctx.reflect.get("tools", false);
+    const tools = scoped ?? this.ctx.tools;
     if (!tools) throw new AgentError("tools service is required");
     return tools;
   }
@@ -18903,6 +19089,1281 @@ function defineAgent(definition) {
   };
 }
 
+// packages/core/src/utils.ts
+var DisposableList = class {
+  sn = 0;
+  map = /* @__PURE__ */ new Map();
+  weak = /* @__PURE__ */ new WeakMap();
+  get length() {
+    return this.map.size;
+  }
+  push(value) {
+    const sn = ++this.sn;
+    this.map.set(sn, value);
+    this.weak.set(value, sn);
+    return () => this.map.delete(sn);
+  }
+  unshift(value) {
+    const sn = ++this.sn;
+    const entries = [...this.map.entries()];
+    this.map.clear();
+    this.map.set(sn, value);
+    this.weak.set(value, sn);
+    for (const [oldSn, oldValue] of entries) {
+      this.map.set(oldSn, oldValue);
+    }
+    return () => this.map.delete(sn);
+  }
+  delete(value) {
+    const sn = this.weak.get(value);
+    if (!sn) return false;
+    return this.map.delete(sn);
+  }
+  clear() {
+    const values = [...this.map.values()];
+    this.map.clear();
+    return values.reverse();
+  }
+  [Symbol.iterator]() {
+    return this.map.values();
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this];
+  }
+};
+var symbols = {
+  shadow: /* @__PURE__ */ Symbol.for("tnega.shadow"),
+  caller: /* @__PURE__ */ Symbol.for("tnega.caller"),
+  receiver: /* @__PURE__ */ Symbol.for("tnega.receiver"),
+  original: /* @__PURE__ */ Symbol.for("tnega.original"),
+  metadata: /* @__PURE__ */ Symbol.for("tnega.metadata"),
+  initHooks: /* @__PURE__ */ Symbol.for("tnega.initHooks"),
+  checkProto: /* @__PURE__ */ Symbol.for("tnega.checkProto"),
+  effect: /* @__PURE__ */ Symbol.for("tnega.effect"),
+  filter: /* @__PURE__ */ Symbol.for("tnega.filter"),
+  isolate: /* @__PURE__ */ Symbol.for("tnega.isolate"),
+  intercept: /* @__PURE__ */ Symbol.for("tnega.intercept"),
+  init: /* @__PURE__ */ Symbol.for("tnega.init"),
+  check: /* @__PURE__ */ Symbol.for("tnega.check"),
+  config: /* @__PURE__ */ Symbol.for("tnega.config"),
+  invoke: /* @__PURE__ */ Symbol.for("tnega.invoke"),
+  extend: /* @__PURE__ */ Symbol.for("tnega.extend"),
+  tracker: /* @__PURE__ */ Symbol.for("tnega.tracker"),
+  resolveConfig: /* @__PURE__ */ Symbol.for("tnega.resolveConfig")
+};
+var GeneratorFunction = function* () {
+}.constructor;
+var AsyncGeneratorFunction = async function* () {
+}.constructor;
+function isConstructor(func) {
+  if (typeof func !== "function") return false;
+  if (func instanceof GeneratorFunction) return false;
+  if (AsyncGeneratorFunction !== Function && func instanceof AsyncGeneratorFunction) return false;
+  return /^class\s/.test(Function.prototype.toString.call(func));
+}
+function isObject2(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function isNullable(value) {
+  return value == null;
+}
+function joinPrototype(proto1, proto2) {
+  if (proto1 === Object.prototype) return proto2;
+  const result = Object.create(joinPrototype(Object.getPrototypeOf(proto1), proto2));
+  for (const key of Reflect.ownKeys(proto1)) {
+    Object.defineProperty(result, key, Reflect.getOwnPropertyDescriptor(proto1, key));
+  }
+  return result;
+}
+function getPropertyDescriptor(target, prop) {
+  let proto = target;
+  while (proto) {
+    const desc = Reflect.getOwnPropertyDescriptor(proto, prop);
+    if (desc) return desc;
+    proto = Object.getPrototypeOf(proto);
+  }
+}
+function getTraceable(ctx, value) {
+  if (!isObject2(value)) return value;
+  if (Object.hasOwn(value, symbols.shadow)) {
+    return Object.getPrototypeOf(value);
+  }
+  const tracker = value[symbols.tracker];
+  if (!tracker) return value;
+  return createTraceable(ctx, value, tracker);
+}
+function withProps(target, props) {
+  if (!props) return target;
+  return new Proxy(target, {
+    get: (target2, prop, receiver) => {
+      if (prop in props && prop !== "constructor") return Reflect.get(props, prop, receiver);
+      return Reflect.get(target2, prop, receiver);
+    },
+    set: (target2, prop, value, receiver) => {
+      if (prop in props && prop !== "constructor") return Reflect.set(props, prop, value, receiver);
+      return Reflect.set(target2, prop, value, receiver);
+    }
+  });
+}
+function withProp(target, prop, value) {
+  return withProps(target, Object.defineProperty(/* @__PURE__ */ Object.create(null), prop, {
+    value,
+    writable: false
+  }));
+}
+function createShadow(ctx, target, property, receiver) {
+  if (!property) return receiver;
+  const origin = getPropertyDescriptor(target, property)?.value;
+  if (!origin) return receiver;
+  return withProp(receiver, property, ctx.extend({ [symbols.shadow]: origin }));
+}
+function createShadowMethod(ctx, value, outer, shadow) {
+  const proxy = new Proxy(value, {
+    apply: (target, thisArg, args) => {
+      if (thisArg === outer) thisArg = shadow;
+      return getTraceable(ctx, Reflect.apply(target, thisArg, args));
+    }
+  });
+  return proxy;
+}
+function createTraceable(ctx, value, tracker) {
+  const caller = ctx[symbols.shadow] ?? ctx;
+  if (ctx[symbols.shadow]) {
+    ctx = Object.getPrototypeOf(ctx);
+  }
+  const proxy = new Proxy(value, {
+    get: (target, prop, receiver) => {
+      if (prop === symbols.original) return target;
+      if (prop === symbols.caller) return caller;
+      if (prop === tracker.property) return ctx;
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (tracker.associate && ctx.reflect.props[`${tracker.associate}.${prop}`]) {
+        return Reflect.get(ctx, `${tracker.associate}.${prop}`, withProp(ctx, symbols.receiver, receiver));
+      }
+      let shadow;
+      let innerValue;
+      const desc = getPropertyDescriptor(target, prop);
+      if (desc?.value !== void 0) {
+        innerValue = desc.value;
+      } else {
+        shadow = createShadow(ctx, target, tracker.property, receiver);
+        innerValue = Reflect.get(target, prop, shadow);
+      }
+      const innerTracker = innerValue?.[symbols.tracker];
+      if (innerTracker) {
+        return createTraceable(ctx, innerValue, innerTracker);
+      } else if (!tracker.noShadow && typeof innerValue === "function") {
+        shadow ??= createShadow(ctx, target, tracker.property, receiver);
+        return createShadowMethod(ctx, innerValue, receiver, shadow);
+      } else {
+        return innerValue;
+      }
+    },
+    set: (target, prop, value2, receiver) => {
+      if (prop === symbols.original || prop === symbols.caller || prop === tracker.property) return false;
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value2, receiver);
+      }
+      if (tracker.associate && ctx.reflect.props[`${tracker.associate}.${prop}`]) {
+        return Reflect.set(ctx, `${tracker.associate}.${prop}`, value2, withProp(ctx, symbols.receiver, receiver));
+      }
+      const shadow = createShadow(ctx, target, tracker.property, receiver);
+      return Reflect.set(target, prop, value2, shadow);
+    },
+    apply: (target, thisArg, args) => {
+      const receiver = tracker.noShadow ? proxy : createShadow(ctx, target, tracker.property, proxy);
+      return applyTraceable(receiver, target, thisArg, args);
+    }
+  });
+  return proxy;
+}
+function applyTraceable(proxy, value, thisArg, args) {
+  if (!value[symbols.invoke]) return Reflect.apply(value, thisArg, args);
+  return value[symbols.invoke].apply(proxy, args);
+}
+function createCallable(name, proto, tracker) {
+  const self = function(...args) {
+    const proxy = createTraceable(self.ctx, self, tracker);
+    return Reflect.apply(proxy, this, args);
+  };
+  Object.defineProperty(self, "name", { value: name, configurable: true, writable: true });
+  return Object.setPrototypeOf(self, proto);
+}
+function handleError(info, reason, getOuterStack) {
+  const innerLines = info.error.stack.split("\n");
+  if (typeof reason?.stack !== "string") {
+    const outerError = new Error(reason);
+    const lines2 = outerError.stack.split("\n");
+    lines2.splice(1, Infinity, ...getOuterStack());
+    outerError.stack = lines2.join("\n");
+    throw outerError;
+  }
+  const lines = reason.stack.split("\n");
+  const index = lines.indexOf(innerLines[2]);
+  if (index === -1) throw reason;
+  lines.splice(index - info.offset, Infinity, ...getOuterStack());
+  reason.stack = lines.join("\n");
+  throw reason;
+}
+function composeError(callback, getOuterStack = buildOuterStack()) {
+  const info = { offset: 1, error: new Error() };
+  try {
+    const result = callback(info);
+    if (isObject2(result) && "then" in result) {
+      return result.then(void 0, (reason) => handleError(info, reason, getOuterStack));
+    }
+    return result;
+  } catch (reason) {
+    handleError(info, reason, getOuterStack);
+  }
+}
+function buildOuterStack(offset = 0) {
+  const outerError = new Error();
+  return () => outerError.stack.split("\n").slice(3 + offset);
+}
+
+// packages/core/src/events.ts
+function isBailed(value) {
+  return value !== null && value !== false && value !== void 0;
+}
+var EventsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+    this.on("internal/listener", function(name, listener, options) {
+      if (name === "internal/update" && !options.global) {
+        const hooks = this.fiber._hooks["internal/update"] ??= new DisposableList();
+        const method = options.prepend ? "unshift" : "push";
+        return hooks[method](listener);
+      }
+    });
+    this.on("internal/update", function(config2, noSave, next) {
+      const cbs = [...this.fiber._hooks["internal/update"] ?? []];
+      const _next = () => {
+        const cb = cbs.shift() ?? next;
+        return cb.call(this, config2, noSave, _next);
+      };
+      return _next();
+    }, { global: true, prepend: true });
+  }
+  ctx;
+  _hooks = /* @__PURE__ */ Object.create(null);
+  _resolve(type, args) {
+    const thisArg = typeof args[0] === "object" || typeof args[0] === "function" ? args.shift() : null;
+    const name = args.shift();
+    if (!name.startsWith("internal/") && this._hooks["internal/dispatch"]?.length) {
+      this.emit("internal/dispatch", type, name, args, thisArg);
+    }
+    const filter = thisArg?.[Context.filter];
+    return [thisArg, (this._hooks[name] || []).filter((hook) => hook.global || !filter || filter.call(thisArg, hook.ctx)).map((hook) => hook.callback)];
+  }
+  dispatch(type, args) {
+    const [thisArg, callbacks] = this._resolve(type, args);
+    return callbacks.map((callback) => callback.bind(thisArg));
+  }
+  async parallel(...args) {
+    const [thisArg, callbacks] = this._resolve("parallel", args);
+    const results = await Promise.allSettled(callbacks.map(async (callback) => Reflect.apply(callback, thisArg, args)));
+    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (errors.length) throw new AggregateError(errors);
+  }
+  emit(...args) {
+    const [thisArg, callbacks] = this._resolve("emit", args);
+    for (const callback of callbacks) Reflect.apply(callback, thisArg, args);
+  }
+  async serial(...args) {
+    const [thisArg, callbacks] = this._resolve("serial", args);
+    for (const callback of callbacks) {
+      const result = await Reflect.apply(callback, thisArg, args);
+      if (isBailed(result)) return result;
+    }
+  }
+  bail(...args) {
+    const [thisArg, callbacks] = this._resolve("bail", args);
+    for (const callback of callbacks) {
+      const result = Reflect.apply(callback, thisArg, args);
+      if (isBailed(result)) return result;
+    }
+  }
+  waterfall(...args) {
+    const [thisArg, callbacks] = this._resolve("waterfall", args);
+    const inner = args.pop();
+    const next = () => {
+      const callback = callbacks.shift();
+      return callback ? Reflect.apply(callback, thisArg, args) : inner(...args);
+    };
+    args.push(next);
+    return next();
+  }
+  async waterfallAsync(...args) {
+    const [thisArg, callbacks] = this._resolve("waterfallAsync", args);
+    const inner = args.pop();
+    const next = async () => {
+      const callback = callbacks.shift();
+      return callback ? await Reflect.apply(callback, thisArg, args) : inner(...args);
+    };
+    args.push(next);
+    return next();
+  }
+  register(label, hooks, callback, options) {
+    const method = options.prepend ? "unshift" : "push";
+    return this.ctx.fiber.effect(() => {
+      hooks[method]({ ctx: this.ctx, callback, ...options });
+      return () => this.unregister(hooks, callback);
+    }, label);
+  }
+  unregister(hooks, callback) {
+    const index = hooks.findIndex((hook) => hook.callback === callback);
+    if (index >= 0) {
+      hooks.splice(index, 1);
+      return true;
+    }
+  }
+  on(name, listener, options = {}) {
+    if (typeof options !== "object") {
+      options = { prepend: options };
+    }
+    this.ctx.fiber.assertActive();
+    listener = this.ctx.reflect.bind(listener);
+    const result = this.bail(this.ctx, "internal/listener", name, listener, options);
+    if (result) return result;
+    const hooks = this._hooks[name] ??= [];
+    return this.register(`ctx.on(${JSON.stringify(name)})`, hooks, listener, options);
+  }
+  once(name, listener, options = {}) {
+    const dispose = this.on(name, function(...args) {
+      dispose();
+      return listener.apply(this, args);
+    }, options);
+    return dispose;
+  }
+};
+
+// packages/core/src/fiber.ts
+var INACTIVE = "__INACTIVE__";
+var ValidationError = class extends TypeError {
+  name = "ValidationError";
+  constructor(issues) {
+    super("invalid config:\n" + issues.map((issue2) => {
+      if (issue2.path) {
+        return `  - ${issue2.message} (at ${issue2.path.join(".")})`;
+      }
+      return `  - ${issue2.message}`;
+    }).join("\n"));
+  }
+};
+function resolveConfig(runtime, config2) {
+  if (!runtime.Config) return config2;
+  const schema = runtime.Config;
+  if (typeof schema === "function") return schema(config2);
+  const validate2 = schema?.["~standard"]?.validate;
+  if (typeof validate2 === "function") {
+    const result = validate2(config2);
+    if ("then" in result) {
+      throw new TypeError("Async config validation is not supported");
+    }
+    if (result.issues) {
+      throw new ValidationError(result.issues);
+    }
+    return result.value;
+  }
+  return config2;
+}
+var CordisErrorCode = {
+  INACTIVE_EFFECT: "cannot create effect on inactive context"
+};
+var CordisError = class extends Error {
+  constructor(code, message) {
+    super(message ?? CordisErrorCode[code]);
+    this.code = code;
+  }
+  code;
+};
+var Fiber = class {
+  constructor(parent, config2, inject, runtime, getOuterStack) {
+    this.parent = parent;
+    this.inject = inject;
+    this.runtime = runtime;
+    const collect = (dispose) => {
+      this._disposables.push(dispose);
+    };
+    if (runtime) {
+      this.uid = parent.registry.counter;
+      this.ctx = this.context = parent.extend({ fiber: this });
+      const injectEntries = Object.entries(this.inject);
+      if (injectEntries.length) {
+        this.ctx[symbols.intercept] = Object.create(parent[symbols.intercept]);
+        for (const [name, config3] of injectEntries) {
+          if (isNullable(config3)) continue;
+          this.ctx[symbols.intercept][name] = config3;
+        }
+      }
+      this._runner = {
+        epoch: INACTIVE,
+        getOuterStack,
+        execute: () => {
+          if (isConstructor(runtime.callback)) {
+            const instance = new runtime.callback(this.ctx, this.config);
+            for (const hook of instance?.[symbols.initHooks] ?? []) {
+              hook();
+            }
+            return instance?.[symbols.init]?.();
+          } else {
+            return runtime.callback(this.ctx, this.config);
+          }
+        },
+        collect
+      };
+      this.context.emit(this, "internal/plugin");
+      for (const name of Object.keys(this.inject)) {
+        this._checkImpl(name);
+      }
+      this.dispose = parent.fiber.effect(() => {
+        const remove = runtime.fibers.push(this);
+        try {
+          this.config = resolveConfig(runtime, config2);
+          this._refresh();
+        } catch (error2) {
+          this.ctx.logger.error(error2);
+          this._error = error2;
+        }
+        return async () => {
+          this.uid = null;
+          this.context.emit(this, "internal/plugin");
+          if (this.ctx.registry.has(runtime.callback)) {
+            remove();
+            if (!runtime.fibers.length) {
+              this.ctx.registry.delete(runtime.callback);
+            }
+          }
+          this._setEpoch(INACTIVE);
+          while (this.inertia) {
+            await this.inertia;
+          }
+        };
+      }, "ctx.plugin()");
+    } else {
+      this.uid = 0;
+      this.ctx = this.context = parent;
+      this.state = 2 /* ACTIVE */;
+      this.store = /* @__PURE__ */ Object.create(null);
+      this._runner = {
+        epoch: "",
+        getOuterStack,
+        execute: () => {
+        },
+        collect
+      };
+      this.dispose = () => this.restart();
+    }
+  }
+  parent;
+  inject;
+  runtime;
+  uid;
+  ctx;
+  config;
+  state = 0 /* PENDING */;
+  dispose;
+  store;
+  inertia;
+  _hooks = /* @__PURE__ */ Object.create(null);
+  _disposables = new DisposableList();
+  context;
+  _error = void 0;
+  _runner;
+  _store = /* @__PURE__ */ Object.create(null);
+  _restarting;
+  get name() {
+    if (this.runtime?.name) return this.runtime.name;
+    let fiber = this.parent.fiber;
+    while (fiber !== fiber.parent.fiber) {
+      if (fiber.runtime?.name) return fiber.runtime.name;
+      fiber = fiber.parent.fiber;
+    }
+    return "root";
+  }
+  assertActive() {
+    if (this.uid !== null) return;
+    throw new CordisError("INACTIVE_EFFECT");
+  }
+  _execute(runner) {
+    const oldEpoch = runner.epoch;
+    return composeError((info) => {
+      const safeCollect = (dispose) => {
+        if (typeof dispose === "function") {
+          runner.collect(dispose);
+        } else if (!isNullable(dispose)) {
+          throw new TypeError("Invalid effect");
+        }
+      };
+      const effect = runner.execute.call(this);
+      if (typeof effect === "function") {
+        return runner.collect(effect);
+      } else if (isNullable(effect)) {
+        return;
+      } else if (!isObject2(effect)) {
+        throw new TypeError("Invalid effect");
+      } else if ("then" in effect) {
+        return effect.then(safeCollect);
+      } else if (Symbol.iterator in effect) {
+        info.error = new Error();
+        const iter = effect[Symbol.iterator]();
+        while (true) {
+          const result = iter.next();
+          safeCollect(result.value);
+          if (result.done) return;
+        }
+      } else if (Symbol.asyncIterator in effect) {
+        const iter = effect[Symbol.asyncIterator]();
+        return (async () => {
+          await Promise.resolve();
+          info.error = new Error();
+          while (true) {
+            if (runner.epoch !== oldEpoch) return;
+            const result = await iter.next();
+            safeCollect(result.value);
+            if (result.done) return;
+          }
+        })();
+      } else {
+        throw new TypeError("Invalid effect");
+      }
+    }, runner.getOuterStack);
+  }
+  effect(execute, label = "anonymous") {
+    this.assertActive();
+    const disposables = [];
+    const dispose = () => {
+      let task2;
+      for (const dispose2 of disposables.splice(0).reverse()) {
+        if (task2) {
+          task2 = task2.then(dispose2);
+        } else {
+          const result = dispose2();
+          if (isObject2(result) && "then" in result) {
+            task2 = result;
+          }
+        }
+      }
+      return task2;
+    };
+    const meta2 = { label, children: [] };
+    const runner = {
+      execute,
+      epoch: true,
+      collect: (dispose2) => {
+        disposables.push(dispose2);
+        this._disposables.delete(dispose2);
+        if (dispose2[symbols.effect]) {
+          meta2.children.push(dispose2[symbols.effect]);
+        }
+      },
+      getOuterStack: buildOuterStack()
+    };
+    let task;
+    try {
+      task = this._execute(runner);
+    } catch (reason) {
+      dispose();
+      throw reason;
+    }
+    task?.catch(dispose).catch((error2) => this.ctx.logger.error(error2));
+    const wrapper = Object.defineProperty(() => {
+      if (!runner.epoch) return;
+      runner.epoch = false;
+      return task ? task.then(dispose) : dispose();
+    }, symbols.effect, { value: meta2 });
+    const disposeAsync = () => {
+      if (!runner.epoch) return;
+      runner.epoch = false;
+      return dispose();
+    };
+    wrapper.then = async (onFulfilled, onRejected) => {
+      return Promise.resolve(task).then(() => disposeAsync).then(onFulfilled, onRejected);
+    };
+    disposables.push(this._disposables.push(wrapper));
+    return wrapper;
+  }
+  getEffects() {
+    return [...this._disposables].map((dispose) => dispose[symbols.effect]).filter(Boolean);
+  }
+  _getState() {
+    if (this.uid === null) return 4 /* DISPOSED */;
+    if (this._error) return 3 /* FAILED */;
+    if (this._runner.epoch !== INACTIVE) return 2 /* ACTIVE */;
+    return 0 /* PENDING */;
+  }
+  _updateState(callback) {
+    const oldState = this.state;
+    this.state = callback?.() ?? this._getState();
+    if (oldState === this.state) return;
+    this.context.emit(this, "internal/status", oldState);
+    if (oldState !== 2 /* ACTIVE */ && this.state !== 2 /* ACTIVE */) return;
+    for (const key of Reflect.ownKeys(this.ctx.reflect.store)) {
+      const impl = this.ctx.reflect.store[key];
+      if (!impl) continue;
+      if (impl.fiber !== this) continue;
+      this.ctx.reflect.notify([impl.name]);
+    }
+  }
+  _checkImpl(name) {
+    const impl = this.ctx.reflect._getImpl(name, true);
+    if (!impl) return delete this._store[name];
+    try {
+      if (impl.check && !impl.check.call(getTraceable(this.ctx, impl.value))) {
+        return delete this._store[name];
+      }
+    } catch (error2) {
+      impl.fiber.ctx.logger.error(error2);
+      return delete this._store[name];
+    }
+    this._store[name] = impl;
+  }
+  _refresh() {
+    let epoch = "";
+    for (const name of Object.keys(this.inject)) {
+      const impl = this._store[name];
+      if (!impl) {
+        epoch = INACTIVE;
+        break;
+      }
+      epoch += ":" + impl.fiber.uid;
+    }
+    this._setEpoch(epoch);
+  }
+  _setEpoch(epoch) {
+    const oldEpoch = this._runner.epoch;
+    if (epoch === oldEpoch) return;
+    this._runner.epoch = epoch;
+    if (this.inertia) return;
+    this._updateState(() => {
+      if (epoch !== INACTIVE && oldEpoch === INACTIVE) {
+        this.inertia = this._reload();
+        return 1 /* LOADING */;
+      } else {
+        this.inertia = this._unload();
+        return 5 /* UNLOADING */;
+      }
+    });
+  }
+  async _reload() {
+    this.store = { ...this._store };
+    const oldEpoch = this._runner.epoch;
+    try {
+      await Promise.resolve();
+      await this._execute(this._runner);
+    } catch (reason) {
+      this.ctx.logger.error(reason);
+      this._error = reason;
+      this._runner.epoch = INACTIVE;
+    }
+    this._updateState(() => {
+      if (this._runner.epoch === oldEpoch) {
+        this.inertia = void 0;
+      } else {
+        this.inertia = this._unload();
+        return 5 /* UNLOADING */;
+      }
+    });
+  }
+  async _unload() {
+    await Promise.all(this._disposables.clear().map(async (dispose) => {
+      try {
+        await composeError(async (info) => {
+          await Promise.resolve();
+          info.error = new Error();
+          await dispose();
+        }, this._runner.getOuterStack);
+      } catch (reason) {
+        this.ctx.logger.error(reason);
+      }
+    }));
+    this.store = void 0;
+    this._updateState(() => {
+      if (this._runner.epoch === INACTIVE) {
+        this.inertia = void 0;
+      } else {
+        this.inertia = this._reload();
+        return 1 /* LOADING */;
+      }
+    });
+  }
+  async await() {
+    while (this.inertia || this._restarting) {
+      await Promise.all([this.inertia, this._restarting].filter((task) => !!task));
+    }
+    if (this._error) throw this._error;
+    return this;
+  }
+  async restart() {
+    const fiber = this.ctx.fiber;
+    fiber.assertActive();
+    if (fiber._restarting) return fiber._restarting.then(() => void 0);
+    let resolve3;
+    const restarting = new Promise((resolvePromise) => {
+      resolve3 = resolvePromise;
+    });
+    fiber._restarting = restarting;
+    try {
+      await this._runRestart(fiber);
+    } finally {
+      fiber._restarting = void 0;
+      resolve3();
+    }
+  }
+  async _runRestart(fiber) {
+    if (fiber.inertia) {
+      fiber._setEpoch(INACTIVE);
+      while (fiber.inertia) await fiber.inertia;
+    }
+    fiber._setEpoch(INACTIVE);
+    fiber._refresh();
+    while (fiber.inertia) await fiber.inertia;
+  }
+  update(config2, noSave = false) {
+    const fiber = this.ctx.fiber;
+    fiber.assertActive();
+    config2 = resolveConfig(fiber.runtime, config2);
+    fiber.context.waterfall(fiber.context, "internal/update", config2, noSave, () => {
+      fiber.config = config2;
+      fiber._error = void 0;
+      return fiber.restart();
+    });
+  }
+};
+
+// packages/core/src/logger.ts
+var Logger = class {
+  constructor(options, service) {
+    this.service = service;
+    this.name = options.name;
+    this.level = options.level;
+    this.error = this._method("error");
+    this.info = this._method("info");
+    this.warn = this._method("warn");
+    this.debug = this._method("debug");
+  }
+  service;
+  name;
+  level;
+  error;
+  info;
+  warn;
+  debug;
+  _method(type) {
+    return (...args) => this.service._log({ name: this.name, type, args });
+  }
+};
+var LoggerService = class {
+  buffer = [];
+  ctx;
+  _snMessage = 0;
+  _snExporter = 0;
+  exporters = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    const tracker = {
+      property: "ctx",
+      noShadow: true
+    };
+    const self = createCallable("logger", joinPrototype(Object.getPrototypeOf(this), Function.prototype), tracker);
+    Object.assign(self, this);
+    self.ctx = ctx;
+    Object.defineProperty(self, symbols.tracker, { value: tracker });
+    self.exporter({
+      export: (message) => {
+        self.buffer.push(message);
+      }
+    });
+    ctx.reflect.provide("logger", self);
+    return self;
+  }
+  exporter(exporter) {
+    return this.ctx.fiber.effect(() => {
+      const id = ++this._snExporter;
+      this.exporters.set(id, exporter);
+      return () => this.exporters.delete(id);
+    }, "ctx.logger.exporter()");
+  }
+  [symbols.invoke](name) {
+    const caller = this[symbols.caller];
+    const fiber = (caller ?? this.ctx).fiber;
+    return new Logger({
+      name: name ?? fiber.name
+    }, this);
+  }
+  _log(message) {
+    const sn = ++this._snMessage;
+    const ts = Date.now();
+    for (const exporter of this.exporters.values()) {
+      if (exporter.level != null && exporter.level < 0) continue;
+      exporter.export({ sn, ts, ...message });
+    }
+  }
+  error(...args) {
+    return this().error(...args);
+  }
+  info(...args) {
+    return this().info(...args);
+  }
+  warn(...args) {
+    return this().warn(...args);
+  }
+  debug(...args) {
+    return this().debug(...args);
+  }
+};
+
+// packages/core/src/reflect.ts
+function enhanceError(error2) {
+  const lines = error2.stack.split("\n");
+  lines.splice(0, 2, `Error: ${error2.message}`);
+  error2.stack = lines.join("\n");
+  return error2;
+}
+var RESERVED_WORDS = ["prototype", "then"];
+function isSpecialProperty(prop) {
+  return typeof prop === "symbol" || RESERVED_WORDS.includes(prop) || parseInt(prop).toString() === prop || prop.startsWith("_");
+}
+var ReflectService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+    this.mixin("reflect", ["get", "set", "provide", "accessor", "mixin"]);
+    this.mixin("fiber", ["runtime", "effect"]);
+    this.mixin("registry", ["inject", "plugin"]);
+    this.mixin("events", [
+      "on",
+      "once",
+      "parallel",
+      "emit",
+      "serial",
+      "bail",
+      "waterfall",
+      "waterfallAsync"
+    ]);
+  }
+  ctx;
+  static handler = {
+    get: (target, prop, ctx) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.get(target, prop, ctx);
+      }
+      if (Reflect.has(target, prop)) {
+        return getTraceable(ctx, Reflect.get(target, prop, ctx));
+      }
+      const error2 = new Error(`cannot get property "${String(prop)}" without inject`);
+      try {
+        const def = target.reflect.props[prop];
+        if (def?.type === "accessor") {
+          return def.get.call(ctx, ctx[symbols.receiver], error2);
+        }
+        if (!ctx.fiber.runtime) return ctx.reflect.get(prop, false);
+        return ctx.events.waterfall(ctx, "internal/get", prop, error2, () => {
+          const key = target[symbols.isolate][prop];
+          let fiber = (ctx[symbols.shadow] ?? ctx).fiber;
+          while (true) {
+            const impl = fiber.store?.[prop];
+            if (impl) return getTraceable(ctx, impl.value);
+            if (prop in fiber.inject) {
+              error2.message = `cannot get required service "${String(prop)}" in inactive context`;
+              throw error2;
+            }
+            if (!fiber.runtime) throw error2;
+            if (fiber.parent[symbols.isolate][prop] !== key) throw error2;
+            fiber = fiber.parent.fiber;
+          }
+        });
+      } catch (e) {
+        throw e === error2 ? enhanceError(e) : e;
+      }
+    },
+    set: (target, prop, value, ctx) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.set(target, prop, value, ctx);
+      }
+      const error2 = new Error(`cannot set property "${String(prop)}" without provide`);
+      const def = target.reflect.props[prop];
+      try {
+        if (def?.type === "accessor") {
+          if (!def.set) return false;
+          return def.set.call(ctx, value, ctx[symbols.receiver], error2);
+        }
+        if (!def && !ctx.fiber.runtime) {
+          return Reflect.set(target, prop, value, ctx);
+        }
+        return ctx.events.waterfall(ctx, "internal/set", prop, value, error2, () => {
+          if (!def) throw error2;
+          return ctx.reflect.set(prop, value);
+        });
+      } catch (e) {
+        throw e === error2 ? enhanceError(e) : e;
+      }
+    },
+    has: (target, prop) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.has(target, prop);
+      }
+      if (Reflect.has(target, prop)) return true;
+      return !!target.reflect.props[prop];
+    }
+  };
+  store = /* @__PURE__ */ Object.create(null);
+  props = /* @__PURE__ */ Object.create(null);
+  get(name, strict = true) {
+    return getTraceable(this.ctx, this._getImpl(name, strict)?.value);
+  }
+  _getImpl(name, strict = true) {
+    const key = this.ctx[symbols.isolate][name];
+    const impl = key && this.store[key];
+    if (!impl) return;
+    if (strict && impl.fiber.state !== 2 /* ACTIVE */) return;
+    return impl;
+  }
+  set(name, value) {
+    const key = this.ctx[symbols.isolate][name];
+    const impl = key && this.store[key];
+    if (!impl) {
+      throw new Error(`cannot set property "${name}" without provide`);
+    }
+    if (impl.fiber !== this.ctx.fiber) {
+      throw new Error(`cannot set property "${name}" in multiple fibers`);
+    }
+    impl.value = value;
+    return true;
+  }
+  provide(name, value, check) {
+    return this.ctx.fiber.effect(() => {
+      if (!this.props[name]) {
+        this.props[name] = { type: "service" };
+      } else if (this.props[name].type !== "service") {
+        throw new Error(`property "${name}" is already declared as ${this.props[name].type}`);
+      }
+      this.props[name] = { type: "service" };
+      this.ctx.root[symbols.isolate][name] ??= Symbol(name);
+      const key = this.ctx[symbols.isolate][name];
+      const impl = {
+        name,
+        value,
+        fiber: this.ctx.fiber,
+        ...check ? { check } : {}
+      };
+      if (key && this.store[key]) {
+        throw new Error(`service "${name}" has been registered at <${this.store[key].fiber.name}>`);
+      }
+      this.store[key] = impl;
+      this.ctx.fiber.store[name] = impl;
+      if (this.ctx.fiber.state === 2 /* ACTIVE */) {
+        this.notify([name]);
+      }
+      return async () => {
+        delete this.store[key];
+        const fibers = this.notify([name]);
+        await Promise.allSettled(fibers.map((fiber) => fiber.await()));
+        delete this.ctx.fiber.store[name];
+      };
+    }, `ctx.provide(${JSON.stringify(name)})`);
+  }
+  notify(names, filter = (ctx, name) => ctx[symbols.isolate][name] === this.ctx[symbols.isolate][name]) {
+    const fibers = [];
+    for (const runtime of this.ctx.registry.values()) {
+      for (const fiber of runtime.fibers) {
+        let hasUpdate = false;
+        for (const name of names) {
+          if (!(name in fiber.inject)) continue;
+          if (!filter(fiber.ctx, name)) continue;
+          hasUpdate = true;
+          fiber._checkImpl(name);
+        }
+        if (!hasUpdate) continue;
+        fiber._refresh();
+        fibers.push(fiber);
+      }
+    }
+    for (const name of names) {
+      const self = Object.create(this.ctx);
+      self[symbols.filter] = (target) => filter(target, name);
+      this.ctx.events.emit(self, "internal/service", name, this._getImpl(name, false)?.value);
+    }
+    return fibers;
+  }
+  accessor(name, options) {
+    return this.ctx.fiber.effect(() => {
+      if (name in this.props) {
+        throw new Error(`property "${name}" is already declared as ${this.props[name].type}`);
+      }
+      this.props[name] = { type: "accessor", ...options };
+      return () => delete this.props[name];
+    }, `ctx.accessor(${JSON.stringify(name)})`);
+  }
+  mixin(source, mixins) {
+    return this.ctx.fiber.effect(() => {
+      const entries = Array.isArray(mixins) ? mixins.map((key) => [key, key]) : Object.entries(mixins);
+      const getTarget = (target) => target[source];
+      return entries.map(([key, value]) => {
+        return this.accessor(value, {
+          get(receiver) {
+            const service = getTarget(this);
+            if (service == null) return service;
+            const mixin = receiver ? withProps(receiver, service) : service;
+            const result = Reflect.get(service, key, mixin);
+            if (typeof result !== "function") return result;
+            return result.bind(mixin ?? service);
+          },
+          set(value2, receiver) {
+            const service = getTarget(this);
+            const mixin = receiver ? withProps(receiver, service) : service;
+            return Reflect.set(service, key, value2, mixin);
+          }
+        });
+      });
+    }, `ctx.mixin(${JSON.stringify(source)})`);
+  }
+  trace(value) {
+    return getTraceable(this.ctx, value);
+  }
+  bind(callback) {
+    return new Proxy(callback, {
+      apply: (target, thisArg, args) => {
+        return Reflect.apply(target, this.trace(thisArg), args.map((arg) => this.trace(arg)));
+      },
+      construct: (target, args, newTarget) => {
+        return Reflect.construct(target, args.map((arg) => this.trace(arg)), newTarget);
+      }
+    });
+  }
+};
+
+// packages/core/src/registry.ts
+function isApplicable(object3) {
+  return object3 && typeof object3 === "object" && typeof object3.apply === "function";
+}
+function resolveInject(inject, result = /* @__PURE__ */ Object.create(null)) {
+  if (!inject) return result;
+  if (Array.isArray(inject)) {
+    for (const name of inject) {
+      result[name] = null;
+    }
+  } else if (Reflect.has(inject, symbols.checkProto)) {
+    Object.assign(result, resolveInject(Object.getPrototypeOf(inject)));
+    for (const name of Object.keys(inject)) {
+      result[name] = inject[name] ?? null;
+    }
+  } else {
+    for (const name of Object.keys(inject)) {
+      result[name] = inject[name] ?? null;
+    }
+  }
+  return result;
+}
+var RegistryService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+  }
+  ctx;
+  _counter = 0;
+  _internal = /* @__PURE__ */ new Map();
+  get counter() {
+    return ++this._counter;
+  }
+  get size() {
+    return this._internal.size;
+  }
+  resolve(plugin) {
+    try {
+      if (typeof plugin === "function") return plugin;
+      if (isApplicable(plugin)) return plugin.apply;
+    } catch {
+    }
+  }
+  get(plugin) {
+    const key = this.resolve(plugin);
+    return key && this._internal.get(key);
+  }
+  has(plugin) {
+    const key = this.resolve(plugin);
+    return !!key && this._internal.has(key);
+  }
+  delete(plugin) {
+    const key = this.resolve(plugin);
+    const runtime = key && this._internal.get(key);
+    if (!runtime) return;
+    this._internal.delete(key);
+    for (const fiber of [...runtime.fibers]) {
+      fiber.dispose();
+    }
+    return runtime;
+  }
+  keys() {
+    return this._internal.keys();
+  }
+  values() {
+    return this._internal.values();
+  }
+  entries() {
+    return this._internal.entries();
+  }
+  forEach(callback) {
+    return this._internal.forEach(callback);
+  }
+  inject(inject, callback) {
+    const name = callback.name || void 0;
+    return this.plugin(Object.assign(
+      { inject, apply: callback },
+      name ? { name } : {}
+    ));
+  }
+  plugin(plugin, config2, getOuterStack = buildOuterStack()) {
+    const callback = this.resolve(plugin);
+    if (!callback) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof plugin);
+    this.ctx.fiber.assertActive();
+    let runtime = this._internal.get(callback);
+    if (!runtime) {
+      let name = plugin.name;
+      if (name === "apply") name = void 0;
+      runtime = {
+        callback,
+        fibers: new DisposableList(),
+        ...name ? { name } : {},
+        ...plugin.Config ? { Config: plugin.Config } : {}
+      };
+      this._internal.set(callback, runtime);
+    }
+    const fiber = new Fiber(this.ctx, config2, resolveInject(plugin.inject), runtime, getOuterStack);
+    const wrapped = Object.create(fiber);
+    wrapped.then = (onFulfilled, onRejected) => {
+      return fiber.await().then(onFulfilled, onRejected);
+    };
+    return wrapped;
+  }
+};
+
+// packages/core/src/context.ts
+var Context = class _Context {
+  static effect = symbols.effect;
+  static filter = symbols.filter;
+  static isolate = symbols.isolate;
+  static intercept = symbols.intercept;
+  static marker = /* @__PURE__ */ Symbol.for("tnega.is");
+  static is(value) {
+    return !!value?.[_Context.marker];
+  }
+  static {
+    _Context.prototype[_Context.marker] = true;
+  }
+  constructor() {
+    this[symbols.isolate] = /* @__PURE__ */ Object.create(null);
+    this[symbols.intercept] = /* @__PURE__ */ Object.create(null);
+    const self = new Proxy(this, ReflectService.handler);
+    this.root = self;
+    this.baseUrl = void 0;
+    this.fiber = new Fiber(self, {}, /* @__PURE__ */ Object.create(null), null, () => []);
+    this.reflect = new ReflectService(self);
+    this.registry = new RegistryService(self);
+    this.events = new EventsService(self);
+    this.logger = new LoggerService(self);
+    this.fiber._disposables.clear();
+    return self;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Context <${this.fiber.name}>`;
+  }
+  extend(meta2 = {}) {
+    const shadow = Reflect.getOwnPropertyDescriptor(this, symbols.shadow)?.value;
+    const self = Object.create(getTraceable(this, this));
+    for (const prop of Reflect.ownKeys(meta2)) {
+      Object.defineProperty(self, prop, Reflect.getOwnPropertyDescriptor(meta2, prop));
+    }
+    if (!shadow) return self;
+    return Object.assign(Object.create(self), { [symbols.shadow]: shadow });
+  }
+  isolate(name, label) {
+    const shadow = Object.create(this[symbols.isolate]);
+    shadow[name] = label ?? Symbol(name);
+    return this.extend({ [symbols.isolate]: shadow });
+  }
+  intercept(name, config2) {
+    const intercept = Object.create(this[symbols.intercept]);
+    intercept[name] = config2;
+    return this.extend({ [symbols.intercept]: intercept });
+  }
+};
+
+// packages/core/src/service.ts
+var Service = class _Service {
+  constructor(ctx, name) {
+    this.ctx = ctx;
+    name ??= this.constructor.provide;
+    const tracker = {
+      associate: name,
+      property: "ctx"
+    };
+    const self = this[symbols.invoke] ? createCallable(name, joinPrototype(Object.getPrototypeOf(this), Function.prototype), tracker) : this;
+    self.ctx = ctx;
+    self.name = name;
+    Object.defineProperty(self, symbols.tracker, { value: tracker });
+    self.ctx.reflect.provide(name, self, this[symbols.check]);
+    return self;
+  }
+  ctx;
+  static init = symbols.init;
+  static check = symbols.check;
+  static config = symbols.config;
+  static invoke = symbols.invoke;
+  static extend = symbols.extend;
+  static tracker = symbols.tracker;
+  static resolveConfig = symbols.resolveConfig;
+  name;
+  [symbols.filter](ctx) {
+    return ctx[symbols.isolate][this.name] === this.ctx[symbols.isolate][this.name];
+  }
+  [symbols.extend](props) {
+    let self;
+    if (this[_Service.invoke]) {
+      self = createCallable(this.name, this, this[symbols.tracker]);
+    } else {
+      self = Object.create(this);
+    }
+    return Object.assign(self, props);
+  }
+  [symbols.resolveConfig](base, head) {
+    let intercept = this.ctx[symbols.intercept];
+    const configs = [];
+    while (this.name in intercept) {
+      if (Object.hasOwn(intercept, this.name)) {
+        configs.unshift(intercept[this.name]);
+      }
+      intercept = Object.getPrototypeOf(intercept);
+    }
+    if (base) configs.unshift(base);
+    if (head) configs.push(head);
+    if (this["Config"]?.merge) {
+      return this["Config"].merge(...configs);
+    } else {
+      return Object.assign({}, ...configs);
+    }
+  }
+  static [Symbol.hasInstance](instance) {
+    if (!instance) return false;
+    let constructor = instance.constructor;
+    while (constructor) {
+      constructor = constructor.prototype?.constructor;
+      if (constructor === this) return true;
+      constructor &&= Object.getPrototypeOf(constructor);
+    }
+    return false;
+  }
+};
+
 // packages/coding-agent/src/codingAgent.ts
 var dynamic = (ctx) => ctx;
 var CODING_SYSTEM_PROMPT = `You are Tnega, a coding agent running in a workspace session.