@iowarp/clio-coder 0.3.6 → 0.3.8

package/dist/{chunk-AD2SYQYC.js → chunk-IJ7RPIYJ.js}

@@ -1,14 +1,16 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  MAX_TIMER_DELAY_MS
+} from "./chunk-FQ4SKYE4.js";
 import {
   ACTIVE_AGENT_AUTOMATION_ROLES,
   ACTIVE_ROUTING_POSTURES,
   ACTIVE_ROUTING_ROLES,
+  COUNCIL_MEMBER_LABEL_PATTERN,
   DEFAULT_SETTINGS,
+  THEME_NAMED_COLORS,
   THINKING_LEVELS
-} from "./chunk-4OC57DA6.js";
-import {
-  MAX_TIMER_DELAY_MS
-} from "./chunk-FQ4SKYE4.js";
+} from "./chunk-4DGYLA73.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
@@ -731,6 +733,30 @@ function validateMemorySettings(issues, value) {
   }
   return out;
 }
+function validateWatchdogSettings(issues, value) {
+  const out = cloneValue(DEFAULT_SETTINGS.watchdog);
+  if (!isPlainObject(value)) {
+    issues.add("watchdog", `expected a map, got ${describe(value)}`);
+    return out;
+  }
+  issues.unknownKeys("watchdog", value, ["enabled", "target", "cadenceToolCalls"]);
+  if ("enabled" in value) {
+    const enabled = expectBoolean(issues, "watchdog.enabled", value.enabled);
+    if (enabled !== void 0) out.enabled = enabled;
+  }
+  if ("target" in value && value.target !== null) {
+    const target = expectString(issues, "watchdog.target", value.target);
+    if (target !== void 0) {
+      if (target.trim().length === 0) issues.add("watchdog.target", "expected a non-empty target id");
+      else out.target = target.trim();
+    }
+  }
+  if ("cadenceToolCalls" in value && value.cadenceToolCalls !== null) {
+    const cadence = expectInteger(issues, "watchdog.cadenceToolCalls", value.cadenceToolCalls, { min: 1 });
+    if (cadence !== void 0) out.cadenceToolCalls = cadence;
+  }
+  return out;
+}
 function validateKeybindings(issues, value) {
   if (!isPlainObject(value)) {
     issues.add("keybindings", `expected a map, got ${describe(value)}`);
@@ -769,6 +795,7 @@ var TOP_LEVEL_KEYS = [
   "orchestrator",
   "background",
   "memory",
+  "watchdog",
   "workers",
   "fleet",
   "routing",
@@ -779,6 +806,7 @@ var TOP_LEVEL_KEYS = [
   "theme",
   "terminal",
   "skills",
+  "library",
   "attribution",
   "delegation",
   "keybindings",
@@ -825,6 +853,25 @@ function validateSettings(raw) {
     const v = expectStringArray(issues, "runtimePlugins", raw.runtimePlugins);
     if (v !== void 0) settings.runtimePlugins = v;
   }
+  if ("library" in raw) {
+    if (!isPlainObject(raw.library)) {
+      issues.add("library", `expected a map, got ${describe(raw.library)}`);
+    } else {
+      issues.unknownKeys("library", raw.library, ["catalog", "remote", "confirmedRemote", "sync"]);
+      for (const key of ["catalog", "remote", "confirmedRemote"]) {
+        const value = raw.library[key];
+        if (value === void 0) continue;
+        if (value !== null && typeof value !== "string")
+          issues.add(`library.${key}`, `expected a string or null, got ${describe(value)}`);
+        else settings.library[key] = value;
+      }
+      if (raw.library.sync !== void 0) {
+        if (typeof raw.library.sync !== "boolean")
+          issues.add("library.sync", `expected a boolean, got ${describe(raw.library.sync)}`);
+        else settings.library.sync = raw.library.sync;
+      }
+    }
+  }
   if ("orchestrator" in raw) {
     settings.orchestrator = validateWorkerTarget(
       issues,
@@ -844,6 +891,7 @@ function validateSettings(raw) {
     );
   }
   if ("memory" in raw) settings.memory = validateMemorySettings(issues, raw.memory);
+  if ("watchdog" in raw) settings.watchdog = validateWatchdogSettings(issues, raw.watchdog);
   if ("fleet" in raw) {
     settings.fleet = validateFleet(issues, raw.fleet);
   }
@@ -935,6 +983,7 @@ function validateSettings(raw) {
       issues.unknownKeys("workers", raw.workers, [
         "default",
         "profiles",
+        "rosters",
         "agentBindings",
         "maxRetries",
         "onPermission",
@@ -976,6 +1025,70 @@ function validateSettings(raw) {
           settings.workers.profiles = profiles;
         }
       }
+      if ("rosters" in raw.workers) {
+        if (!isPlainObject(raw.workers.rosters)) {
+          issues.add("workers.rosters", `expected a map, got ${describe(raw.workers.rosters)}`);
+        } else {
+          const rosters = {};
+          for (const [rawName, rawRoster] of Object.entries(raw.workers.rosters)) {
+            const name = rawName.trim();
+            const path = `workers.rosters.${name}`;
+            if (!name) {
+              issues.add("workers.rosters", "empty roster name");
+              continue;
+            }
+            if (!isPlainObject(rawRoster)) {
+              issues.add(path, `expected a map, got ${describe(rawRoster)}`);
+              continue;
+            }
+            issues.unknownKeys(path, rawRoster, ["members"]);
+            if (!Array.isArray(rawRoster.members)) {
+              issues.add(`${path}.members`, "expected a list");
+              continue;
+            }
+            if (rawRoster.members.length < 2 || rawRoster.members.length > 5) {
+              issues.add(`${path}.members`, "expected 2 to 5 members");
+            }
+            const members = [];
+            const labels = /* @__PURE__ */ new Set();
+            for (const [index, rawMember] of rawRoster.members.entries()) {
+              const memberPath = `${path}.members[${index}]`;
+              if (!isPlainObject(rawMember)) {
+                issues.add(memberPath, `expected a map, got ${describe(rawMember)}`);
+                continue;
+              }
+              issues.unknownKeys(memberPath, rawMember, ["label", "target", "model", "thinking", "color"]);
+              const label = expectString(issues, `${memberPath}.label`, rawMember.label);
+              const target = expectString(issues, `${memberPath}.target`, rawMember.target);
+              if (label !== void 0 && !COUNCIL_MEMBER_LABEL_PATTERN.test(label)) {
+                issues.add(`${memberPath}.label`, "expected [a-z][a-z0-9_-]{0,31}");
+              }
+              if (label !== void 0 && labels.has(label)) issues.add(`${memberPath}.label`, "duplicate label");
+              if (label !== void 0) labels.add(label);
+              if (target !== void 0 && !settings.targets.some((entry) => entry.id === target)) {
+                issues.add(`${memberPath}.target`, `unknown target '${target}'`);
+              }
+              const model = rawMember.model === void 0 ? void 0 : expectString(issues, `${memberPath}.model`, rawMember.model);
+              const thinking = rawMember.thinking === void 0 ? void 0 : expectEnum(issues, `${memberPath}.thinking`, rawMember.thinking, THINKING_LEVELS);
+              const color = rawMember.color === void 0 ? void 0 : expectString(issues, `${memberPath}.color`, rawMember.color);
+              if (color !== void 0 && !THEME_NAMED_COLORS.includes(color) && !/^#[0-9a-fA-F]{6}$/u.test(color)) {
+                issues.add(`${memberPath}.color`, "expected a theme named color or 6-digit hex color");
+              }
+              if (label === void 0 || target === void 0) continue;
+              members.push({
+                label,
+                target,
+                ...model ? { model } : {},
+                ...thinking ? { thinking } : {},
+                ...color ? { color } : {}
+              });
+            }
+            if (rawRoster.members.length >= 2 && rawRoster.members.length <= 5 && members.length === rawRoster.members.length)
+              rosters[name] = { members };
+          }
+          settings.workers.rosters = rosters;
+        }
+      }
       if ("agentBindings" in raw.workers) {
         if (!isPlainObject(raw.workers.agentBindings)) {
           issues.add("workers.agentBindings", `expected a map, got ${describe(raw.workers.agentBindings)}`);
@@ -1100,7 +1213,8 @@ function validateSettings(raw) {
         "outputVerbosity",
         "tuiMode",
         "fullscreenScrollbar",
-        "smoothStreaming"
+        "smoothStreaming",
+        "notify"
       ]);
       if ("showTerminalProgress" in raw.terminal) {
         const v = expectBoolean(issues, "terminal.showTerminalProgress", raw.terminal.showTerminalProgress);
@@ -1126,6 +1240,10 @@ function validateSettings(raw) {
         if (v === "off" || v === "auto" || v === "on") settings.terminal.smoothStreaming = v;
         else if (v !== void 0) issues.add("terminal.smoothStreaming", "expected off, auto, or on");
       }
+      if ("notify" in raw.terminal) {
+        const v = expectBoolean(issues, "terminal.notify", raw.terminal.notify);
+        if (v !== void 0) settings.terminal.notify = v;
+      }
     }
   }
   if ("skills" in raw) {
@@ -1443,4 +1561,4 @@ export {
   removeFleetProfileFromSettings,
   bindAgentProfileInSettings
 };
-//# sourceMappingURL=chunk-AD2SYQYC.js.map
+//# sourceMappingURL=chunk-IJ7RPIYJ.js.map

package/dist/chunk-J3YUBZWY.js

@@ -0,0 +1,382 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  fleetLoopCheckStepId,
+  fleetLoopRepairStepId,
+  fleetStepWriteBoundary
+} from "./chunk-E77JEWSD.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/execution-plan.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+function requireAgentSteps(steps) {
+  return steps.map((step) => {
+    if (step.kind === "code") throw new Error(`execution plan: step '${step.id}' is a code step and has no route`);
+    return step;
+  });
+}
+function canonicalSteps(steps) {
+  return steps.map(
+    (step) => step.kind === "code" ? { ...step, kind: "code", dependencies: [...step.dependencies].sort() } : { ...step, kind: "agent", dependencies: [...step.dependencies].sort() }
+  );
+}
+function executionPlanWaves(steps, maxWorkers) {
+  if (!Number.isInteger(maxWorkers) || maxWorkers < 1)
+    throw new Error("execution plan: maxWorkers must be a positive integer");
+  if (steps.length === 0) throw new Error("execution plan: plan must contain at least one step");
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.id.trim().length === 0) throw new Error("execution plan: step id must be non-empty");
+    if (ids.has(step.id)) throw new Error(`execution plan: duplicate step id '${step.id}'`);
+    ids.add(step.id);
+  }
+  for (const step of steps)
+    for (const dependency of step.dependencies) {
+      if (!ids.has(dependency))
+        throw new Error(`execution plan: step '${step.id}' has missing dependency '${dependency}'`);
+      if (dependency === step.id) throw new Error(`execution plan: cycle includes '${step.id}'`);
+    }
+  const remaining = new Set(steps.map((step) => step.id));
+  const completed = /* @__PURE__ */ new Set();
+  const waves = [];
+  while (remaining.size > 0) {
+    const ready = steps.filter((step) => remaining.has(step.id) && step.dependencies.every((id) => completed.has(id)));
+    if (ready.length === 0) throw new Error("execution plan: dependency cycle detected");
+    const codeReady = ready.filter((step) => step.kind === "code").map((step) => step.id);
+    const agentReady = ready.filter((step) => step.kind !== "code").map((step) => step.id);
+    const chunks = [];
+    for (let offset = 0; offset < agentReady.length; offset += maxWorkers) {
+      chunks.push(agentReady.slice(offset, offset + maxWorkers));
+    }
+    if (chunks.length === 0) chunks.push([]);
+    chunks[0] = [...codeReady, ...chunks[0] ?? []];
+    for (const wave of chunks) {
+      waves.push(wave);
+      for (const id of wave) {
+        remaining.delete(id);
+        completed.add(id);
+      }
+    }
+  }
+  return waves;
+}
+function checkLoops(steps, loops) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const loop of loops) {
+    if (seen.has(loop.id)) throw new Error(`execution plan: duplicate loop id '${loop.id}'`);
+    seen.add(loop.id);
+    if (!Number.isInteger(loop.maxAttempts) || loop.maxAttempts < 1) {
+      throw new Error(`execution plan: loop '${loop.id}' must declare a positive attempt bound`);
+    }
+    if (loop.checkStepIds.length !== loop.maxAttempts || loop.repairStepIds.length !== loop.maxAttempts - 1) {
+      throw new Error(`execution plan: loop '${loop.id}' membership does not match its bound of ${loop.maxAttempts}`);
+    }
+    for (const id of [...loop.checkStepIds, ...loop.repairStepIds]) {
+      const step = byId.get(id);
+      if (step === void 0) throw new Error(`execution plan: loop '${loop.id}' names unknown step '${id}'`);
+      if (step.loop?.loopId !== loop.id) {
+        throw new Error(`execution plan: step '${id}' is not a member of loop '${loop.id}'`);
+      }
+    }
+  }
+  for (const step of steps) {
+    if (step.loop !== void 0 && !seen.has(step.loop.loopId)) {
+      throw new Error(`execution plan: step '${step.id}' belongs to undeclared loop '${step.loop.loopId}'`);
+    }
+  }
+}
+function checkWriteBoundaryWaves(steps, waves, writerLimit) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  for (const [index, wave] of waves.entries()) {
+    const members = wave.flatMap((id) => {
+      const step = byId.get(id);
+      return step === void 0 ? [] : [step];
+    });
+    const declared = members.filter((step) => step.writes !== void 0);
+    if (declared.length === 0) continue;
+    const undeclared = members.filter((step) => step.writes === void 0);
+    if (undeclared.length > 0 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} mixes boundary-enforced steps (${declared.map((step) => step.id).join(", ")}) with steps that declare no boundary (${undeclared.map((step) => step.id).join(", ")}); they share one checkout, so the undeclared step's writes cannot be told from a violation`
+      );
+    }
+    const writers = declared.filter((step) => (step.writes?.length ?? 0) > 0);
+    if (writers.length > 1 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} schedules ${writers.length} steps that may write (${writers.map((step) => step.id).join(
+          ", "
+        )}); a write boundary is verified by diffing one shared checkout, so concurrent writers cannot be attributed. Order them with dependencies or lower maxWorkers`
+      );
+    }
+  }
+}
+function compileExecutionPlan(input) {
+  if (input.writers !== void 0 && input.writers !== 1) {
+    throw new Error("execution plan: writers must be 1 when present");
+  }
+  const steps = canonicalSteps(input.steps);
+  const loops = (input.loops ?? []).map((loop) => ({
+    ...loop,
+    checkStepIds: [...loop.checkStepIds],
+    repairStepIds: [...loop.repairStepIds]
+  }));
+  checkLoops(steps, loops);
+  const waves = executionPlanWaves(steps, input.maxWorkers);
+  checkWriteBoundaryWaves(steps, waves, input.writers);
+  const canonical = {
+    version: 4,
+    topology: input.topology,
+    rootTask: input.rootTask,
+    maxWorkers: input.maxWorkers,
+    ...input.writers === 1 ? { writers: 1 } : {},
+    onFailure: input.onFailure,
+    steps,
+    loops,
+    waves
+  };
+  return { ...canonical, hash: createHash("sha256").update(JSON.stringify(canonical)).digest("hex") };
+}
+function executionPlanAncestors(plan, stepId) {
+  const byId = new Map(plan.steps.map((step) => [step.id, step]));
+  const ancestors = /* @__PURE__ */ new Set();
+  const pending = [...byId.get(stepId)?.dependencies ?? []];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === void 0 || ancestors.has(next)) continue;
+    ancestors.add(next);
+    pending.push(...byId.get(next)?.dependencies ?? []);
+  }
+  return ancestors;
+}
+function spliceExecutionPlan(plan, parentId, tasks) {
+  const parent = plan.steps.find((step) => step.id === parentId);
+  if (parent?.kind !== "agent" || parent.plan === void 0) {
+    throw new Error(`execution plan: '${parentId}' is not a plan step`);
+  }
+  const inserted = tasks.map((task) => ({
+    kind: "agent",
+    id: task.id,
+    agentId: task.agentId,
+    executionRole: task.executionRole,
+    scope: task.writes.length > 0 ? "workspace" : "readonly",
+    expectedResultContract: task.expectedResultContract,
+    requestedAuthority: task.requestedAuthority,
+    approvedAuthority: task.approvedAuthority,
+    dependencies: [parentId, ...task.dependencies],
+    task: task.task,
+    writes: [...task.writes],
+    ...task.target !== void 0 ? { target: task.target } : {},
+    ...task.profile !== void 0 ? { profile: task.profile } : {},
+    planParentId: parentId
+  }));
+  return compileExecutionPlan({
+    topology: plan.topology,
+    rootTask: plan.rootTask,
+    maxWorkers: plan.maxWorkers,
+    ...plan.writers === 1 ? { writers: 1 } : {},
+    onFailure: plan.onFailure,
+    steps: [...plan.steps, ...inserted],
+    loops: plan.loops
+  });
+}
+
+// src/domains/dispatch/fleet-plan.ts
+init_esm_shims();
+function expandDependencies(dependencies, loopMembers) {
+  return dependencies.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.checkStepIds];
+  });
+}
+function expandCommitSources(sources, loopMembers) {
+  return sources.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.repairStepIds].reverse();
+  });
+}
+function declaredLoops(steps) {
+  const loops = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    if (step.kind !== "loop") continue;
+    const checkStepIds = [];
+    const repairStepIds = [];
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      checkStepIds.push(fleetLoopCheckStepId(step.id, attempt));
+      if (attempt < step.maxAttempts) repairStepIds.push(fleetLoopRepairStepId(step.id, attempt));
+    }
+    loops.set(step.id, {
+      id: step.id,
+      checkKind: step.check.kind === "gate" ? "code" : step.check.kind,
+      maxAttempts: step.maxAttempts,
+      checkStepIds,
+      repairStepIds
+    });
+  }
+  return loops;
+}
+function compileFleetExecutionPlan(input) {
+  const { contract, task, resolveAgent } = input;
+  const loops = declaredLoops(contract.steps);
+  const steps = [];
+  const boundary = (scope, writes) => {
+    const resolved = fleetStepWriteBoundary(contract.version, scope, writes);
+    return resolved === void 0 ? {} : { writes: [...resolved] };
+  };
+  const agentNode = (context, dependencies, writes, loop, extra) => {
+    const resolved = resolveAgent(context);
+    return {
+      kind: "agent",
+      id: context.stepId,
+      agentId: context.agentId,
+      scope: context.scope,
+      dependencies: [...dependencies],
+      task,
+      expectedResultContract: resolved.expectedResultContract,
+      requestedAuthority: resolved.requestedAuthority,
+      approvedAuthority: resolved.approvedAuthority,
+      executionRole: resolved.executionRole,
+      ...boundary(context.scope, writes),
+      ...loop !== void 0 ? { loop } : {},
+      ...context.target !== void 0 ? { target: context.target } : {},
+      ...context.profile !== void 0 ? { profile: context.profile } : {},
+      ...extra
+    };
+  };
+  const routeOf = (value) => ({
+    ...value.target !== void 0 ? { target: value.target } : {},
+    ...value.profile !== void 0 ? { profile: value.profile } : {}
+  });
+  for (const step of contract.steps) {
+    const dependencies = expandDependencies(step.dependencies, loops);
+    if (step.kind === "agent") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, ...routeOf(step) },
+          dependencies,
+          step.writes
+        )
+      );
+      continue;
+    }
+    if (step.kind === "gate") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: "workspace", attempt: 0, gateAuthorRole: true, ...routeOf(step) },
+          dependencies,
+          [step.path],
+          void 0,
+          { gate: { path: step.path, commandId: step.run } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "plan") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, planRole: true, ...routeOf(step) },
+          dependencies,
+          step.writes,
+          void 0,
+          { plan: { roster: [...step.roster], maxTasks: step.maxTasks, proposals: step.proposals } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "code") {
+      steps.push({
+        kind: "code",
+        id: step.id,
+        commandId: step.command,
+        scope: step.scope,
+        dependencies,
+        ...boundary(step.scope, step.writes),
+        ...step.commitFrom !== void 0 ? { commitFrom: expandCommitSources(step.commitFrom, loops) } : {}
+      });
+      continue;
+    }
+    const loop = loops.get(step.id);
+    if (loop === void 0) throw new Error(`fleet plan: loop '${step.id}' failed to compile`);
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      const checkId = loop.checkStepIds[attempt - 1] ?? "";
+      const previousRepair = attempt === 1 ? null : loop.repairStepIds[attempt - 2] ?? "";
+      const checkDependencies = previousRepair === null ? dependencies : [previousRepair];
+      const membership = { loopId: loop.id, role: "check", attempt };
+      if (step.check.kind === "code") {
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: step.check.command,
+          scope: step.check.scope,
+          dependencies: checkDependencies,
+          ...boundary(step.check.scope, step.check.writes),
+          loop: membership,
+          // The green a later step may rely on; the scheduler re-runs it
+          // when a workspace step lands after it.
+          verification: true
+        });
+      } else if (step.check.kind === "gate") {
+        const gateId = step.check.gate;
+        const gate = contract.steps.find((candidate) => candidate.id === gateId);
+        if (gate?.kind !== "gate") throw new Error(`fleet plan: gate '${gateId}' failed to resolve`);
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: gate.run,
+          scope: "readonly",
+          dependencies: checkDependencies,
+          writes: [],
+          loop: membership,
+          verification: true,
+          gate: { gateId: gate.id, path: gate.path }
+        });
+      } else {
+        steps.push(
+          agentNode(
+            {
+              stepId: checkId,
+              agentId: step.check.agent,
+              scope: step.check.scope,
+              attempt: 0,
+              gateRole: "reviewer",
+              ...routeOf(step.check)
+            },
+            checkDependencies,
+            step.check.writes,
+            membership
+          )
+        );
+      }
+      if (attempt >= step.maxAttempts) continue;
+      const repairId = loop.repairStepIds[attempt - 1] ?? "";
+      steps.push(
+        agentNode(
+          { stepId: repairId, agentId: step.repair.agent, scope: step.repair.scope, attempt, ...routeOf(step.repair) },
+          [checkId],
+          step.repair.writes,
+          { loopId: loop.id, role: "repair", attempt }
+        )
+      );
+    }
+  }
+  return compileExecutionPlan({
+    topology: "fleet",
+    rootTask: task,
+    maxWorkers: contract.maxWorkers,
+    ...contract.writers === 1 ? { writers: 1 } : {},
+    onFailure: contract.onFailure,
+    steps,
+    loops: [...loops.values()]
+  });
+}
+
+export {
+  requireAgentSteps,
+  compileExecutionPlan,
+  executionPlanAncestors,
+  spliceExecutionPlan,
+  compileFleetExecutionPlan
+};
+//# sourceMappingURL=chunk-J3YUBZWY.js.map

package/dist/{chunk-5JGRAMKL.js → chunk-JOZYP4GM.js}

@@ -1,20 +1,22 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   assistantTextFromEvent
-} from "./chunk-3BPUFZDL.js";
+} from "./chunk-HLE42MG7.js";
 import {
-  compileExecutionPlan,
   durableAssistantTextFromEvent
-} from "./chunk-QM3F2GKX.js";
+} from "./chunk-TLQJPP24.js";
+import {
+  compileExecutionPlan
+} from "./chunk-J3YUBZWY.js";
 import {
   deriveExecutionRole
-} from "./chunk-22NAGB7X.js";
+} from "./chunk-H7IXIC72.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
 import {
   BusChannels
-} from "./chunk-G7MUEIGA.js";
+} from "./chunk-TT36MB5S.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -274,4 +276,4 @@ export {
   compileScoutTransition,
   createDispatchRunEventRegistry
 };
-//# sourceMappingURL=chunk-5JGRAMKL.js.map
+//# sourceMappingURL=chunk-JOZYP4GM.js.map