plugin-agent-orchestrator 1.0.19 → 1.0.21

package/dist/server/services/AgentLoopController.js

@@ -29,13 +29,20 @@ __export(AgentLoopController_exports, {
   AgentLoopController: () => AgentLoopController
 });
 module.exports = __toCommonJS(AgentLoopController_exports);
+var import_CircuitBreaker = require("./CircuitBreaker");
 var import_crypto = require("crypto");
+var import_ctx_utils = require("../utils/ctx-utils");
 const DEFAULT_POLICY = {
   maxIterations: 20,
   maxStepAttempts: 2,
   allowReplan: true,
   requireVerification: true,
-  stopOnApprovalRequired: true
+  stopOnApprovalRequired: true,
+  maxContextTokens: 4e3,
+  contextSummaryStrategy: "last_n",
+  includeToolResults: false,
+  includeStepOutputs: true,
+  maxConcurrency: 5
 };
 const TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "rejected", "canceled"]);
 const TERMINAL_STEP_STATUSES = /* @__PURE__ */ new Set(["succeeded", "skipped"]);
@@ -54,50 +61,21 @@ function normalizePolicy(policy) {
   next.allowReplan = next.allowReplan !== false;
   next.requireVerification = next.requireVerification !== false;
   next.stopOnApprovalRequired = next.stopOnApprovalRequired !== false;
+  next.maxContextTokens = next.maxContextTokens || DEFAULT_POLICY.maxContextTokens;
+  next.contextSummaryStrategy = next.contextSummaryStrategy || DEFAULT_POLICY.contextSummaryStrategy;
+  next.includeToolResults = next.includeToolResults !== false;
+  next.includeStepOutputs = next.includeStepOutputs !== false;
+  next.maxConcurrency = Math.max(1, Number(next.maxConcurrency || DEFAULT_POLICY.maxConcurrency));
   return next;
 }
