@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-F7Y6QTPL.js

@@ -0,0 +1,689 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compile,
+  compileWorker,
+  loadOperatorProfile,
+  loadProjectRules,
+  renderOperatorProfile,
+  selectActiveRules,
+  selectProjectPreload
+} from "./chunk-5W4FRA5Q.js";
+import {
+  loadFragments,
+  sha256
+} from "./chunk-FB3KTE2J.js";
+import {
+  BusChannels
+} from "./chunk-W5RM7YAH.js";
+import {
+  isUserVisibleAgent
+} from "./chunk-ARRUMZ7X.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/agents/catalog.ts
+init_esm_shims();
+var DEFAULT_DISPATCH_AGENT_ID = "coder";
+var OPERATOR_ONLY_SHADOW_AGENT_IDS = /* @__PURE__ */ new Set(["oracle"]);
+var FLEET_PROMPT_PURPOSE_MAX_CHARS = 64;
+var FLEET_HANDOFF_RULE = "A file you assigned to a worker is not yours to edit while its dispatch is pending or after it succeeds; if you already changed it, say so in your report.";
+var FLEET_REFUSAL_DISCLOSURE = "When admission refuses a dispatch, report the refusal and the reason it gave; never substitute another agent without saying why.";
+var FLEET_ANTI_CHURN_RULE = "A dispatch with the same target files and the same goal as one you already ran is a repeat however differently you word it: read that run's receipt, or run the check yourself, instead of dispatching again.";
+var FLEET_SPECIALIST_ROUTING = "Pick by job: supplied URLs, standards, or papers -> researcher; current ecosystems or an open-world second opinion -> world-knowledge; repository recon -> scout; receipts -> provenance; tests -> tester; gates -> verifier.";
+function fleetPromptPurpose(description) {
+  const trimmed = description.trim().replace(/\s+/gu, " ");
+  if (trimmed.length === 0) return "";
+  const stop = trimmed.indexOf(". ");
+  const sentence = stop > 0 ? trimmed.slice(0, stop) : trimmed.replace(/\.$/u, "");
+  if (sentence.length <= FLEET_PROMPT_PURPOSE_MAX_CHARS) return sentence;
+  const cut = sentence.lastIndexOf(" ", FLEET_PROMPT_PURPOSE_MAX_CHARS);
+  return `${sentence.slice(0, cut > 0 ? cut : FLEET_PROMPT_PURPOSE_MAX_CHARS).trimEnd()}...`;
+}
+function fleetPromptLine(spec) {
+  const budget = spec.budget.maximum ? `${spec.budget.toolCalls}..${spec.budget.maximum.toolCalls} calls` : `${spec.budget.toolCalls} calls`;
+  const purpose = fleetPromptPurpose(spec.description);
+  return `- ${spec.id} (${spec.capabilityClass}, ${budget})${purpose.length > 0 ? `: ${purpose}` : ""}`;
+}
+function renderFleetPromptSection(input) {
+  const specs = input.slice().sort((a, b) => {
+    const category = a.category.localeCompare(b.category);
+    return category === 0 ? a.id.localeCompare(b.id) : category;
+  });
+  const publicSpecs = specs.filter(isUserVisibleAgent);
+  const shadowSpecs = specs.filter((spec) => spec.audience === "shadow" && !OPERATOR_ONLY_SHADOW_AGENT_IDS.has(spec.id));
+  if (publicSpecs.length === 0 && shadowSpecs.length === 0) return "";
+  const lines = [
+    "# Fleet",
+    FLEET_HANDOFF_RULE,
+    FLEET_ANTI_CHURN_RULE,
+    FLEET_REFUSAL_DISCLOSURE,
+    // `agent:"auto"` baselines by task shape and can still land on a worker
+    // whose capability class is wrong for the job, so a pinned id is the
+    // reliable path; said here, next to the ids, rather than in the Tool
+    // Contract.
+    `Workers you reach with \`dispatch\` by \`agent\` id (default ${DEFAULT_DISPATCH_AGENT_ID}); agent:"auto" is a fallback, not a router. Capability class is what a worker may do: a read-only worker cannot edit.`,
+    FLEET_SPECIALIST_ROUTING
+  ];
+  if (publicSpecs.length > 0) {
+    lines.push("", "Operator-facing:", ...publicSpecs.map(fleetPromptLine));
+  }
+  if (shadowSpecs.length > 0) {
+    lines.push("", "Internal specialists, dispatch-only:", ...shadowSpecs.map(fleetPromptLine));
+  }
+  return lines.join("\n");
+}
+function renderAgentCatalogSectionsFromSpecs(input) {
+  const specs = input.slice().sort((a, b) => {
+    const category = a.category.localeCompare(b.category);
+    return category === 0 ? a.id.localeCompare(b.id) : category;
+  });
+  const publicSpecs = specs.filter(isUserVisibleAgent);
+  const shadowSpecs = specs.filter((spec) => spec.audience === "shadow");
+  const lines = [
+    "Clio manages a small fleet of coding agents. Recipes are Markdown files; normalized specs carry audience, category, capability, tools, skills, latency, and worker-budget hints.",
+    "Use the `dispatch` tool to invoke one by `agent_id` when delegation helps.",
+    `Default dispatch agent: ${DEFAULT_DISPATCH_AGENT_ID}.`,
+    "User-facing agents are base/custom. Shadow agents are internal helpers for context, research, and provenance; do not recommend them as normal `/run` choices.",
+    "Prefer fast read-only agents for orientation, verification agents for gates, and workspace-edit agents only for bounded coding tasks.",
+    "When a task matches a skill named on an agent line (skills=...), prefer the recipe that binds it; its worker is told to load bound skills for the run.",
+    `After a dispatch succeeds, synthesize from the sealed receipt; the worker's prose is an advisory claim until its verification state is verified. Spot-check delegated claims before repeating them: re-read any cited file:line location, and re-run or inspect the named validation before repeating a "tests pass" claim.`,
+    FLEET_ANTI_CHURN_RULE
+  ];
+  if (publicSpecs.length > 0) {
+    lines.push("", "User-facing agents:");
+    for (const spec of publicSpecs) {
+      const description = spec.description.trim();
+      const suffix = description.length > 0 ? ` - ${description}` : "";
+      lines.push(formatSpecLine(spec, suffix));
+    }
+  }
+  if (shadowSpecs.length > 0) {
+    lines.push("", "Shadow agents for internal orchestration:");
+    for (const spec of shadowSpecs) {
+      const description = spec.description.trim();
+      const suffix = description.length > 0 ? ` - ${description}` : "";
+      lines.push(formatSpecLine(spec, suffix));
+    }
+  }
+  return { stable: lines.join("\n"), volatile: "" };
+}
+function formatSpecLine(spec, suffix) {
+  const tags = spec.tags.length > 0 ? `, tags=${spec.tags.join("/")}` : "";
+  const skills = spec.skills.length > 0 ? `, skills=${spec.skills.join("/")}` : "";
+  const maximum = spec.budget.maximum ? `..${spec.budget.maximum.toolCalls}/${spec.budget.maximum.readReserve}` : "";
+  const budget = `, budget=${spec.budget.toolCalls}/${spec.budget.readReserve}${maximum}/${spec.budget.synthesis ? "synthesize" : "stop"}`;
+  return `- ${spec.name} [${spec.id}] (${spec.audience}, ${spec.category}, ${spec.capabilityClass}, ${spec.latencyClass}, ${spec.source}${tags}${skills}${budget})${suffix}`;
+}
+
+// src/domains/prompts/index.ts
+init_esm_shims();
+
+// src/domains/prompts/extension.ts
+init_esm_shims();
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+// src/core/clio-repo.ts
+init_esm_shims();
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+var CLIO_PACKAGE_NAME = "@iowarp/clio-coder";
+var SOURCE_MARKERS = [
+  "src/entry/orchestrator.ts",
+  "src/worker/entry.ts",
+  "src/domains/prompts/fragments/identity/clio.md"
+];
+function isFile(filePath) {
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function readPackageJson(root) {
+  try {
+    const raw = readFileSync(path.join(root, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function repositoryMatches(value) {
+  if (typeof value === "string") return value.includes("iowarp/clio-coder");
+  if (!value || typeof value !== "object") return false;
+  const url = value.url;
+  return typeof url === "string" && url.includes("iowarp/clio-coder");
+}
+function hasGitMarker(root) {
+  return existsSync(path.join(root, ".git"));
+}
+function hasSourceMarkers(root) {
+  return SOURCE_MARKERS.every((marker) => isFile(path.join(root, marker)));
+}
+function isClioCoderRepoRoot(root) {
+  const pkg = readPackageJson(root);
+  if (pkg?.name !== CLIO_PACKAGE_NAME) return false;
+  if (!repositoryMatches(pkg.repository)) return false;
+  if (!hasGitMarker(root)) return false;
+  return hasSourceMarkers(root);
+}
+function detectClioCoderRepo(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  for (; ; ) {
+    if (isClioCoderRepoRoot(current)) {
+      return { isClioCoderRepo: true, repoRoot: current };
+    }
+    if (hasGitMarker(current)) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return { isClioCoderRepo: false, repoRoot: null };
+}
+
+// src/domains/prompts/extension.ts
+var CLIO_REPO_AWARENESS_ID = "context.clio-repo-awareness";
+var WORKSPACE_ROOT_ID = "context.workspace-root";
+function createPromptsBundle(context, options = {}) {
+  let table = null;
+  let fragmentEpoch = 0;
+  let sessionSourceEpoch = 0;
+  const sessionSourceSnapshots = /* @__PURE__ */ new Map();
+  const suppressContextFiles = options.noContextFiles === true;
+  function config() {
+    return context.getContract("config");
+  }
+  function contextDomain() {
+    return context.getContract("context");
+  }
+  function agentsDomain() {
+    return context.getContract("agents");
+  }
+  function fleetRoster() {
+    const specs = agentsDomain()?.listSpecs() ?? [];
+    return specs.length > 0 ? renderFleetPromptSection(specs) : "";
+  }
+  function reload() {
+    try {
+      table = loadFragments();
+      fragmentEpoch += 1;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[clio-coder:prompts] reload failed: ${msg}
+`);
+    }
+  }
+  function diffTouchesFragments(paths) {
+    for (const p of paths) {
+      if (p.includes("prompt") || p.includes("fragment")) return true;
+    }
+    return false;
+  }
+  function sessionSourceKey(sessionId, cwd) {
+    return `${sessionId}\0${cwd}`;
+  }
+  function captureSessionSourceSnapshot(cwd) {
+    let projectContext = null;
+    if (!suppressContextFiles) {
+      projectContext = contextDomain()?.renderPromptContext(cwd) ?? null;
+      for (const warning of projectContext?.warnings ?? []) process.stderr.write(`${warning}
+`);
+    }
+    return {
+      cwd,
+      projectContext,
+      customization: captureCustomizationSources(cwd),
+      workspaceRoot: workspaceRootFragment(cwd),
+      clioRepoAwareness: clioRepoAwarenessFragments(cwd)
+    };
+  }
+  function sessionSourceSnapshot(sessionId, cwd) {
+    const key = sessionSourceKey(sessionId, cwd);
+    const existing = sessionSourceSnapshots.get(key);
+    if (existing) return existing;
+    const captured = captureSessionSourceSnapshot(cwd);
+    sessionSourceSnapshots.set(key, captured);
+    return captured;
+  }
+  function invalidateSessionSources(cwd) {
+    if (cwd === void 0) {
+      sessionSourceSnapshots.clear();
+    } else {
+      const workspace = resolve(cwd);
+      for (const [key, snapshot] of sessionSourceSnapshots) {
+        const descendant = relative(workspace, snapshot.cwd);
+        if (descendant !== ".." && !descendant.startsWith(`..${sep}`) && !isAbsolute(descendant)) {
+          sessionSourceSnapshots.delete(key);
+        }
+      }
+    }
+    sessionSourceEpoch += 1;
+  }
+  const contract = {
+    inputEpoch() {
+      return `${fragmentEpoch}:${agentsDomain()?.revision() ?? 0}:${sessionSourceEpoch}`;
+    },
+    async compileSessionPrompt(input) {
+      if (!table) throw new Error("prompts domain not started");
+      if (table.byId.size === 0) {
+        throw new Error("prompts: no fragments loaded, check startup logs");
+      }
+      const configContract = config();
+      const settings = configContract?.get();
+      const safety = input.autonomy ?? settings?.safety.autonomy ?? "auto-edit";
+      const cwd = resolve(input.cwd ?? process.cwd());
+      const sources = sessionSourceSnapshot(input.sessionId, cwd);
+      let contextFiles = "";
+      let projectPreload = null;
+      let projectHandbookFiles = [];
+      if (!suppressContextFiles) {
+        const projectContext = sources.projectContext;
+        if (projectContext) {
+          const selected = selectProjectPreload(projectContext, input.sessionInputs.providerSupportsTools ?? null);
+          contextFiles = selected.text;
+          projectPreload = selected.classification;
+          projectHandbookFiles = projectContext.handbookFiles;
+        }
+      }
+      const roster = fleetRoster();
+      const sessionInputs = {
+        ...input.sessionInputs,
+        ...contextFiles.length > 0 ? { contextFiles } : {},
+        ...roster.length > 0 ? { fleetRoster: roster } : {}
+      };
+      const compiled = compile(table, {
+        identity: "identity.clio",
+        operatingContract: "operating.contract",
+        safety: `safety.${safety}`,
+        sessionInputs,
+        additionalFragments: [
+          ...sources.workspaceRoot,
+          ...sources.clioRepoAwareness,
+          ...renderCustomizationFragments(sources.customization, cwd, input.workingContextPaths ?? []).fragments
+        ]
+      });
+      return { ...compiled, projectPreload, projectHandbookFiles };
+    },
+    async compileWorkerPrompt(input) {
+      if (!table) throw new Error("prompts domain not started");
+      if (table.byId.size === 0) {
+        throw new Error("prompts: no fragments loaded, check startup logs");
+      }
+      const { cwd: inputCwd, workingContextPaths, ...workerInputs } = input;
+      const cwd = inputCwd ?? process.cwd();
+      const customization = customizationFragments(cwd, workingContextPaths ?? []);
+      const compiled = compileWorker(table, {
+        ...workerInputs,
+        additionalFragments: customization.fragments
+      });
+      return {
+        ...compiled,
+        rulesApplied: customization.activeRuleIds,
+        operatorProfileApplied: customization.operatorProfileApplied
+      };
+    },
+    reload
+  };
+  let unsubscribeContextSources = null;
+  let unsubscribeHotReload = null;
+  let unsubscribePluginsReload = null;
+  const extension = {
+    async start() {
+      try {
+        table = loadFragments();
+        fragmentEpoch += 1;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[clio-coder:prompts] initial load failed: ${msg}
+`);
+        table = { byId: /* @__PURE__ */ new Map(), rootDir: "" };
+      }
+      unsubscribeContextSources = context.bus.on(BusChannels.ContextSourcesChanged, ({ cwd }) => {
+        invalidateSessionSources(cwd);
+      });
+      unsubscribeHotReload = context.bus.on(BusChannels.ConfigHotReload, (payload) => {
+        invalidateSessionSources();
+        const diff = payload?.diff;
+        const paths = diff?.hotReload ?? [];
+        if (!diffTouchesFragments(paths)) return;
+        reload();
+      });
+      unsubscribePluginsReload = context.bus.on(BusChannels.PluginsReloaded, () => reload());
+    },
+    async stop() {
+      unsubscribeContextSources?.();
+      unsubscribeContextSources = null;
+      unsubscribeHotReload?.();
+      unsubscribeHotReload = null;
+      unsubscribePluginsReload?.();
+      unsubscribePluginsReload = null;
+      sessionSourceSnapshots.clear();
+    }
+  };
+  return { extension, contract };
+}
+function customizationFragments(cwd, workingContextPaths) {
+  return renderCustomizationFragments(captureCustomizationSources(cwd), cwd, workingContextPaths);
+}
+function captureCustomizationSources(cwd) {
+  let rules = [];
+  let operatorProfile = null;
+  try {
+    rules = loadProjectRules(cwd).rules;
+  } catch {
+  }
+  try {
+    operatorProfile = loadOperatorProfile(cwd);
+  } catch {
+  }
+  return { rules, operatorProfile };
+}
+function renderCustomizationFragments(sources, cwd, workingContextPaths) {
+  const fragments = [];
+  let activeRuleIds = [];
+  let operatorProfileApplied = false;
+  try {
+    const active = selectActiveRules(sources.rules, normalizeWorkingContextPaths(cwd, workingContextPaths));
+    if (active.length > 0) {
+      const body = ["# Project rules", ...active.map((rule) => rule.body)].join("\n\n");
+      fragments.push({
+        id: "context.project-rules",
+        relPath: "inline/project-rules",
+        body,
+        contentHash: sha256(body),
+        dynamic: true
+      });
+      activeRuleIds = active.map((rule) => rule.id);
+    }
+  } catch {
+  }
+  try {
+    const rendered = renderOperatorProfile(sources.operatorProfile?.profile ?? {});
+    if (rendered.text.length > 0) {
+      fragments.push({
+        id: "context.operator-profile",
+        relPath: "inline/operator-profile",
+        body: rendered.text,
+        contentHash: sha256(rendered.text),
+        dynamic: true
+      });
+      operatorProfileApplied = true;
+    }
+  } catch {
+  }
+  return { fragments, activeRuleIds, operatorProfileApplied };
+}
+function normalizeWorkingContextPaths(cwd, paths) {
+  const normalized = /* @__PURE__ */ new Set();
+  for (const filePath of paths) {
+    const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) continue;
+    normalized.add(rel.replace(/\\/g, "/"));
+  }
+  return [...normalized].sort();
+}
+function workspaceRootFragment(cwd) {
+  const body = [
+    "# Workspace",
+    `Absolute workspace root: ${cwd}`,
+    "Relative paths resolve here. Do not invent a root such as /workspace or /repo, and do not pass a working directory unless the command must run in a subdirectory of this root."
+  ].join("\n");
+  return [
+    {
+      id: WORKSPACE_ROOT_ID,
+      relPath: "inline/workspace-root",
+      body,
+      contentHash: sha256(body),
+      dynamic: true
+    }
+  ];
+}
+function clioRepoAwarenessFragments(cwd) {
+  const awareness = detectClioCoderRepo(cwd);
+  if (!awareness.isClioCoderRepo || !awareness.repoRoot) return [];
+  const body = [
+    "# Clio Source Tree",
+    "This workspace is Clio Coder's own source tree.",
+    "When running inside this repo, Clio can modify her own TUI, skills, agents, tools, prompts, context/bootstrap, and harness as ordinary local source work when the user asks.",
+    "Shared contribution/publishing/push/PR/release requires explicit user intent and normal Git/GitHub etiquette. Do not imply autonomous publishing."
+  ].join("\n");
+  return [
+    {
+      id: CLIO_REPO_AWARENESS_ID,
+      relPath: "inline/clio-repo-awareness",
+      body,
+      contentHash: sha256(body),
+      dynamic: true
+    }
+  ];
+}
+
+// src/domains/prompts/manifest.ts
+init_esm_shims();
+var PromptsManifest = {
+  name: "prompts",
+  // agents: the compiled session prompt carries the fleet roster, so the
+  // recipe registry must be loaded before the first compile.
+  dependsOn: ["config", "context", "resources", "agents"]
+};
+
+// src/domains/prompts/index.ts
+function createPromptsDomainModule(options = {}) {
+  return {
+    manifest: options.noContextFiles === true ? {
+      ...PromptsManifest,
+      dependsOn: PromptsManifest.dependsOn.filter((name) => name !== "context")
+    } : PromptsManifest,
+    createExtension: (context) => createPromptsBundle(context, options)
+  };
+}
+
+// src/domains/scheduling/index.ts
+init_esm_shims();
+
+// src/domains/scheduling/extension.ts
+init_esm_shims();
+
+// src/domains/scheduling/budget.ts
+init_esm_shims();
+function createBudgetState(initialCeilingUsd) {
+  if (initialCeilingUsd < 0) throw new Error(`budget: ceiling must be >= 0 (got ${initialCeilingUsd})`);
+  let ceiling = initialCeilingUsd;
+  return {
+    get ceilingUsd() {
+      return ceiling;
+    },
+    checkCeiling(currentUsd) {
+      if (currentUsd > ceiling) return "over";
+      if (currentUsd === ceiling) return "at";
+      return "under";
+    },
+    raise(newCeilingUsd) {
+      if (newCeilingUsd < ceiling) {
+        throw new Error(`budget.raise: new ceiling ${newCeilingUsd} below current ${ceiling}`);
+      }
+      ceiling = newCeilingUsd;
+    }
+  };
+}
+
+// src/domains/scheduling/cluster.ts
+init_esm_shims();
+var LOCAL_NODE_ID = "local";
+var NODE_DEATH_FAILURE_THRESHOLD = 2;
+function freshState() {
+  return { state: "online", stateReason: null, consecutiveFailures: 0, lastSeenMs: null };
+}
+function createFleetRegistry(getNodes, options) {
+  const now = options?.now ?? (() => Date.now());
+  const runtime = /* @__PURE__ */ new Map();
+  let activeWorkers = options?.activeWorkers;
+  function stateFor(id) {
+    let state = runtime.get(id);
+    if (!state) {
+      state = freshState();
+      runtime.set(id, state);
+    }
+    return state;
+  }
+  function snapshotFor(id, config) {
+    const state = stateFor(id);
+    if (config === null) {
+      return {
+        id: LOCAL_NODE_ID,
+        host: "localhost",
+        kind: "local",
+        state: state.state,
+        stateReason: state.stateReason,
+        activeWorkers: activeWorkers?.(LOCAL_NODE_ID) ?? 0,
+        maxWorkers: options?.localMaxWorkers?.() ?? Number.POSITIVE_INFINITY,
+        labels: [],
+        lastSeenAt: state.lastSeenMs !== null ? new Date(state.lastSeenMs).toISOString() : null
+      };
+    }
+    return {
+      id: config.id,
+      host: config.host,
+      kind: "ssh",
+      state: state.state,
+      stateReason: state.stateReason,
+      activeWorkers: activeWorkers?.(id) ?? 0,
+      maxWorkers: config.maxWorkers,
+      labels: [...config.labels ?? []],
+      lastSeenAt: state.lastSeenMs !== null ? new Date(state.lastSeenMs).toISOString() : null
+    };
+  }
+  function findConfig(id) {
+    return getNodes().find((node) => node.id === id) ?? null;
+  }
+  return {
+    hasRemoteNodes() {
+      return getNodes().length > 0;
+    },
+    list() {
+      return [snapshotFor(LOCAL_NODE_ID, null), ...getNodes().map((node) => snapshotFor(node.id, node))];
+    },
+    get(id) {
+      if (id === LOCAL_NODE_ID) return snapshotFor(LOCAL_NODE_ID, null);
+      const config = findConfig(id);
+      return config ? snapshotFor(id, config) : null;
+    },
+    config(id) {
+      return id === LOCAL_NODE_ID ? null : findConfig(id);
+    },
+    seen(id) {
+      stateFor(id).lastSeenMs = now();
+    },
+    recordChannelFailure(id, reason) {
+      const state = stateFor(id);
+      state.consecutiveFailures += 1;
+      if (state.state === "online" && state.consecutiveFailures >= NODE_DEATH_FAILURE_THRESHOLD) {
+        state.state = "offline";
+        state.stateReason = `classified dead after ${state.consecutiveFailures} consecutive channel failures (${reason})`;
+      }
+      return state.state;
+    },
+    bindActiveWorkers(source) {
+      activeWorkers = source;
+    },
+    recordChannelSuccess(id) {
+      const state = stateFor(id);
+      state.consecutiveFailures = 0;
+      state.lastSeenMs = now();
+      if (state.state === "offline") {
+        state.state = "online";
+        state.stateReason = null;
+      }
+    }
+  };
+}
+
+// src/domains/scheduling/extension.ts
+var DEFAULT_MAX_WORKERS = 4;
+function resolveMaxWorkers(concurrency) {
+  if (concurrency === "auto") return DEFAULT_MAX_WORKERS;
+  return Math.max(1, concurrency);
+}
+function createSchedulingBundle(context) {
+  const maybeConfig = context.getContract("config");
+  if (!maybeConfig) throw new Error("scheduling domain requires 'config' contract");
+  const config = maybeConfig;
+  const observability = context.getContract("observability");
+  const settings = config.get();
+  let budget = createBudgetState(settings.safety.limits.sessionCostUsd);
+  const fleet = createFleetRegistry(() => config.get().fleet?.nodes ?? [], {
+    localMaxWorkers: () => resolveMaxWorkers(config.get().fleet.concurrency)
+  });
+  const unsubscribes = [];
+  function syncBudget() {
+    const nextCeiling = config.get().safety.limits.sessionCostUsd;
+    if (nextCeiling === budget.ceilingUsd) return;
+    budget = createBudgetState(nextCeiling);
+  }
+  function evaluate() {
+    syncBudget();
+    const currentUsd = observability?.sessionCost() ?? 0;
+    return { verdict: budget.checkCeiling(currentUsd), currentUsd };
+  }
+  const extension = {
+    async start() {
+      unsubscribes.push(
+        context.bus.on(BusChannels.DispatchEnqueued, () => {
+          const { verdict, currentUsd } = evaluate();
+          if (verdict !== "under") {
+            context.bus.emit(BusChannels.BudgetAlert, {
+              level: verdict,
+              currentUsd,
+              ceilingUsd: budget.ceilingUsd
+            });
+          }
+        })
+      );
+    },
+    async stop() {
+      for (const off of unsubscribes) off();
+      unsubscribes.length = 0;
+    }
+  };
+  const contract = {
+    ceilingUsd: () => {
+      syncBudget();
+      return budget.ceilingUsd;
+    },
+    checkCeiling: (current) => {
+      syncBudget();
+      return budget.checkCeiling(current);
+    },
+    raiseCeiling: (next) => {
+      budget = createBudgetState(next);
+    },
+    preflight: () => {
+      const { verdict, currentUsd } = evaluate();
+      return { verdict, currentUsd, ceilingUsd: budget.ceilingUsd };
+    },
+    maxWorkers: () => resolveMaxWorkers(config.get().fleet.concurrency),
+    fleet
+  };
+  return { extension, contract };
+}
+
+// src/domains/scheduling/manifest.ts
+init_esm_shims();
+var SchedulingManifest = {
+  name: "scheduling",
+  dependsOn: ["config", "observability"]
+};
+
+// src/domains/scheduling/index.ts
+var SchedulingDomainModule = {
+  manifest: SchedulingManifest,
+  createExtension: createSchedulingBundle
+};
+
+export {
+  renderAgentCatalogSectionsFromSpecs,
+  createPromptsDomainModule,
+  SchedulingDomainModule
+};
+//# sourceMappingURL=chunk-F7Y6QTPL.js.map