@iowarp/clio-coder 0.3.0

package/dist/chunk-3DANZDGR.js

@@ -0,0 +1,717 @@
+import {
+  loadOperatorProfile,
+  loadProjectRules,
+  renderOperatorProfile,
+  selectActiveRules
+} from "./chunk-UWIJNAOB.js";
+import {
+  compile,
+  compileWorker,
+  sha256
+} from "./chunk-GNGDQYDU.js";
+import {
+  isUserVisibleAgent
+} from "./chunk-WD6AJM35.js";
+import {
+  classifyProjectPreload
+} from "./chunk-KBR4MZZR.js";
+import {
+  BusChannels
+} from "./chunk-D5YD55AR.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/domains/prompts/extension.ts
+import { isAbsolute, relative } from "node:path";
+
+// src/core/clio-repo.ts
+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/agents/catalog.ts
+var DEFAULT_DISPATCH_AGENT_ID = "coder";
+var FLEET_PROMPT_PURPOSE_MAX_CHARS = 64;
+var FLEET_DELEGATION_RULE = "Delegate when the task has two or more independent file-scoped subtasks, or any broad exploration. You keep synthesis and validation; a single narrow change stays with you.";
+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: receipts, diffs, or telemetry -> provenance; external docs -> researcher; broad recon -> scout; tests -> tester; gates or review -> 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 ? `${spec.budget.toolCalls} calls` : "default budget";
+  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");
+  if (publicSpecs.length === 0 && shadowSpecs.length === 0) return "";
+  const lines = [
+    "# Fleet",
+    FLEET_DELEGATION_RULE,
+    FLEET_HANDOFF_RULE,
+    FLEET_ANTI_CHURN_RULE,
+    FLEET_REFUSAL_DISCLOSURE,
+    `Workers you reach with \`dispatch\`, by \`agent\` id (default ${DEFAULT_DISPATCH_AGENT_ID}). 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 budget = spec.budget ? `, budget=${spec.budget.toolCalls}/${spec.budget.readReserve}/${spec.budget.synthesis ? "synthesize" : "stop"}` : ", budget=operator-default";
+  return `- ${spec.name} [${spec.id}] (${spec.audience}, ${spec.category}, ${spec.capabilityClass}, ${spec.latencyClass}, ${spec.source}${tags}${skills}${budget})${suffix}`;
+}
+
+// src/domains/prompts/fragment-loader.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import yaml from "yaml";
+var frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var fragmentIdRegex = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+function defaultRootDir() {
+  return path2.join(resolvePackageRoot(), "src", "domains", "prompts", "fragments");
+}
+function walk(root) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = path2.join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "wiki") continue;
+      out.push(...walk(full));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+  return out.sort((left, right) => left.localeCompare(right));
+}
+function parseFragment(filePath, rootDir) {
+  const raw = readFileSync2(filePath, "utf8");
+  const rawRel = path2.relative(rootDir, filePath);
+  const relPath = rawRel.split(path2.sep).join("/");
+  const match = raw.match(frontmatterRegex);
+  if (!match) {
+    throw new Error(`fragment-loader: ${relPath}: missing or malformed YAML frontmatter`);
+  }
+  const frontmatterText = match[1] ?? "";
+  const body = match[2] ?? "";
+  let parsed;
+  try {
+    parsed = yaml.parse(frontmatterText);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`fragment-loader: ${relPath}: invalid YAML frontmatter (${reason})`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter must be a YAML object`);
+  }
+  const fm = parsed;
+  const id = fm.id;
+  if (typeof id !== "string" || !fragmentIdRegex.test(id)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.id must be a dot-separated namespace`);
+  }
+  const version = fm.version;
+  if (version !== 1) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.version must be 1`);
+  }
+  const description = fm.description;
+  if (typeof description !== "string" || description.trim() === "") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.description must be a non-empty string`);
+  }
+  const dynamicRaw = fm.dynamic;
+  if (dynamicRaw !== void 0 && typeof dynamicRaw !== "boolean") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.dynamic must be a boolean when present`);
+  }
+  return {
+    path: filePath,
+    relPath,
+    id,
+    version,
+    description,
+    dynamic: dynamicRaw === true,
+    body,
+    contentHash: sha256(raw)
+  };
+}
+function loadFragments(options) {
+  const rootDir = typeof options === "string" ? options : options?.rootDir;
+  const resolvedRoot = rootDir ? path2.resolve(rootDir) : defaultRootDir();
+  const files = walk(resolvedRoot);
+  const byId = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const fragment = parseFragment(file, resolvedRoot);
+    const existing = byId.get(fragment.id);
+    if (existing) {
+      throw new Error(
+        `fragment-loader: duplicate fragment id "${fragment.id}" in ${existing.relPath} and ${fragment.relPath}`
+      );
+    }
+    byId.set(fragment.id, fragment);
+  }
+  return { byId, rootDir: resolvedRoot };
+}
+
+// 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;
+  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();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[clio:prompts] reload failed: ${msg}
+`);
+    }
+  }
+  function diffTouchesFragments(paths) {
+    for (const p of paths) {
+      if (p.includes("prompt") || p.includes("fragment")) return true;
+    }
+    return false;
+  }
+  const contract = {
+    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?.autonomy ?? "auto-edit";
+      const cwd = input.cwd ?? process.cwd();
+      let contextFiles = "";
+      let projectPreload = null;
+      if (!suppressContextFiles) {
+        const projectContext = contextDomain()?.renderPromptContext(cwd);
+        contextFiles = projectContext ? selectProjectContext(projectContext, input.sessionInputs.providerSupportsTools ?? null) : "";
+        if (projectContext) {
+          projectPreload = classifyProjectPreload({
+            hasClioMd: projectContext.clioMd !== null,
+            text: projectContext.text
+          });
+        }
+        for (const warning of projectContext?.warnings ?? []) process.stderr.write(`${warning}
+`);
+      }
+      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: [
+          ...workspaceRootFragment(cwd),
+          ...clioRepoAwarenessFragments(cwd),
+          ...customizationFragments(cwd, input.workingContextPaths ?? [])
+        ]
+      });
+      return { ...compiled, projectPreload };
+    },
+    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");
+      }
+      return compileWorker(table, input);
+    },
+    reload
+  };
+  let unsubscribeHotReload = null;
+  const extension = {
+    async start() {
+      try {
+        table = loadFragments();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[clio:prompts] initial load failed: ${msg}
+`);
+        table = { byId: /* @__PURE__ */ new Map(), rootDir: "" };
+      }
+      unsubscribeHotReload = context.bus.on(BusChannels.ConfigHotReload, (payload) => {
+        const diff = payload?.diff;
+        const paths = diff?.hotReload ?? [];
+        if (!diffTouchesFragments(paths)) return;
+        reload();
+      });
+    },
+    async stop() {
+      unsubscribeHotReload?.();
+      unsubscribeHotReload = null;
+    }
+  };
+  return { extension, contract };
+}
+function customizationFragments(cwd, workingContextPaths) {
+  const fragments = [];
+  try {
+    const loaded = loadProjectRules(cwd);
+    const active = selectActiveRules(loaded.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
+      });
+    }
+  } catch {
+  }
+  try {
+    const profile = loadOperatorProfile(cwd);
+    const rendered = renderOperatorProfile(profile.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
+      });
+    }
+  } catch {
+  }
+  return fragments;
+}
+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
+    }
+  ];
+}
+function projectTypeFromPromptContext(text) {
+  const match = /<project-type>([^<]+)<\/project-type>/.exec(text);
+  const value = match?.[1]?.trim();
+  return value && value !== "unknown" ? value : null;
+}
+function hasCodewiki(text) {
+  return text.includes("<codewiki>");
+}
+function wikiAvailabilityFromPromptContext(text) {
+  const match = /<wiki>([^<]+)<\/wiki>/.exec(text);
+  const value = match?.[1]?.trim();
+  return value && value.length > 0 ? value : null;
+}
+function renderProjectSynopsis(context, providerSupportsTools) {
+  const projectType = projectTypeFromPromptContext(context.text);
+  const wiki = wikiAvailabilityFromPromptContext(context.text);
+  const lines = ["<project-synopsis>"];
+  if (projectType) lines.push(`Language: ${projectType}`);
+  if (context.clioMd) {
+    lines.push(`Project: ${context.clioMd.projectName}`);
+    lines.push(
+      "CLIO-CODER.md: available; compact synopsis only because the handbook is too large for automatic preload."
+    );
+  }
+  if (hasCodewiki(context.text)) lines.push("Codewiki: available via code_nav.");
+  if (wiki) lines.push(`Wiki: ${wiki}`);
+  if (providerSupportsTools === false) {
+    lines.push("Tools: unavailable for this target; use this synopsis only as fallback context.");
+  } else {
+    lines.push('Retrieve exact repository facts with context(scope="workspace"), code_nav, grep, and read.');
+  }
+  lines.push("</project-synopsis>");
+  return lines.join("\n");
+}
+function selectProjectContext(context, providerSupportsTools) {
+  const preload = classifyProjectPreload({ hasClioMd: context.clioMd !== null, text: context.text });
+  if (preload.mode === "none") return "";
+  if (preload.mode === "full") return context.text.trim();
+  return renderProjectSynopsis(context, providerSupportsTools);
+}
+
+// src/domains/prompts/manifest.ts
+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/budget.ts
+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
+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.budget.sessionCeilingUsd);
+  const fleet = createFleetRegistry(() => config.get().fleet?.nodes ?? [], {
+    localMaxWorkers: () => resolveMaxWorkers(config.get().budget.concurrency)
+  });
+  const unsubscribes = [];
+  function syncBudget() {
+    const nextCeiling = config.get().budget.sessionCeilingUsd;
+    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().budget.concurrency),
+    fleet
+  };
+  return { extension, contract };
+}
+
+// src/domains/scheduling/manifest.ts
+var SchedulingManifest = {
+  name: "scheduling",
+  dependsOn: ["config", "observability"]
+};
+
+// src/domains/scheduling/index.ts
+var SchedulingDomainModule = {
+  manifest: SchedulingManifest,
+  createExtension: createSchedulingBundle
+};
+
+export {
+  renderAgentCatalogSectionsFromSpecs,
+  createPromptsDomainModule,
+  SchedulingDomainModule
+};
+//# sourceMappingURL=chunk-3DANZDGR.js.map