-function asArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-function asObject(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    try {
-      const parsed = JSON.parse(value);
-      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-function trimText(value, max = 5e4) {
-  let text = "";
-  if (typeof value === "string") {
-    text = value;
-  } else if (value != null) {
-    try {
-      text = JSON.stringify(value);
-    } catch {
-      text = String(value);
-    }
-  }
-  return text.length > max ? `${text.slice(0, max)}
-...[truncated]` : text;
-}
-function normalizeStepType(value) {
-  return ["reasoning", "skill", "tool", "sub_agent", "verification"].includes(value) ? value : "tool";
-}
-function normalizePlanKey(step, index) {
-  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
-}
 class AgentLoopController {
-  constructor(registryService, plannerService, validator, repository, harness) {
+  constructor(registryService, plannerService, validator, repository, harness, tokenTracker = null) {
     this.registryService = registryService;
     this.plannerService = plannerService;
     this.validator = validator;
     this.repository = repository;
     this.harness = harness;
+    this.tokenTracker = tokenTracker;
   }
   async createRun(options) {
     const goal = String(options.goal || "").trim();
@@ -144,7 +122,7 @@ class AgentLoopController {
     this.validator.validate(plan);
     const harnessTag = String(options.harnessTag || ((_a = options.metadata) == null ? void 0 : _a.harnessTag) || "default").trim() || "default";
     const harnessProfile = await this.registryService.getHarnessProfile(harnessTag);
-    const harnessSettings = asObject(harnessProfile == null ? void 0 : harnessProfile.settings);
+    const harnessSettings = (0, import_ctx_utils.asObject)(harnessProfile == null ? void 0 : harnessProfile.settings);
     if (options.runId) {
       return this.revisePlanGoal(options.runId, plan, {
         goal: options.goal,
@@ -165,7 +143,7 @@ class AgentLoopController {
       userId: options.userId,
       policy: options.policy,
       metadata: {
-        ...asObject(options.metadata),
+        ...(0, import_ctx_utils.asObject)(options.metadata),
         harnessTag,
         harnessProfileId: harnessProfile == null ? void 0 : harnessProfile.id,
         harnessSettings,
@@ -198,11 +176,11 @@ class AgentLoopController {
         planVersion: 1,
         harnessTag,
         steps: plan.map((step, index) => ({
-          planKey: normalizePlanKey(step, index),
+          planKey: (0, import_ctx_utils.normalizePlanKey)(step, index),
           title: step.title || `Step ${index + 1}`,
-          type: normalizeStepType(step.type),
+          type: (0, import_ctx_utils.normalizeStepType)(step.type),
           target: step.target || "",
-          dependsOn: asArray(step.dependsOn).map(String)
+          dependsOn: (0, import_ctx_utils.asArray)(step.dependsOn).map(String)
         }))
       }
     });
@@ -234,11 +212,11 @@ class AgentLoopController {
       rejectionReason: "",
       changeRequest: "",
       metadata: {
-        ...asObject(run.metadata),
-        ...asObject(options.metadata),
-        harnessTag: options.harnessTag || asObject(run.metadata).harnessTag || "default",
-        harnessProfileId: options.harnessProfileId || asObject(run.metadata).harnessProfileId,
-        harnessSettings: asObject(options.harnessSettings || asObject(run.metadata).harnessSettings),
+        ...(0, import_ctx_utils.asObject)(run.metadata),
+        ...(0, import_ctx_utils.asObject)(options.metadata),
+        harnessTag: options.harnessTag || (0, import_ctx_utils.asObject)(run.metadata).harnessTag || "default",
+        harnessProfileId: options.harnessProfileId || (0, import_ctx_utils.asObject)(run.metadata).harnessProfileId,
+        harnessSettings: (0, import_ctx_utils.asObject)(options.harnessSettings || (0, import_ctx_utils.asObject)(run.metadata).harnessSettings),
         approvalMode: "plan_first"
       },
       updatedAt: now()
@@ -252,7 +230,7 @@ class AgentLoopController {
       userId: options.userId,
       payload: {
         planVersion: nextPlanVersion,
-        steps: plan.map((step, index) => normalizePlanKey(step, index))
+        steps: plan.map((step, index) => (0, import_ctx_utils.normalizePlanKey)(step, index))
       }
     });
     return this.getRunDetail(run.id);
@@ -377,20 +355,20 @@ class AgentLoopController {
       const created = await this.repository.createStep({
         runId: run.id,
         parentStepId: step.parentStepId,
-        planKey: normalizePlanKey(step, i),
+        planKey: (0, import_ctx_utils.normalizePlanKey)(step, i),
         index: indexStart + i,
         title: step.title || `Step ${indexStart + i + 1}`,
         description: step.description || "",
-        type: normalizeStepType(step.type),
+        type: (0, import_ctx_utils.normalizeStepType)(step.type),
         target: step.target || "",
         input: step.input || {},
         output: {},
         status: "pending",
         attempt: 0,
         maxAttempts: step.maxAttempts || policy.maxStepAttempts,
-        dependsOn: asArray(step.dependsOn).map(String),
+        dependsOn: (0, import_ctx_utils.asArray)(step.dependsOn).map(String),
         dependencyPolicy: step.dependencyPolicy || ((_a = step.metadata) == null ? void 0 : _a.dependencyPolicy) || "require_success",
-        metadata: asObject(step.metadata)
+        metadata: (0, import_ctx_utils.asObject)(step.metadata)
       });
       createdSteps.push(created);
     }
@@ -460,7 +438,6 @@ class AgentLoopController {
     });
     await this.repository.updateRun(run.id, {
       status: "running",
-      currentStepId: step.id,
       updatedAt: now()
     });
     await this.repository.createEvent({
@@ -498,22 +475,18 @@ class AgentLoopController {
     if (step.status !== "running") {
       throw new Error(`Step ${step.id} cannot complete from status "${step.status}".`);
     }
-    if (!run.currentStepId || String(run.currentStepId) !== String(step.id)) {
-      throw new Error(`Step ${step.id} is not the current running step for run ${run.id}.`);
-    }
     await this.repository.updateStep(step.id, {
       status: "succeeded",
       output: output === void 0 ? {} : output,
       error: "",
       skillExecutionId: options.skillExecutionId || step.skillExecutionId,
       agentExecutionSpanId: options.agentExecutionSpanId || step.agentExecutionSpanId,
-      metadata: { ...asObject(step.metadata), ...asObject(options.metadata) },
+      metadata: { ...(0, import_ctx_utils.asObject)(step.metadata), ...(0, import_ctx_utils.asObject)(options.metadata) },
       endedAt: now(),
       updatedAt: now()
     });
     await this.repository.updateRun(run.id, {
       status: "running",
-      currentStepId: null,
       updatedAt: now()
     });
     await this.repository.createEvent({
@@ -521,7 +494,7 @@ class AgentLoopController {
       stepId: step.id,
       type: "step_succeeded",
       title: `Completed: ${step.title || step.planKey}`,
-      content: trimText(output, 2e3),
+      content: (0, import_ctx_utils.trimText)(output, 2e3),
       status: "succeeded",
       userId: options.userId
     });
@@ -536,20 +509,16 @@ class AgentLoopController {
     if (step.status !== "running") {
       throw new Error(`Step ${step.id} cannot fail from status "${step.status}".`);
     }
-    if (!run.currentStepId || String(run.currentStepId) !== String(step.id)) {
-      throw new Error(`Step ${step.id} is not the current running step for run ${run.id}.`);
-    }
     const policy = normalizePolicy(run.policy);
     await this.repository.updateStep(step.id, {
       status: "failed",
-      error: trimText(error, 1e4),
-      metadata: { ...asObject(step.metadata), ...asObject(options.metadata) },
+      error: (0, import_ctx_utils.trimText)(error, 1e4),
+      metadata: { ...(0, import_ctx_utils.asObject)(step.metadata), ...(0, import_ctx_utils.asObject)(options.metadata) },
       endedAt: now(),
       updatedAt: now()
     });
     await this.repository.updateRun(run.id, {
       status: "running",
-      currentStepId: null,
       updatedAt: now()
     });
     await this.repository.createEvent({
@@ -575,11 +544,6 @@ class AgentLoopController {
     if (!["pending", "running", "failed"].includes(step.status)) {
       throw new Error(`Step ${step.id} cannot skip from status "${step.status}".`);
     }
-    if (step.status === "running") {
-      if (!run.currentStepId || String(run.currentStepId) !== String(step.id)) {
-        throw new Error(`Step ${step.id} is not the current running step for run ${run.id}.`);
-      }
-    }
     await this.repository.updateStep(step.id, {
       status: "skipped",
       error: reason,
@@ -606,11 +570,6 @@ class AgentLoopController {
     if (!["pending", "running"].includes(step.status)) {
       throw new Error(`Step ${step.id} cannot request approval for status "${step.status}".`);
     }
-    if (step.status === "running") {
-      if (!run.currentStepId || String(run.currentStepId) !== String(step.id)) {
-        throw new Error(`Step ${step.id} is not the current running step for run ${run.id}.`);
-      }
-    }
     await this.repository.updateStep(step.id, {
       status: "waiting_user",
       approval: approval || {},
@@ -646,9 +605,6 @@ class AgentLoopController {
     if (run.status !== "waiting_user" || step.status !== "waiting_user") {
       throw new Error("Run is not waiting for user approval.");
     }
-    if (run.currentStepId && String(run.currentStepId) !== String(step.id)) {
-      throw new Error(`Step ${step.id} is not the current waiting step for run ${run.id}.`);
-    }
     if (options.approved) {
       const nextValues = {
         status: "pending",
@@ -708,12 +664,35 @@ class AgentLoopController {
     if (Number(step.attempt || 0) >= Number(step.maxAttempts || policy.maxStepAttempts)) {
       throw new Error(`Step ${step.id} reached maxAttempts=${step.maxAttempts}.`);
     }
-    await this.repository.updateStep(step.id, {
+    let routedTarget;
+    let routeReason;
+    if (step.type === "sub_agent" && run.leaderUsername) {
+      const target = step.target || "";
+      if (target) {
+        const circuitBreaker = (0, import_CircuitBreaker.getCircuitBreaker)();
+        const state = circuitBreaker.getState(target);
+        const attempt = Number(step.attempt || 0);
+        const shouldRoute = (state == null ? void 0 : state.state) === "open" || state && state.failures >= 2 && attempt >= 1;
+        if (shouldRoute) {
+          const alternatives = await this.registryService.findAlternativeSubAgents(run.leaderUsername, target);
+          if (alternatives.length > 0) {
+            const chosen = alternatives[0];
+            routedTarget = chosen.username;
+            routeReason = `Sub-agent "${target}" has ${(state == null ? void 0 : state.failures) || 0} failure(s) (circuit: ${(state == null ? void 0 : state.state) || "closed"}). Routing retry to alternative "${routedTarget}".`;
+          }
+        }
+      }
+    }
+    const updateValues = {
       status: "pending",
       error: "",
       endedAt: null,
       updatedAt: now()
-    });
+    };
+    if (routedTarget) {
+      updateValues.target = routedTarget;
+    }
+    await this.repository.updateStep(step.id, updateValues);
     await this.repository.updateRun(run.id, {
       status: "running",
       updatedAt: now()
@@ -722,9 +701,11 @@ class AgentLoopController {
       runId: run.id,
       stepId: step.id,
       type: "step_retry",
-      title: `Retry queued: ${step.title || step.planKey}`,
+      title: routedTarget ? `Retry routed: ${step.title || step.planKey} \u2192 ${routedTarget}` : `Retry queued: ${step.title || step.planKey}`,
+      content: routeReason || "",
       status: "pending",
-      userId: options.userId
+      userId: options.userId,
+      payload: routedTarget ? { originalTarget: step.target, routedTarget, reason: routeReason } : void 0
     });
     return this.getRunSnapshot(run.id);
   }
@@ -751,7 +732,7 @@ class AgentLoopController {
       finalAnswer: finalAnswer || "",
       summary: options.summary || run.summary,
       currentStepId: null,
-      metadata: { ...asObject(run.metadata), evidence: options.evidence },
+      metadata: { ...(0, import_ctx_utils.asObject)(run.metadata), evidence: options.evidence },
       endedAt: now(),
       updatedAt: now()
     });
@@ -766,6 +747,32 @@ class AgentLoopController {
     });
     return this.getRunSnapshot(run.id);
   }
+  async stepFeedback(stepId, feedback, options = {}) {
+    const step = await this.repository.requireStep(stepId);
+    const run = await this.repository.requireRun(step.runId);
+    if (step.status !== "succeeded" && step.status !== "failed") {
+      throw new Error(`Cannot provide feedback for step ${step.id} in status "${step.status}".`);
+    }
+    await this.repository.createEvent({
+      runId: run.id,
+      stepId: step.id,
+      type: "step_feedback",
+      title: `Feedback: ${feedback.rating === "positive" ? "\u{1F44D}" : "\u{1F44E}"} ${step.title || step.planKey}`,
+      content: feedback.comment || "",
+      status: step.status,
+      userId: options.userId,
+      payload: {
+        rating: feedback.rating,
+        comment: feedback.comment || "",
+        category: feedback.category || "",
+        stepType: step.type,
+        stepPlanKey: step.planKey,
+        stepTarget: step.target || "",
+        attempt: step.attempt || 0
+      }
+    });
+    return this.getRunSnapshot(run.id);
+  }
   async cancelRun(runId, options = {}) {
     const run = await this.repository.requireRun(runId);
     if (TERMINAL_RUN_STATUSES.has(run.status)) {
@@ -808,7 +815,7 @@ class AgentLoopController {
     try {
       let iterations = 0;
       let snapshot = await this.getRunSnapshot(runId);
-      const harnessSettings = asObject((_b = (_a = snapshot.run) == null ? void 0 : _a.metadata) == null ? void 0 : _b.harnessSettings);
+      const harnessSettings = (0, import_ctx_utils.asObject)((_b = (_a = snapshot.run) == null ? void 0 : _a.metadata) == null ? void 0 : _b.harnessSettings);
       const maxControllerSteps = Math.max(
         1,
         Math.min(
@@ -817,39 +824,67 @@ class AgentLoopController {
         )
       );
       const policy = normalizePolicy(snapshot.run.policy);
-      while (snapshot.nextStep && iterations < maxControllerSteps) {
-        iterations += 1;
-        const nextStep = snapshot.nextStep;
-        snapshot = await this.startStep(nextStep.id, { userId: options.userId });
-        const runningStep = snapshot.steps.find((step) => String(step.id) === String(nextStep.id)) || nextStep;
-        try {
-          const output = await this.harness.executeStep(snapshot.run, runningStep, options);
-          snapshot = await this.completeStep(runningStep.id, output, {
-            userId: options.userId,
-            metadata: { controller: "agent-loop-service" }
-          });
-        } catch (error) {
-          if ((error == null ? void 0 : error.message) === "requires_approval") {
-            snapshot = await this.requestApproval(runningStep.id, {
-              prompt: `Execution of step "${runningStep.title}" requires permission.`
-            }, {
-              userId: options.userId,
-              reason: "Dynamic tool approval required by policy."
+      const maxConcurrency = policy.maxConcurrency;
+      while (snapshot.nextSteps && snapshot.nextSteps.length > 0 && iterations < maxControllerSteps) {
+        const batch = snapshot.nextSteps.slice(0, maxConcurrency);
+        iterations += batch.length;
+        if (this.tokenTracker) {
+          const budgetCheck = await this.tokenTracker.checkBudget(runId);
+          if (!budgetCheck.allowed) {
+            return this.finishRun(runId, budgetCheck.reason, {
+              status: "failed",
+              summary: budgetCheck.reason,
+              userId: options.userId
             });
-            break;
           }
-          snapshot = await this.failStep(runningStep.id, (error == null ? void 0 : error.message) || String(error), {
-            userId: options.userId,
-            metadata: { controller: "agent-loop-service" }
-          });
-          const failedStep = snapshot.steps.find((step) => String(step.id) === String(runningStep.id));
-          if (!failedStep || Number(failedStep.attempt || 0) >= Number(failedStep.maxAttempts || policy.maxStepAttempts)) {
-            break;
+        }
+        await Promise.all(batch.map((step) => this.startStep(step.id, { userId: options.userId })));
+        snapshot = await this.getRunSnapshot(runId);
+        const runningSteps = batch.map(
+          (step) => snapshot.steps.find((s) => String(s.id) === String(step.id)) || step
+        );
+        const results = await Promise.allSettled(
+          runningSteps.map((step) => this.harness.executeStep(snapshot.run, step, options))
+        );
+        for (let i = 0; i < results.length; i++) {
+          const runningStep = runningSteps[i];
+          const result = results[i];
+          if (result.status === "fulfilled") {
+            snapshot = await this.completeStep(runningStep.id, result.value, {
+              userId: options.userId,
+              metadata: { controller: "agent-loop-service" }
+            });
+          } else {
+            const error = result.reason;
+            if ((error == null ? void 0 : error.message) === "requires_approval") {
+              snapshot = await this.requestApproval(
+                runningStep.id,
+                { prompt: `Execution of step "${runningStep.title}" requires permission.` },
+                { userId: options.userId, reason: "Dynamic tool approval required by policy." }
+              );
+              break;
+            }
+            snapshot = await this.failStep(runningStep.id, (error == null ? void 0 : error.message) || String(error), {
+              userId: options.userId,
+              metadata: { controller: "agent-loop-service" }
+            });
+            const failedStep = snapshot.steps.find((s) => String(s.id) === String(runningStep.id));
+            if (failedStep && Number(failedStep.attempt || 0) < Number(failedStep.maxAttempts || policy.maxStepAttempts)) {
+              const attempt = Number(failedStep.attempt || 1);
+              const baseDelay = 1e3;
+              const maxDelay = 6e4;
+              const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
           }
         }
+        snapshot = await this.getRunSnapshot(runId);
+        if (snapshot.run.status === "waiting_user") {
+          break;
+        }
       }
       snapshot = await this.getRunSnapshot(runId);
-      if (iterations >= maxControllerSteps && snapshot.nextStep) {
+      if (iterations >= maxControllerSteps && snapshot.nextSteps && snapshot.nextSteps.length > 0) {
         return this.finishRun(runId, `Agent loop stopped after ${maxControllerSteps} controller steps.`, {
           status: "failed",
           summary: "Controller iteration limit reached.",
@@ -861,7 +896,9 @@ class AgentLoopController {
       }
       const steps = snapshot.steps || [];
       const failed = steps.filter((step) => step.status === "failed");
-      const unfinished = steps.filter((step) => !TERMINAL_STEP_STATUSES.has(step.status) && step.status !== "failed");
+      const unfinished = steps.filter(
+        (step) => !TERMINAL_STEP_STATUSES.has(step.status) && step.status !== "failed"
+      );
       if (failed.length || unfinished.length) {
         return this.finishRun(
           runId,
@@ -869,7 +906,10 @@ class AgentLoopController {
           {
             status: "failed",
             summary: ((_c = failed[0]) == null ? void 0 : _c.error) || "No executable step is available.",
-            evidence: { failedStepIds: failed.map((step) => step.id), unfinishedStepIds: unfinished.map((step) => step.id) },
+            evidence: {
+              failedStepIds: failed.map((step) => step.id),
+              unfinishedStepIds: unfinished.map((step) => step.id)
+            },
             userId: options.userId
           }
         );
@@ -891,11 +931,12 @@ class AgentLoopController {
   async getRunSnapshot(runId) {
     const run = await this.repository.requireRun(runId);
     const steps = await this.repository.getSteps(run.id);
-    const nextStep = this.pickNextStep(steps, run.policy);
+    const nextSteps = this.pickNextSteps(steps, run.policy);
+    const runningStepIds = steps.filter((s) => s.status === "running").map((s) => s.id);
     return {
-      run,
+      run: { ...run, runningStepIds },
       steps,
-      nextStep
+      nextSteps
     };
   }
   async getRunDetail(runId) {
@@ -910,28 +951,26 @@ class AgentLoopController {
       skillExecutions
     };
   }
-  pickNextStep(steps, runPolicy) {
+  pickNextSteps(steps, runPolicy) {
     var _a;
     const byPlanKey = new Map(steps.map((step) => [String(step.planKey), step]));
     const policy = normalizePolicy(runPolicy);
     const candidates = steps.filter(
       (step) => step.status === "pending" || step.status === "failed" && Number(step.attempt || 0) < Number(step.maxAttempts || policy.maxStepAttempts)
     ).sort((a, b) => Number(a.index || 0) - Number(b.index || 0));
+    const ready = [];
     for (const step of candidates) {
-      const dependencies = asArray(step.dependsOn).map(String);
+      const dependencies = (0, import_ctx_utils.asArray)(step.dependsOn).map(String);
       const allowSkipped = step.dependencyPolicy === "allow_skipped" || ((_a = step.metadata) == null ? void 0 : _a.dependencyPolicy) === "allow_skipped";
-      const ready = dependencies.every((key) => {
+      const allDepsReady = dependencies.every((key) => {
         const dependency = byPlanKey.get(key);
         return (dependency == null ? void 0 : dependency.status) === "succeeded" || allowSkipped && (dependency == null ? void 0 : dependency.status) === "skipped";
       });
-      if (ready) {
-        return {
-          ...step,
-          retryable: step.status === "failed"
-        };
+      if (allDepsReady) {
+        ready.push(step);
       }
     }
-    return null;
+    return ready;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/services/AgentLoopRepository.js

@@ -29,24 +29,8 @@ __export(AgentLoopRepository_exports, {
   AgentLoopRepository: () => AgentLoopRepository
 });
 module.exports = __toCommonJS(AgentLoopRepository_exports);
-function toPlain(record) {
-  var _a;
-  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
-}
-function trimText(value, max = 5e4) {
-  let text = "";
-  if (typeof value === "string") {
-    text = value;
-  } else if (value != null) {
-    try {
-      text = JSON.stringify(value);
-    } catch {
-      text = String(value);
-    }
-  }
-  return text.length > max ? `${text.slice(0, max)}
-...[truncated]` : text;
-}
+var import_ctx_utils = require("../utils/ctx-utils");
+var import_RunEventBus = require("./RunEventBus");
 class AgentLoopRepository {
   constructor(plugin) {
     this.plugin = plugin;
@@ -58,7 +42,7 @@ class AgentLoopRepository {
     const run = await this.db.getRepository("agentLoopRuns").findOne({
       filter: { id: runId }
     });
-    return run ? toPlain(run) : null;
+    return run ? (0, import_ctx_utils.toPlain)(run) : null;
   }
   async requireRun(runId) {
     const run = await this.getRun(runId);
@@ -71,7 +55,7 @@ class AgentLoopRepository {
     const run = await this.db.getRepository("agentLoopRuns").create({
       values
     });
-    return toPlain(run);
+    return (0, import_ctx_utils.toPlain)(run);
   }
   async updateRun(runId, values) {
     await this.db.getRepository("agentLoopRuns").update({
@@ -83,7 +67,7 @@ class AgentLoopRepository {
     const step = await this.db.getRepository("agentLoopSteps").findOne({
       filter: { id: stepId }
     });
-    return step ? toPlain(step) : null;
+    return step ? (0, import_ctx_utils.toPlain)(step) : null;
   }
   async requireStep(stepId) {
     const step = await this.getStep(stepId);
@@ -96,7 +80,7 @@ class AgentLoopRepository {
     const step = await this.db.getRepository("agentLoopSteps").create({
       values
     });
-    return toPlain(step);
+    return (0, import_ctx_utils.toPlain)(step);
   }
   async updateStep(stepId, values) {
     await this.db.getRepository("agentLoopSteps").update({
@@ -110,18 +94,20 @@ class AgentLoopRepository {
       sort: ["index", "createdAt"],
       pageSize: 1e3
     });
-    return steps.map(toPlain);
+    return steps.map(import_ctx_utils.toPlain);
   }
   async createEvent(values) {
     const record = await this.db.getRepository("agentLoopEvents").create({
       values: {
         ...values,
-        content: trimText(values.content || "", 1e4),
+        content: (0, import_ctx_utils.trimText)(values.content || "", 1e4),
         payload: values.payload || {},
         createdAt: /* @__PURE__ */ new Date()
       }
     });
-    return toPlain(record);
+    const event = (0, import_ctx_utils.toPlain)(record);
+    (0, import_RunEventBus.getRunEventBus)().emit(values.runId, event);
+    return event;
   }
   async getEvents(runId) {
     const events = await this.db.getRepository("agentLoopEvents").find({
@@ -129,7 +115,7 @@ class AgentLoopRepository {
       sort: ["createdAt"],
       pageSize: 500
     });
-    return events.map(toPlain);
+    return events.map(import_ctx_utils.toPlain);
   }
   async getLinkedSpans(runId, rootRunId) {
     const repo = this.db.getRepository("agentExecutionSpans");
@@ -143,7 +129,7 @@ class AgentLoopRepository {
         sort: ["createdAt"],
         pageSize: 1e3
       });
-      return rows.map(toPlain);
+      return rows.map(import_ctx_utils.toPlain);
     } catch {
       if (!rootRunId) return [];
       const rows = await repo.find({
@@ -151,7 +137,7 @@ class AgentLoopRepository {
         sort: ["createdAt"],
         pageSize: 1e3
       });
-      return rows.map(toPlain);
+      return rows.map(import_ctx_utils.toPlain);
     }
   }
   async getLinkedSkillExecutions(runId, steps) {
@@ -171,7 +157,7 @@ class AgentLoopRepository {
       sort: ["createdAt"],
       pageSize: 1e3
     });
-    return rows.map(toPlain);
+    return rows.map(import_ctx_utils.toPlain);
   }
   async lockRun(runId, lockName, durationMs) {
     const repo = this.db.getRepository("agentLoopRuns");
@@ -186,11 +172,7 @@ class AgentLoopRepository {
       {
         where: {
           id: runId,
-          [Op.or]: [
-            { lockedBy: null },
-            { lockedUntil: { [Op.lt]: now.toISOString() } },
-            { lockedBy: lockName }
-          ]
+          [Op.or]: [{ lockedBy: null }, { lockedUntil: { [Op.lt]: now.toISOString() } }, { lockedBy: lockName }]
         }
       }
     );