@structured-vibe-coding/core 0.18.0 → 0.19.0

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   mcpTimeoutMs,
   toProcessEnv,
   withMcpSource
-} from "./chunk-QGP43XCN.js";
+} from "./chunk-H55RFAEI.js";
 import {
   McpConfigSchema,
   McpInvokeSchema,
@@ -39,13 +39,6 @@ import {
   agentKickoffMessage,
   assertAgentInstallable,
   contentHash,
-  defaultMcpYamlPath,
-  defaultMemoryDir,
-  defaultPricesYamlPath,
-  defaultSearchYamlPath,
-  defaultTemplatesDir,
-  defaultWorkflowsDir,
-  defaultsRoot,
   describeFsError,
   describeKept,
   generatedState,
@@ -55,11 +48,13 @@ import {
   integrationKeyFor,
   loadGeneratedManifest,
   loadInstalledAgent,
+  loadProductTeam,
   markGenerated,
   optionForTarget,
   parseAgentTargets,
   parseIntegration,
   planAgentIntegration,
+  productTeamHome,
   reconcileGeneratedTree,
   refreshActiveAgentContext,
   refreshConfiguredGuidance,
@@ -67,14 +62,16 @@ import {
   removeOtherAgentHostsDetailed,
   renderAgentsMd,
   renderMemoryIndex,
+  renderProductTeamSection,
   renderProtocolMd,
   renderSddReadme,
   renderThinAgent,
   saveGeneratedManifest,
   writeAgentHandoff
-} from "./chunk-4PIRWYRA.js";
+} from "./chunk-26YG6A4M.js";
 import {
   ChangeMetricsSchema,
+  DecisionMetricSchema,
   PhaseMetricSchema,
   TokenUsageMetricSchema,
   advanceStage,
@@ -93,6 +90,9 @@ import {
   parseFeaturesBacklog,
   promoteGreenfieldToMemory,
   readChangeMetrics,
+  recordDecisionMetric,
+  recordDecisionRequest,
+  recordSignoff,
   skipStage,
   startFeatureFromBacklog,
   startGreenfield,
@@ -100,60 +100,95 @@ import {
   switchWorkflow,
   transitionPhase,
   updateFeatureStatus
-} from "./chunk-LHSR7JG2.js";
+} from "./chunk-2FJBFYVJ.js";
 import {
   EMBEDDINGS_UNAVAILABLE,
   EMBEDDING_MODEL,
+  ModelsConfigSchema,
+  ROLE_TEXT,
   RRF_K,
   SUMMARY_TOKEN_CAP,
   SearchConfigError,
+  TeamSchema,
+  WORK_TYPES,
+  allowFilePath,
   budgetForStage,
   buildAgentPrompt,
   buildRetrievedInner,
+  canonicalRoleName,
+  checkModels,
+  checkTeam,
   chunkCode,
   chunkMarkdown,
   classifyPath,
   clearRegisteredSearchProviders,
+  conversationDir,
   countTokens,
   createBuiltinProvider,
   createFastembedEmbedder,
+  createRole,
+  createRoleFromTemplate,
   defaultConfig,
+  deleteRole,
+  duplicateRole,
+  editRole,
   embedSearchQuery,
   executeSearch,
   extractiveSummary,
   fallbackWarning,
   fastembedImportCount,
   formatStatus,
+  formatTeam,
   ftsTokens,
   fuseByRank,
   fuseHits,
   getHeadSha,
+  gitUserName,
+  hideRole,
+  initTeam,
   isHardDenied,
   isIgnoredPath,
   isInitialized,
   isPrunedDir,
   isSecretPath,
+  isWorkType,
   keywordHits,
+  listConversationRoles,
+  listRoleTemplates,
   listScopeHits,
+  listTeamTemplates,
   loadConfig,
   loadExcluder,
+  loadModels,
   loadSearchConfig,
+  memoryDir as memoryDir2,
   mergeConfigDefaults,
   mergeRankedHits,
   packHits,
+  parseRoleDocument,
+  pinRole,
   rankScope,
+  readAllowFile,
   readPackedCache,
+  readRole,
+  readTeamConfig,
   registerSearchProvider,
   renderBlock,
   resolveActiveDirectory,
+  resolveBot,
   resolveEmbedder,
   resolveSearchProvider,
+  roleFilePath,
   rrf,
   saveConfig,
   scopeForPath,
   searchPreamble,
+  searchProject,
+  showRoles,
+  showTeam,
+  workKind,
   writePackedCache
-} from "./chunk-44LQ5BKZ.js";
+} from "./chunk-TGRV6WGS.js";
 import {
   ArtifactDefSchema,
   ChangeMetaSchema,
@@ -166,15 +201,25 @@ import {
   buildContext,
   changeDirName,
   clearActiveIf,
+  defaultMcpYamlPath,
+  defaultMemoryDir,
+  defaultPricesYamlPath,
+  defaultSearchYamlPath,
+  defaultTeamsDir,
+  defaultTemplatesDir,
+  defaultWorkflowsDir,
+  defaultsRoot,
   firstActiveStageId,
   getActiveChangeId,
   getStage,
   inferComplexity,
   isStageSkipped,
+  listBundledWorkflowNames,
   listChanges,
   listWorkflowNames,
   loadChangeMeta,
   loadWorkflow,
+  missingBundledWorkflows,
   nextStageId,
   nowIso,
   recommendWorkflow,
@@ -185,8 +230,9 @@ import {
   shouldAutoSkip,
   slugify,
   todayIsoDate,
-  uniqueChangeDirName
-} from "./chunk-QHV5KZKX.js";
+  uniqueChangeDirName,
+  workflowUnavailableMessage
+} from "./chunk-HG7TPW5V.js";
 import {
   SddError,
   errorMessage,
@@ -245,6 +291,7 @@ var PricesSchema = z.object({
   }).catchall(PriceCardSchema)
 });
 var TOKEN_HEADER = "source  phase  provider  model  requests  input  cache_read  cache_write  output  usd  inr";
+var DECISION_HEADER = "work_type  kind  provider  model  calls  input  cache_read  cache_write  output  usd  inr";
 function finiteMs(startIso, endMs) {
   const start = Date.parse(startIso);
   if (!Number.isFinite(start) || !Number.isFinite(endMs)) return 0;
@@ -291,14 +338,14 @@ function stripLeadingZeros(digits) {
 }
 function rateUnits(rate) {
   if (!Number.isFinite(rate) || rate < 0) throw new Error("prices.yaml is invalid");
-  let text;
+  let text2;
   try {
-    text = rate.toFixed(9);
+    text2 = rate.toFixed(9);
   } catch {
     throw new Error("prices.yaml is invalid");
   }
-  const negative = text.startsWith("-");
-  const unsigned = negative ? text.slice(1) : text;
+  const negative = text2.startsWith("-");
+  const unsigned = negative ? text2.slice(1) : text2;
   const dot = unsigned.indexOf(".");
   const whole = dot === -1 ? unsigned : unsigned.slice(0, dot);
   const frac = dot === -1 ? "" : unsigned.slice(dot + 1, dot + 10);
@@ -476,9 +523,67 @@ function renderChangeReport(input) {
     for (const request of input.metrics.requests) addRequest(total, request);
     lines.push(`  ${totalLine(total, input.metrics, input.prices)}`);
   }
+  const decisions = decisionSection(input.metrics, input.prices);
+  if (decisions.length > 0) {
+    lines.push("Decisions:");
+    lines.push(`  ${DECISION_HEADER}`);
+    for (const line of decisions) lines.push(`  ${line}`);
+  }
   if (input.prices === null) lines.push("prices.yaml is missing");
   return lines.join("\n");
 }
+function groupDecisions(metrics) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of metrics.decisions ?? []) {
+    const model = row.model ?? null;
+    const key = `${row.workType}\0${row.kind}\0${row.provider}\0${model ?? ""}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = {
+        workType: row.workType,
+        kind: row.kind,
+        provider: row.provider,
+        model,
+        totals: emptyTotals()
+      };
+      groups.set(key, group);
+    }
+    group.totals.requests += 1;
+    group.totals.input = addCount(group.totals.input, row.inputTokens);
+    group.totals.cacheRead = addCount(group.totals.cacheRead, row.cacheReadTokens);
+    group.totals.cacheWrite = addCount(group.totals.cacheWrite, row.cacheWriteTokens);
+    group.totals.output = addCount(group.totals.output, row.outputTokens);
+  }
+  const order = ["route", "classify", "check", "draft", "design", "code", "review"];
+  return [...groups.values()].sort((left, right) => {
+    const workDelta = order.indexOf(left.workType) - order.indexOf(right.workType);
+    if (workDelta !== 0) return workDelta;
+    const kindDelta = left.kind.localeCompare(right.kind);
+    if (kindDelta !== 0) return kindDelta;
+    const providerDelta = left.provider.localeCompare(right.provider);
+    if (providerDelta !== 0) return providerDelta;
+    return (left.model ?? "").localeCompare(right.model ?? "");
+  });
+}
+function decisionSection(metrics, prices) {
+  return groupDecisions(metrics).map((group) => {
+    const card = prices ? cardFor(prices, group.provider, group.model) : null;
+    const cost = prices && card ? costFor(group.totals, card, prices.usd_to_inr) : { usd: "n/a", inr: "n/a" };
+    return [
+      group.workType,
+      group.kind,
+      group.provider,
+      modelCell(group.model),
+      String(group.totals.requests),
+      cell(group.totals.input),
+      cell(group.totals.cacheRead),
+      cell(group.totals.cacheWrite),
+      cell(group.totals.output),
+      cost.usd,
+      cost.inr
+    ].join("  ");
+  });
+}
 function requestUsdNumerator(request, card) {
   const parts = [
     [request.inputTokens, card.input_per_million_usd],
@@ -535,8 +640,8 @@ function compareChangesByFirstPhase(left, right) {
 }
 async function readHandoffCodePoints(projectRoot) {
   try {
-    const text = await readText(join(sddRoot(projectRoot), "handoff.md"));
-    return Array.from(text).length;
+    const text2 = await readText(join(sddRoot(projectRoot), "handoff.md"));
+    return Array.from(text2).length;
   } catch (err) {
     const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
     if (code === "ENOENT") return null;
@@ -612,13 +717,13 @@ metrics.json is invalid`
 import { join as join2 } from "pathe";
 var VERIFY_MARKER = /<!-- sdd:verify stage="([^"]+)" head_sha="(?:none|[0-9a-f]{40}|[0-9a-f]{64})" result_count="(\d+)" -->/gi;
 async function syncChangeHead(projectRoot, config, changeId, opts) {
-  const headSha = opts?.headSha !== void 0 ? opts.headSha : await getHeadSha(projectRoot);
-  if (!headSha) throw new Error("Cannot sync: Git HEAD is unavailable in this project.");
+  const headSha2 = opts?.headSha !== void 0 ? opts.headSha : await getHeadSha(projectRoot);
+  if (!headSha2) throw new Error("Cannot sync: Git HEAD is unavailable in this project.");
   const ctx = await buildContext(projectRoot, config, changeId);
   let updatedResults = 0;
-  for (const result of Object.values(ctx.meta.verify_results ?? {})) {
-    if (!result.results.length || result.head_sha === headSha) continue;
-    result.head_sha = headSha;
+  for (const result2 of Object.values(ctx.meta.verify_results ?? {})) {
+    if (!result2.results.length || result2.head_sha === headSha2) continue;
+    result2.head_sha = headSha2;
     updatedResults += 1;
   }
   if (updatedResults) await saveChangeMeta(projectRoot, config, ctx.meta);
@@ -631,7 +736,7 @@ async function syncChangeHead(projectRoot, config, changeId, opts) {
     if (markers.length) {
       const updated = report.replace(
         VERIFY_MARKER,
-        (_marker, stage, resultCount) => `<!-- sdd:verify stage="${stage}" head_sha="${headSha}" result_count="${resultCount}" -->`
+        (_marker, stage, resultCount) => `<!-- sdd:verify stage="${stage}" head_sha="${headSha2}" result_count="${resultCount}" -->`
       );
       if (updated !== report) {
         await writeText(reportPath, updated);
@@ -641,20 +746,144 @@ async function syncChangeHead(projectRoot, config, changeId, opts) {
       reportPreserved = true;
     }
   }
-  return { changeId, headSha, updatedResults, reportUpdated, reportPreserved };
+  return { changeId, headSha: headSha2, updatedResults, reportUpdated, reportPreserved };
+}
+
+// src/token-inventory.ts
+import { join as join3 } from "pathe";
+async function readIfExists(path) {
+  if (!await pathExists(path)) return null;
+  return readText(path);
+}
+async function workflowFileTokens(projectRoot, name) {
+  const dir = workflowsDir(projectRoot);
+  for (const ext of ["yaml", "yml"]) {
+    const text2 = await readIfExists(join3(dir, `${name}.${ext}`));
+    if (text2 !== null) return countTokens(text2);
+  }
+  return null;
+}
+async function templateBody(projectRoot, artifact) {
+  const dir = templatesDir(projectRoot);
+  const names = artifact.template ? [artifact.template, artifact.template.replace(/^templates\//, ""), `${artifact.id}.md`] : [`${artifact.id}.md`];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const path = join3(dir, name);
+    if (seen.has(path)) continue;
+    seen.add(path);
+    const text2 = await readIfExists(path);
+    if (text2 !== null) return text2;
+  }
+  return null;
+}
+function pushArtifactLines(lines, stageId, path, label) {
+  lines.push(`  ${stageId}  ${path}  ${label}`);
+  const tokens = Number(label);
+  return Number.isInteger(tokens) && String(tokens) === label ? tokens : 0;
+}
+async function workflowLines(projectRoot, name) {
+  let workflow;
+  try {
+    workflow = await loadWorkflow(projectRoot, name);
+  } catch {
+    return [`${name}  unreadable`];
+  }
+  const fileTokens = await workflowFileTokens(projectRoot, name);
+  const lines = [`${name}  workflow ${fileTokens === null ? "missing" : fileTokens}`];
+  let total = 0;
+  let any = false;
+  for (const stage of workflow.stages) {
+    for (const artifact of stage.artifacts) {
+      any = true;
+      if (artifact.path.endsWith("/")) {
+        total += pushArtifactLines(lines, stage.id, artifact.path, "directory");
+        continue;
+      }
+      const body = await templateBody(projectRoot, artifact);
+      total += pushArtifactLines(
+        lines,
+        stage.id,
+        artifact.path,
+        body === null ? "missing" : String(countTokens(body))
+      );
+    }
+  }
+  lines.push(any ? `  artifacts ${total}` : "  (no artifacts)");
+  return lines;
+}
+async function changeLines(projectRoot, config, id) {
+  const dir = changePath(projectRoot, config, id);
+  let workflowName = "";
+  let workflow;
+  try {
+    const meta = ChangeMetaSchema.parse(await readYaml(join3(dir, "meta.yaml")));
+    workflowName = meta.workflow;
+    workflow = await loadWorkflow(projectRoot, meta.workflow);
+  } catch {
+    return [`Change ${id}  unreadable`];
+  }
+  const lines = [`Change ${id}  workflow ${workflowName}`];
+  let total = 0;
+  let any = false;
+  for (const stage of workflow.stages) {
+    for (const artifact of stage.artifacts) {
+      any = true;
+      if (artifact.path.endsWith("/")) {
+        const folder = join3(dir, artifact.path);
+        const names = (await listFiles(folder)).sort();
+        if (names.length === 0) {
+          total += pushArtifactLines(lines, stage.id, artifact.path, "directory");
+          continue;
+        }
+        for (const name of names) {
+          const text3 = await readText(join3(folder, name));
+          total += pushArtifactLines(
+            lines,
+            stage.id,
+            `${artifact.path}${name}`,
+            String(countTokens(text3))
+          );
+        }
+        continue;
+      }
+      const text2 = await readIfExists(join3(dir, artifact.path));
+      total += pushArtifactLines(
+        lines,
+        stage.id,
+        artifact.path,
+        text2 === null ? "not written" : String(countTokens(text2))
+      );
+    }
+  }
+  lines.push(any ? `  artifacts ${total}` : "  (no artifacts)");
+  return lines;
+}
+async function formatTokenInventory(projectRoot, config) {
+  const lines = ["Tokens (cl100k):"];
+  const names = await listWorkflowNames(projectRoot);
+  if (names.length === 0) lines.push("No workflows.");
+  for (const name of names) {
+    lines.push(...await workflowLines(projectRoot, name));
+  }
+  const active = await getActiveChangeId(projectRoot, config);
+  if (active) {
+    lines.push("");
+    lines.push(...await changeLines(projectRoot, config, active));
+  }
+  return lines.join("\n");
 }
 
 // src/init.ts
 import { spawn } from "child_process";
 import { lstat } from "fs/promises";
-import { join as join3 } from "pathe";
+import { join as join4 } from "pathe";
 async function initProject(opts) {
   const { projectRoot, force = false } = opts;
   const created = [];
   const kept = [];
   const warnings = [];
   const root = sddRoot(projectRoot);
-  const configFile = join3(root, "config.yaml");
+  const configFile = join4(root, "config.yaml");
   if (await pathExists(configFile) && !force) {
     await repairRequiredIgnores(projectRoot);
     return { created, config: await loadConfig(projectRoot), kept, warnings };
@@ -670,12 +899,12 @@ async function initProject(opts) {
   const config = await pathExists(configFile) ? mergeConfigDefaults(await readYaml(configFile)) : defaultConfig();
   if (opts.layoutRoot !== void 0) {
     const layoutRoot = validateLayoutRoot(opts.layoutRoot);
-    config.memory_path = join3(layoutRoot, "memory");
-    config.changes_path = join3(layoutRoot, "changes");
-    config.domains_path = join3(layoutRoot, "domains");
-    config.archive_path = join3(layoutRoot, "archive");
+    config.memory_path = join4(layoutRoot, "memory");
+    config.changes_path = join4(layoutRoot, "changes");
+    config.domains_path = join4(layoutRoot, "domains");
+    config.archive_path = join4(layoutRoot, "archive");
   }
-  const manifestPath = join3(root, ".generated.json");
+  const manifestPath = join4(root, ".generated.json");
   const manifestExisted = await pathExists(manifestPath);
   const manifest = await loadGeneratedManifest(manifestPath);
   if (opts.agents) {
@@ -683,11 +912,11 @@ async function initProject(opts) {
   }
   await ensureDir(root);
   await saveConfig(projectRoot, config);
-  created.push(join3(root, "config.yaml"));
+  created.push(join4(root, "config.yaml"));
   const wfDest = workflowsDir(projectRoot);
   const wfSrc = defaultWorkflowsDir();
   if (await pathExists(wfSrc)) {
-    const result = await reconcileGeneratedTree(
+    const result2 = await reconcileGeneratedTree(
       projectRoot,
       wfSrc,
       wfDest,
@@ -695,7 +924,7 @@ async function initProject(opts) {
       manifest,
       force
     );
-    kept.push(...result.kept);
+    kept.push(...result2.kept);
     created.push(wfDest);
   } else {
     await ensureDir(wfDest);
@@ -703,7 +932,7 @@ async function initProject(opts) {
   const tDest = templatesDir(projectRoot);
   const tSrc = defaultTemplatesDir();
   if (await pathExists(tSrc)) {
-    const result = await reconcileGeneratedTree(
+    const result2 = await reconcileGeneratedTree(
       projectRoot,
       tSrc,
       tDest,
@@ -711,7 +940,7 @@ async function initProject(opts) {
       manifest,
       force
     );
-    kept.push(...result.kept);
+    kept.push(...result2.kept);
     created.push(tDest);
   } else {
     await ensureDir(tDest);
@@ -725,13 +954,13 @@ async function initProject(opts) {
     if (wrote) created.push(mcpDest);
   }
   const pricesSrc = defaultPricesYamlPath();
-  const pricesDest = join3(root, "prices.yaml");
+  const pricesDest = join4(root, "prices.yaml");
   if (await pathExists(pricesSrc)) {
     const wrote = await writeTextIfMissing(pricesDest, await readText(pricesSrc));
     if (wrote) created.push(pricesDest);
   }
   const searchSrc = defaultSearchYamlPath();
-  const searchDest = join3(root, "search.yaml");
+  const searchDest = join4(root, "search.yaml");
   if (await pathExists(searchSrc)) {
     const wrote = await writeTextIfMissing(searchDest, await readText(searchSrc));
     if (wrote) created.push(searchDest);
@@ -749,7 +978,7 @@ async function initProject(opts) {
     await copyDirSkipExisting(mSrc, mDest);
   } else {
     await writeTextIfMissing(
-      join3(mDest, "index.md"),
+      join4(mDest, "index.md"),
       `# Documentation map
 
 Parent page for **stable** project docs. Start here, then open only what you need.
@@ -765,11 +994,11 @@ Active work: \`.sdd/active-context.md\` and the configured changes folder.
 `
     );
     await writeTextIfMissing(
-      join3(mDest, "product.md"),
+      join4(mDest, "product.md"),
       "# Product\n\n<!-- What are you building? -->\n"
     );
     await writeTextIfMissing(
-      join3(mDest, "constitution.md"),
+      join4(mDest, "constitution.md"),
       `# Constitution
 
 <!-- Non-negotiables agents must not violate. Broader style lives in conventions.md. -->
@@ -796,21 +1025,21 @@ Active work: \`.sdd/active-context.md\` and the configured changes folder.
 `
     );
     await writeTextIfMissing(
-      join3(mDest, "architecture.md"),
+      join4(mDest, "architecture.md"),
       "# Architecture\n\n<!-- High-level system shape -->\n"
     );
     await writeTextIfMissing(
-      join3(mDest, "conventions.md"),
+      join4(mDest, "conventions.md"),
       "# Conventions\n\n<!-- Coding and process conventions -->\n"
     );
   }
-  if (!await pathExists(join3(mDest, "constitution.md"))) {
-    const fromDefault = join3(mSrc, "constitution.md");
+  if (!await pathExists(join4(mDest, "constitution.md"))) {
+    const fromDefault = join4(mSrc, "constitution.md");
     if (await pathExists(fromDefault)) {
       await copyDirSkipExisting(mSrc, mDest);
     } else {
       await writeTextIfMissing(
-        join3(mDest, "constitution.md"),
+        join4(mDest, "constitution.md"),
         `# Constitution
 
 <!-- Non-negotiables agents must not violate. Broader style lives in conventions.md. -->
@@ -843,10 +1072,10 @@ Active work: \`.sdd/active-context.md\` and the configured changes folder.
   await ensureDir(domainsDir(projectRoot, config));
   created.push(changesDir(projectRoot, config));
   created.push(domainsDir(projectRoot, config));
-  await writeTextIfMissing(join3(changesDir(projectRoot, config), ".gitkeep"), "");
-  await writeTextIfMissing(join3(domainsDir(projectRoot, config), ".gitkeep"), "");
-  const sddIgnore = join3(root, ".gitignore");
-  const changesIgnore = join3(changesDir(projectRoot, config), ".gitignore");
+  await writeTextIfMissing(join4(changesDir(projectRoot, config), ".gitkeep"), "");
+  await writeTextIfMissing(join4(domainsDir(projectRoot, config), ".gitkeep"), "");
+  const sddIgnore = join4(root, ".gitignore");
+  const changesIgnore = join4(changesDir(projectRoot, config), ".gitignore");
   if ((await ensureIgnoreEntries(sddIgnore, SDD_IGNORE_LINES)).created) {
     created.push(sddIgnore);
   }
@@ -867,7 +1096,7 @@ Active work: \`.sdd/active-context.md\` and the configured changes folder.
       );
     }
   }
-  const sddReadme = join3(root, "README.md");
+  const sddReadme = join4(root, "README.md");
   const readmeState = await pathExists(sddReadme) ? generatedState(await readText(sddReadme)) : null;
   if (readmeState === "edited" || readmeState === "not-generated") {
     kept.push({ path: ".sdd/README.md", reason: readmeState });
@@ -901,8 +1130,8 @@ var SDD_IGNORE_LINES = [
 async function repairRequiredIgnores(projectRoot) {
   const config = await loadConfig(projectRoot);
   const root = sddRoot(projectRoot);
-  const sdd = await ensureIgnoreEntries(join3(root, ".gitignore"), SDD_IGNORE_LINES);
-  const changes = await ensureIgnoreEntries(join3(changesDir(projectRoot, config), ".gitignore"), [
+  const sdd = await ensureIgnoreEntries(join4(root, ".gitignore"), SDD_IGNORE_LINES);
+  const changes = await ensureIgnoreEntries(join4(changesDir(projectRoot, config), ".gitignore"), [
     ".active"
   ]);
   return sdd.added || changes.added;
@@ -957,7 +1186,7 @@ async function listRelativeFiles(directory, prefix = "") {
   );
   const nested = await Promise.all(
     (await listDirs(directory)).map(
-      (name) => listRelativeFiles(join3(directory, name), [prefix, name].filter(Boolean).join("/"))
+      (name) => listRelativeFiles(join4(directory, name), [prefix, name].filter(Boolean).join("/"))
     )
   );
   return [...files, ...nested.flat()];
@@ -965,7 +1194,7 @@ async function listRelativeFiles(directory, prefix = "") {
 
 // src/verify.ts
 import { spawn as spawn2 } from "child_process";
-import { join as join4 } from "pathe";
+import { join as join5 } from "pathe";
 function runCommand(command, cwd) {
   return new Promise((resolve) => {
     const child = spawn2(command, {
@@ -1013,7 +1242,7 @@ var STATUS_LABEL = {
   fail: "FAIL",
   not_run: "NOT RUN"
 };
-function buildSummaryLines(title, stageId, headSha, status, reason, results, checklist) {
+function buildSummaryLines(title, stageId, headSha2, status, reason, results, checklist) {
   const lines = [
     `<!-- sdd:verify-report:start -->`,
     ``,
@@ -1021,7 +1250,7 @@ function buildSummaryLines(title, stageId, headSha, status, reason, results, che
     ``,
     `> Change: ${title}`,
     `> Stage: ${stageId}`,
-    `<!-- sdd:verify stage="${stageId}" head_sha="${headSha ?? "none"}" result_count="${results.length}" -->`,
+    `<!-- sdd:verify stage="${stageId}" head_sha="${headSha2 ?? "none"}" result_count="${results.length}" -->`,
     `> At: ${nowIso()}`,
     `> Overall: ${STATUS_LABEL[status]}${reason ? ` \u2014 ${reason}` : ""}`,
     ``,
@@ -1072,23 +1301,23 @@ async function runLocalVerify(projectRoot, config, changeId, opts) {
       ok: false
     };
   }
-  const headSha = opts?.headSha !== void 0 ? opts.headSha : await getHeadSha(projectRoot);
+  const headSha2 = opts?.headSha !== void 0 ? opts.headSha : await getHeadSha(projectRoot);
   const anyRecordedSha = Object.entries(ctx.meta.verify_results ?? {}).find(
     ([, recorded]) => recorded.head_sha
   );
-  if (anyRecordedSha && !headSha) {
+  if (anyRecordedSha && !headSha2) {
     throw new Error(
-      `Cannot validate recorded SHA in ${join4(ctx.path, "meta.yaml")} at verify_results.${anyRecordedSha[0]}.head_sha because Git HEAD is unavailable.`
+      `Cannot validate recorded SHA in ${join5(ctx.path, "meta.yaml")} at verify_results.${anyRecordedSha[0]}.head_sha because Git HEAD is unavailable.`
     );
   }
   for (const [resultStage, recorded] of Object.entries(ctx.meta.verify_results ?? {})) {
-    if (recorded.head_sha && headSha && recorded.head_sha !== headSha) {
+    if (recorded.head_sha && headSha2 && recorded.head_sha !== headSha2) {
       throw new Error(
-        `Stale SHA in ${join4(ctx.path, "meta.yaml")} at verify_results.${resultStage}.head_sha: recorded ${recorded.head_sha}, current HEAD ${headSha}. Run sdd sync ${changeId}.`
+        `Stale SHA in ${join5(ctx.path, "meta.yaml")} at verify_results.${resultStage}.head_sha: recorded ${recorded.head_sha}, current HEAD ${headSha2}. Run sdd sync ${changeId}.`
       );
     }
   }
-  const summaryPath = join4(ctx.path, "local-test-results.md");
+  const summaryPath = join5(ctx.path, "local-test-results.md");
   if (await pathExists(summaryPath)) {
     const existing = await readText(summaryPath);
     const markerPattern = /<!-- sdd:verify stage="([^"]+)" head_sha="(none|[0-9a-f]{40}|[0-9a-f]{64})" result_count="(\d+)" -->/gi;
@@ -1099,17 +1328,17 @@ async function runLocalVerify(projectRoot, config, changeId, opts) {
       const reportResult = ctx.meta.verify_results?.[reportStage];
       if (!reportResult) {
         throw new Error(
-          `Missing verification metadata in ${join4(ctx.path, "meta.yaml")} for ${summaryPath}:${line} (${reportStage}).`
+          `Missing verification metadata in ${join5(ctx.path, "meta.yaml")} for ${summaryPath}:${line} (${reportStage}).`
         );
       }
-      if (reportSha !== "none" && !headSha) {
+      if (reportSha !== "none" && !headSha2) {
         throw new Error(
           `Cannot validate SHA in ${summaryPath}:${line} because Git HEAD is unavailable.`
         );
       }
-      if (headSha && reportSha !== "none" && reportSha !== headSha) {
+      if (headSha2 && reportSha !== "none" && reportSha !== headSha2) {
         throw new Error(
-          `Stale SHA in ${summaryPath}:${line}: recorded ${reportSha}, current HEAD ${headSha}. Run sdd sync ${changeId}.`
+          `Stale SHA in ${summaryPath}:${line}: recorded ${reportSha}, current HEAD ${headSha2}. Run sdd sync ${changeId}.`
         );
       }
       if (reportResult && Number(marker[3]) !== reportResult.results.length) {
@@ -1119,13 +1348,13 @@ async function runLocalVerify(projectRoot, config, changeId, opts) {
       }
       if (reportResult?.head_sha && reportSha !== reportResult.head_sha) {
         throw new Error(
-          `SHA mismatch between ${join4(ctx.path, "meta.yaml")} and ${summaryPath}:${line}.`
+          `SHA mismatch between ${join5(ctx.path, "meta.yaml")} and ${summaryPath}:${line}.`
         );
       }
     }
   }
   const evidenceDirRaw = stage.verify?.evidence_dir?.trim();
-  const evidenceDir = evidenceDirRaw && evidenceDirRaw.length > 0 ? join4(ctx.path, evidenceDirRaw) : null;
+  const evidenceDir = evidenceDirRaw && evidenceDirRaw.length > 0 ? join5(ctx.path, evidenceDirRaw) : null;
   if (evidenceDir) {
     await ensureDir(evidenceDir);
   }
@@ -1142,7 +1371,7 @@ async function runLocalVerify(projectRoot, config, changeId, opts) {
         output: output.slice(0, 5e4)
       });
       if (evidenceDir) {
-        const logPath = join4(evidenceDir, `${cmd.name.replace(/\s+/g, "-")}.log`);
+        const logPath = join5(evidenceDir, `${cmd.name.replace(/\s+/g, "-")}.log`);
         await writeText(logPath, `# ${cmd.name}
 $ ${cmd.run}
 exit: ${exitCode}
@@ -1164,12 +1393,12 @@ ${output}`);
     status = failed.length ? "fail" : "pass";
     reason = failed.length ? `failed: ${failed.join(", ")}` : void 0;
   }
-  const ok4 = status === "pass";
+  const ok8 = status === "pass";
   const checklist = stage.gate?.checklist ?? [];
   const lines = buildSummaryLines(
     ctx.meta.title,
     stage.id,
-    results.length ? headSha : null,
+    results.length ? headSha2 : null,
     status,
     reason,
     results,
@@ -1191,7 +1420,7 @@ ${output}`);
         ``,
         `> Overall: ${STATUS_LABEL[status]}${reason ? ` \u2014 ${reason}` : ""}`,
         `> Stage: ${stage.id}`,
-        `<!-- sdd:verify stage="${stage.id}" head_sha="${results.length ? headSha ?? "none" : "none"}" result_count="${results.length}" -->`,
+        `<!-- sdd:verify stage="${stage.id}" head_sha="${results.length ? headSha2 ?? "none" : "none"}" result_count="${results.length}" -->`,
         ``
       ];
       if (results.length === 0) {
@@ -1207,7 +1436,7 @@ ${output}`);
     }
     if (evidenceDir) {
       const stamp = nowIso();
-      await writeText(join4(evidenceDir, `run-${stamp.replace(/[:.]/g, "-")}.md`), summaryBody);
+      await writeText(join5(evidenceDir, `run-${stamp.replace(/[:.]/g, "-")}.md`), summaryBody);
     }
   } else {
     await writeText(summaryPath, summaryBody);
@@ -1215,9 +1444,9 @@ ${output}`);
   ctx.meta.verify_results = {
     ...ctx.meta.verify_results,
     [stage.id]: {
-      ok: ok4,
+      ok: ok8,
       status,
-      ...results.length && headSha ? { head_sha: headSha } : {},
+      ...results.length && headSha2 ? { head_sha: headSha2 } : {},
       at: nowIso(),
       results: results.map((r) => ({ name: r.name, exitCode: r.exitCode }))
     }
@@ -1231,17 +1460,17 @@ ${output}`);
     checklist,
     evidencePath: evidenceDir,
     resultsPath: summaryPath,
-    ok: ok4
+    ok: ok8
   };
 }
 
 // src/code-context/index.ts
 import { stat } from "fs/promises";
-import { extname as extname3, isAbsolute as isAbsolute2, join as join6, relative as relative2 } from "pathe";
+import { extname as extname3, isAbsolute as isAbsolute2, join as join7, relative as relative2 } from "pathe";
 
 // src/code-context/focus.ts
 import { promises as fs } from "fs";
-import { isAbsolute, join as join5, normalize, relative } from "pathe";
+import { isAbsolute, join as join6, normalize, relative } from "pathe";
 var KEYWORD_STOPWORDS = new Set(
   [
     "a",
@@ -1304,8 +1533,8 @@ var KEYWORD_STOPWORDS = new Set(
 );
 var SOURCE_ROOTS = ["packages", "src", "lib"];
 var PATH_LIKE_RE = /(?:packages|src|lib)\/[\w./@+-]+\.\w{1,10}|`([^`]+\.\w{1,10})`|([\w./@+-]+\.(?:ts|tsx|js|jsx|mts|cts|mjs|cjs))/g;
-function tokenizeKeywords(text) {
-  const raw = text.toLowerCase().replace(/[^a-z0-9_./-]+/g, " ").split(/\s+/).filter(Boolean);
+function tokenizeKeywords(text2) {
+  const raw = text2.toLowerCase().replace(/[^a-z0-9_./-]+/g, " ").split(/\s+/).filter(Boolean);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const t of raw) {
@@ -1318,12 +1547,12 @@ function tokenizeKeywords(text) {
   }
   return out;
 }
-function extractPathLikeTokens(text) {
+function extractPathLikeTokens(text2) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   let m;
   const re = new RegExp(PATH_LIKE_RE.source, "g");
-  while ((m = re.exec(text)) !== null) {
+  while ((m = re.exec(text2)) !== null) {
     const p = (m[1] || m[2] || m[0]).replace(/`/g, "");
     if (!p || seen.has(p)) continue;
     seen.add(p);
@@ -1332,12 +1561,12 @@ function extractPathLikeTokens(text) {
   return found;
 }
 function toRepoRelative(projectRoot, p) {
-  const abs = isAbsolute(p) ? p : join5(projectRoot, p);
+  const abs = isAbsolute(p) ? p : join6(projectRoot, p);
   const rel = relative(projectRoot, abs);
   return normalize(rel).replace(/\\/g, "/");
 }
 function toAbsolute(projectRoot, p) {
-  return isAbsolute(p) ? p : join5(projectRoot, p);
+  return isAbsolute(p) ? p : join6(projectRoot, p);
 }
 async function walkFiles(absDir, projectRoot, maxFiles, out, gaps) {
   if (out.length >= maxFiles) return;
@@ -1350,7 +1579,7 @@ async function walkFiles(absDir, projectRoot, maxFiles, out, gaps) {
   }
   for (const entry of entries) {
     if (out.length >= maxFiles) return;
-    const abs = join5(absDir, entry.name);
+    const abs = join6(absDir, entry.name);
     const rel = toRepoRelative(projectRoot, abs);
     const kind = classifyPath(rel);
     if (kind === "secret" || kind === "ignored") continue;
@@ -1415,8 +1644,8 @@ async function collectUnderPaths(projectRoot, paths, maxWalk, gaps) {
 async function readBounded(absPath, maxChars) {
   if (!await pathExists(absPath)) return null;
   try {
-    const text = await readText(absPath);
-    return text.slice(0, maxChars);
+    const text2 = await readText(absPath);
+    return text2.slice(0, maxChars);
   } catch {
     return null;
   }
@@ -1444,7 +1673,7 @@ async function resolveChangeMeta(projectRoot, changeId, gaps) {
     return null;
   }
   const cpath = changePath(projectRoot, config, id);
-  const metaPath = join5(cpath, "meta.yaml");
+  const metaPath = join6(cpath, "meta.yaml");
   if (!await pathExists(metaPath)) {
     if (!await pathExists(cpath)) {
       gaps.push({
@@ -1477,7 +1706,7 @@ async function searchByKeywords(projectRoot, keywords, symbols, maxFiles) {
   const terms = [...keywords, ...symbols.map((s) => s.toLowerCase())];
   if (!terms.length) return out;
   for (const root of SOURCE_ROOTS) {
-    const abs = join5(projectRoot, root);
+    const abs = join6(projectRoot, root);
     if (!await pathExists(abs)) continue;
     const files = [];
     await walkFiles(abs, projectRoot, maxFiles * 4, files, []);
@@ -1491,8 +1720,8 @@ async function searchByKeywords(projectRoot, keywords, symbols, maxFiles) {
       }
       if (symbols.length) {
         try {
-          const text = await readText(join5(projectRoot, rel));
-          if (symbols.some((s) => text.includes(s))) {
+          const text2 = await readText(join6(projectRoot, rel));
+          if (symbols.some((s) => text2.includes(s))) {
             out.push(rel);
           }
         } catch {
@@ -1527,7 +1756,7 @@ async function resolveFocus(request, options) {
     }
     notes.push(`Change signals from: ${change.id}`);
     for (const artifact of ["tasks.md", "feature.md", "stories.md", "lld.md"]) {
-      const body = await readBounded(join5(change.path, artifact), 8e3);
+      const body = await readBounded(join6(change.path, artifact), 8e3);
       if (!body) continue;
       if (!request.paths?.length) {
         for (const p of extractPathLikeTokens(body)) {
@@ -1644,10 +1873,10 @@ function formatMarkdown(input) {
 `;
   return { markdown: packed ? frame + packed : frame, truncated: input.summary.truncated };
 }
-function formatJsonSummary(summary, gaps, slices, ok4) {
+function formatJsonSummary(summary, gaps, slices, ok8) {
   return JSON.stringify(
     {
-      ok: ok4,
+      ok: ok8,
       summary,
       gaps,
       slices: slices.map((s) => ({
@@ -1938,7 +2167,7 @@ function hardFailure(gaps, message, summary) {
   };
 }
 function toRepoPath(projectRoot, input) {
-  const abs = isAbsolute2(input) ? input : join6(projectRoot, input);
+  const abs = isAbsolute2(input) ? input : join7(projectRoot, input);
   let rel = relative2(projectRoot, abs).replaceAll("\\", "/");
   while (rel.startsWith("./")) rel = rel.slice(2);
   return rel;
@@ -1979,7 +2208,7 @@ async function generateCodeContext(request, deps) {
   let changeTitle = plan.changeId;
   let stage;
   if (request.changeId) {
-    const mp = join6(changePath(projectRoot, config, request.changeId), "meta.yaml");
+    const mp = join7(changePath(projectRoot, config, request.changeId), "meta.yaml");
     if (await pathExists(mp)) {
       const meta = await readYaml(mp);
       changeTitle = meta.title ?? request.changeId;
@@ -1996,7 +2225,7 @@ async function generateCodeContext(request, deps) {
   let query = request.query?.trim() ? request.query : "";
   if (!query && request.symbols?.length) query = request.symbols.join(" ");
   if (!query && changeTitle && request.changeId) query = changeTitle;
-  const activeChange = await resolveActiveDirectory(projectRoot, config);
+  const activeChange2 = await resolveActiveDirectory(projectRoot, config);
   const cacheRequest = {
     projectRoot,
     query: query.trim() ? query : "",
@@ -2005,7 +2234,7 @@ async function generateCodeContext(request, deps) {
     k,
     budget,
     embeddings: searchConfig.embeddings,
-    activeChange,
+    activeChange: activeChange2,
     filterPaths: request.paths ?? [],
     filterSymbols: request.symbols ?? [],
     scopes: ["code"]
@@ -2041,7 +2270,7 @@ async function generateCodeContext(request, deps) {
     const rel = toRepoPath(projectRoot, input);
     let info = null;
     try {
-      info = await stat(join6(projectRoot, rel));
+      info = await stat(join7(projectRoot, rel));
     } catch {
       info = null;
     }
@@ -2206,7 +2435,7 @@ async function generateCodeContext(request, deps) {
 }
 
 // src/refine.ts
-import { join as join7, relative as relative3 } from "pathe";
+import { join as join8, relative as relative3 } from "pathe";
 function stageArtifactRefs(ctx, stageId) {
   const stage = getStage(ctx.workflow, ctx.meta, stageId);
   if (!stage) return [];
@@ -2214,7 +2443,7 @@ function stageArtifactRefs(ctx, stageId) {
     stageId,
     path: a.path,
     required: Boolean(a.required),
-    absPath: join7(ctx.path, a.path)
+    absPath: join8(ctx.path, a.path)
   }));
 }
 function listMarkdown(refs, displayDir) {
@@ -2255,11 +2484,11 @@ async function buildRefinePlan(opts) {
     laterArtifacts.push(...stageArtifactRefs(ctx, s.id));
   }
   const focusArtifacts = stageArtifactRefs(ctx, focusStageId);
-  const constitutionPath = join7(memoryDir(opts.projectRoot, opts.config), "constitution.md");
+  const constitutionPath = join8(memoryDir(opts.projectRoot, opts.config), "constitution.md");
   const constitutionExists = await pathExists(constitutionPath);
-  const briefPath = join7(ctx.path, "refine-brief.md");
-  const reportPath = join7(ctx.path, "quality-report.md");
-  const openItemsPath = join7(ctx.path, "open-items.md");
+  const briefPath = join8(ctx.path, "refine-brief.md");
+  const reportPath = join8(ctx.path, "quality-report.md");
+  const openItemsPath = join8(ctx.path, "open-items.md");
   const paths = guidancePaths(opts.config);
   const briefRel = `${ctx.displayPath}/refine-brief.md`;
   const reportRel = `${ctx.displayPath}/quality-report.md`;
@@ -2396,7 +2625,7 @@ Do **not** invent content for later stages that were not materialized yet. If a
 }
 async function writeRefineBrief(plan, projectRoot) {
   await writeText(plan.briefPath, plan.briefMarkdown);
-  const pointer = join7(sddRoot(projectRoot), "refine-brief.md");
+  const pointer = join8(sddRoot(projectRoot), "refine-brief.md");
   const briefRel = relative3(projectRoot, plan.briefPath);
   await writeText(
     pointer,
@@ -2412,310 +2641,1740 @@ Run: \`sdd refine${plan.focusStageId ? ` ${plan.focusStageId}` : ""}\`
 }
 
 // src/role/handoff.ts
-import { join as join10 } from "pathe";
-import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+import { join as join16 } from "pathe";
+import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 
-// src/role/profile.ts
-import { readFile, writeFile } from "fs/promises";
-import { join as join8 } from "pathe";
-import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+// src/role/routing.ts
+import { join as join15 } from "pathe";
+import { parse as parseYaml2 } from "yaml";
+import { z as z6 } from "zod";
 
-// src/role/types.ts
-var ROLE_TEXT = {
-  needsJob: "A role needs a job.",
-  notFound: "Role not found.",
-  exists: "Role already exists.",
-  badName: "A role name is not valid.",
-  self: "A role cannot review itself.",
-  x: "X is not a role tool.",
-  needsSection: "This needs an accepted section before a draft.",
-  noModel: "No role model is configured.",
-  cannot: "A role cannot do that.",
-  askFirst: "Ask first. This stays stopped.",
-  choice: "Allow once, Always allow, or Deny.",
-  unavailable: "This action is not available in this slice.",
-  expired: "Expired. The action did not run.",
-  runNotFound: "Run not found.",
-  badYaml: "role.yaml is invalid"
-};
+// src/role/models/decide.ts
+import { z as z2 } from "zod";
 
-// src/role/profile.ts
-var NAME_LIMIT = 80;
-function canonicalRoleName(input) {
-  const name = input.trim();
-  if (!name || name === "." || name === "..") return null;
-  if (name.length > NAME_LIMIT) return null;
-  if (name.includes("/") || name.includes("\\") || name.includes("\0")) return null;
-  return name;
-}
-function roleFilePath(root, name) {
-  return join8(root, ".sdd", "roles", `${name}.md`);
-}
-function conversationDir(root, name) {
-  return join8(root, ".sdd", "role-runs", "conversation", name);
-}
-function memoryDir2(root, name) {
-  return join8(root, ".sdd", "role-runs", "memory", name);
-}
-function allowFilePath(root) {
-  return join8(root, ".sdd", "role-runs", "allow.json");
+// src/role/models/command.ts
+import { spawn as spawn3 } from "child_process";
+function decideStdin(input) {
+  return `${JSON.stringify({
+    mode: "decide",
+    state: input.state,
+    question: input.question,
+    options: input.options
+  })}
+`;
 }
-function ok(stdout = "") {
-  return { exitCode: 0, stdout };
+function spawnModelCommand(command, stdin) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(command, { shell: true, stdio: ["pipe", "pipe", "ignore"] });
+    const out = [];
+    child.stdout?.on("data", (chunk) => out.push(chunk));
+    child.on("error", reject);
+    child.stdin?.on("error", () => void 0);
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`role model exited ${code ?? "unknown"}`));
+        return;
+      }
+      resolve(Buffer.concat(out).toString("utf8").trim());
+    });
+    child.stdin?.write(stdin);
+    child.stdin?.end();
+  });
 }
-function fail(stdout) {
-  return { exitCode: 1, stdout };
+function modelFromEnv(env) {
+  const command = env.SDD_ROLE_MODEL?.trim();
+  if (!command) return void 0;
+  return {
+    async complete(input) {
+      const text2 = await spawnModelCommand(
+        command,
+        `${JSON.stringify({ roleId: input.roleId, prompt: input.prompt })}
+`
+      );
+      let parsed;
+      try {
+        parsed = JSON.parse(text2);
+      } catch {
+        throw new Error("role model stdout is not JSON");
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("role model stdout is not a JSON object");
+      }
+      return text2;
+    }
+  };
 }
-function asText(value) {
-  return typeof value === "string" ? value.trim() : "";
+
+// src/role/models/ollama.ts
+function count(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
 }
-function parseRoleDocument(name, raw) {
-  const text = raw.replace(/^\uFEFF/, "");
-  const nl = text.indexOf("\n");
-  if (nl < 0 || text.slice(0, nl).trim() !== "---") return null;
-  const rest = text.slice(nl + 1);
-  const close = /\r?\n---\s*(?:\r?\n|$)/.exec(rest);
-  if (!close) return null;
-  let data;
+function chatUrl(base) {
   try {
-    data = parseYaml2(rest.slice(0, close.index));
+    const trimmed = base.trim();
+    const absolute = trimmed !== "" && !/^https?:/i.test(trimmed) ? `http://${trimmed}` : trimmed;
+    const withSlash = absolute.endsWith("/") ? absolute : `${absolute}/`;
+    return new URL("api/chat", withSlash).toString();
   } catch {
     return null;
   }
-  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-  const rec = data;
-  const body = rest.slice(close.index + close[0].length).trim();
-  return {
-    name,
-    label: asText(rec.label),
-    job: asText(rec.job),
-    description: body,
-    askFirst: rec.ask_first === true,
-    pinned: rec.pinned === true,
-    hidden: rec.hidden === true
-  };
 }
-function renderRole(role) {
-  const front = stringifyYaml(
-    {
-      name: role.name,
-      label: role.label,
-      job: role.job,
-      ask_first: role.askFirst,
-      pinned: role.pinned,
-      hidden: role.hidden
+async function ollamaDecision(input) {
+  const url = chatUrl(input.baseUrl);
+  if (!url) {
+    return {
+      called: false,
+      model: input.model,
+      content: null,
+      inputTokens: null,
+      outputTokens: null
+    };
+  }
+  const body = JSON.stringify({
+    model: input.model,
+    stream: false,
+    format: {
+      type: "object",
+      properties: {
+        pick: { type: "string" },
+        probs: { type: "object", additionalProperties: { type: "number" } }
+      },
+      required: ["pick", "probs"]
     },
-    { lineWidth: 100 }
-  ).trimEnd();
-  const description = role.description.trim();
-  if (!description) return `---
-${front}
----
-`;
-  return `---
-${front}
----
-${description}
-`;
-}
-async function readRole(root, name) {
-  const canonical = canonicalRoleName(name);
-  if (!canonical) return null;
-  const path = roleFilePath(root, canonical);
-  if (!await pathExists(path)) return null;
+    messages: [
+      {
+        role: "user",
+        content: JSON.stringify({
+          state: input.state,
+          question: input.question,
+          options: input.options
+        })
+      }
+    ]
+  });
   try {
-    return parseRoleDocument(canonical, await readText(path));
+    const response = await input.fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    });
+    const text2 = await response.text();
+    if (!response.ok) {
+      return {
+        called: true,
+        model: input.model,
+        content: null,
+        inputTokens: null,
+        outputTokens: null
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text2);
+    } catch {
+      return {
+        called: true,
+        model: input.model,
+        content: null,
+        inputTokens: null,
+        outputTokens: null
+      };
+    }
+    const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    const message = record.message && typeof record.message === "object" && !Array.isArray(record.message) ? record.message : {};
+    const content = typeof message.content === "string" ? message.content : message.content && typeof message.content === "object" ? JSON.stringify(message.content) : null;
+    const model = typeof record.model === "string" && record.model.trim() ? record.model : input.model;
+    return {
+      called: true,
+      model,
+      content,
+      inputTokens: count(record.prompt_eval_count),
+      outputTokens: count(record.eval_count)
+    };
   } catch {
-    return null;
+    return {
+      called: true,
+      model: input.model,
+      content: null,
+      inputTokens: null,
+      outputTokens: null
+    };
   }
 }
-async function writeRole(root, role) {
-  await writeText(roleFilePath(root, role.name), renderRole(role));
+
+// src/role/models/rules.ts
+function rulesDecision(options) {
+  return { pick: options.includes("human") ? "human" : "human" };
 }
-async function createRole(root, input) {
-  const name = canonicalRoleName(input.name);
-  if (!name) return fail(ROLE_TEXT.badName);
-  const job = input.job.trim();
-  if (!job) return fail(ROLE_TEXT.needsJob);
-  if (await pathExists(roleFilePath(root, name))) return fail(ROLE_TEXT.exists);
-  await writeRole(root, {
-    name,
-    label: input.label.trim(),
-    job,
-    description: (input.description ?? "").trim(),
-    askFirst: input.askFirst === true,
-    pinned: false,
-    hidden: false
-  });
-  return ok();
-}
-async function editRole(root, nameInput, patch) {
-  const name = canonicalRoleName(nameInput);
-  if (!name) return fail(ROLE_TEXT.badName);
-  const role = await readRole(root, name);
-  if (!role) return fail(ROLE_TEXT.notFound);
-  if (patch.job !== void 0 && !patch.job.trim()) return fail(ROLE_TEXT.needsJob);
-  if (patch.label !== void 0) role.label = patch.label.trim();
-  if (patch.job !== void 0) role.job = patch.job.trim();
-  if (patch.description !== void 0) role.description = patch.description.trim();
-  if (patch.askFirst !== void 0) role.askFirst = patch.askFirst;
-  await writeRole(root, role);
-  return ok();
-}
-async function setFlag(root, nameInput, flag) {
-  const name = canonicalRoleName(nameInput);
-  if (!name) return fail(ROLE_TEXT.badName);
-  const role = await readRole(root, name);
-  if (!role) return fail(ROLE_TEXT.notFound);
-  role[flag] = true;
-  await writeRole(root, role);
-  return ok();
-}
-function pinRole(root, name) {
-  return setFlag(root, name, "pinned");
-}
-function hideRole(root, name) {
-  return setFlag(root, name, "hidden");
-}
-async function showRoles(root, opts = {}) {
-  if (opts.name !== void 0) {
-    const name = canonicalRoleName(opts.name);
-    if (!name) return fail(ROLE_TEXT.badName);
-    const path = roleFilePath(root, name);
-    if (!await pathExists(path) || !await readRole(root, name)) return fail(ROLE_TEXT.notFound);
-    return ok((await readText(path)).replace(/\s*$/, ""));
-  }
-  const dir = join8(root, ".sdd", "roles");
-  if (!await pathExists(dir)) return ok();
-  const roles = [];
-  for (const file of await listFiles(dir)) {
-    if (!file.endsWith(".md")) continue;
-    const role = await readRole(root, file.slice(0, -".md".length));
-    if (!role) continue;
-    if (role.hidden && !opts.all) continue;
-    roles.push(role);
-  }
-  roles.sort((a, b) => {
-    if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
-    if (a.name < b.name) return -1;
-    if (a.name > b.name) return 1;
-    return 0;
-  });
-  return ok(roles.map((role) => `${role.name} ${role.label}`).join("\n"));
-}
-async function duplicateRole(root, nameInput) {
-  const name = canonicalRoleName(nameInput);
-  if (!name) return fail(ROLE_TEXT.badName);
-  const source = await readRole(root, name);
-  if (!source) return fail(ROLE_TEXT.notFound);
-  const copyName = canonicalRoleName(`${name} copy`);
-  if (!copyName) return fail(ROLE_TEXT.badName);
-  if (await pathExists(roleFilePath(root, copyName))) return fail(ROLE_TEXT.exists);
-  await writeRole(root, { ...source, name: copyName });
-  return ok();
-}
-async function deleteRole(root, nameInput) {
-  const name = canonicalRoleName(nameInput);
-  if (!name) return fail(ROLE_TEXT.badName);
-  const path = roleFilePath(root, name);
-  if (!await pathExists(path)) return fail(ROLE_TEXT.notFound);
-  await removePath(path);
-  await removePath(conversationDir(root, name));
-  await removePath(memoryDir2(root, name));
-  await removeAllowKey(root, name);
-  return ok();
-}
-async function removeAllowKey(root, name) {
-  const path = allowFilePath(root);
-  if (!await pathExists(path)) return;
-  let data;
-  try {
-    data = JSON.parse(await readText(path));
-  } catch {
-    return;
+
+// src/role/models/select.ts
+function slot(map, workType) {
+  const id = map?.[workType]?.trim();
+  return id || void 0;
+}
+function selectModel(config, ctx) {
+  const bot = ctx.bot?.trim();
+  const stage = ctx.stage?.trim();
+  const role = ctx.role?.trim();
+  const fromBot = bot ? slot(config.overrides?.bots?.[bot], ctx.workType) : void 0;
+  const fromStage = stage ? slot(config.overrides?.stages?.[stage], ctx.workType) : void 0;
+  const fromRole = role ? slot(config.overrides?.roles?.[role], ctx.workType) : void 0;
+  const fromWork = slot(config.defaults.by_work_type, ctx.workType);
+  let id;
+  let why;
+  if (fromBot && bot) {
+    id = fromBot;
+    why = `bot ${bot}`;
+  } else if (fromStage && stage) {
+    id = fromStage;
+    why = `stage ${stage}`;
+  } else if (fromRole && role) {
+    id = fromRole;
+    why = `role ${role}`;
+  } else if (fromWork) {
+    id = fromWork;
+    why = "work-type default";
+  } else {
+    id = workKind(ctx.workType) === "decide" ? config.defaults.fallback_decide : config.defaults.fallback_reason;
+    why = "fallback";
   }
-  if (!data || typeof data !== "object" || Array.isArray(data)) return;
-  const rec = data;
-  if (!(name in rec)) return;
-  delete rec[name];
-  await writeFile(path, `${JSON.stringify(rec, null, 2)}
-`, "utf8");
+  const model = config.models[id];
+  if (!model) return { id, kind: workKind(ctx.workType), provider: "rules", why };
+  return { id, kind: model.kind, provider: model.provider, why };
+}
+
+// src/role/models/decide.ts
+var tokenField = z2.number().int().nonnegative().nullable().optional();
+var DecisionReplySchema = z2.object({
+  pick: z2.string(),
+  probs: z2.record(z2.string(), z2.number()),
+  model: z2.string().trim().min(1).optional(),
+  input_tokens: tokenField,
+  cache_read_tokens: tokenField,
+  cache_write_tokens: tokenField,
+  output_tokens: tokenField
+}).strict();
+function minimumOf(entry) {
+  if (!entry || entry.provider === "rules") return void 0;
+  return entry.min_confidence;
+}
+function humanOutcome(choice, confidence2) {
+  return { pick: "human", source: "human", choice, confidence: confidence2 };
+}
+function emptyUsage() {
+  return {
+    inputTokens: null,
+    cacheReadTokens: null,
+    cacheWriteTokens: null,
+    outputTokens: null
+  };
 }
-async function listConversationRoles(root) {
-  return listDirs(join8(root, ".sdd", "role-runs", "conversation"));
+function usageFrom(reply, base) {
+  return {
+    model: reply.model ?? base.model,
+    inputTokens: reply.input_tokens === void 0 ? base.inputTokens : reply.input_tokens,
+    cacheReadTokens: reply.cache_read_tokens === void 0 ? base.cacheReadTokens : reply.cache_read_tokens,
+    cacheWriteTokens: reply.cache_write_tokens === void 0 ? base.cacheWriteTokens : reply.cache_write_tokens,
+    outputTokens: reply.output_tokens === void 0 ? base.outputTokens : reply.output_tokens
+  };
 }
-async function readAllowFile(root) {
-  const path = allowFilePath(root);
-  if (!await pathExists(path)) return null;
+function scoreReply(raw, options, base) {
+  let value;
   try {
-    const data = JSON.parse(await readFile(path, "utf8"));
-    if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-    return data;
+    value = JSON.parse(raw);
   } catch {
-    return null;
+    return { ok: false, usage: base };
+  }
+  const parsed = DecisionReplySchema.safeParse(value);
+  if (!parsed.success) return { ok: false, usage: base };
+  const reply = parsed.data;
+  const usage = usageFrom(reply, base);
+  if (!options.includes(reply.pick)) return { ok: false, usage };
+  const keys = Object.keys(reply.probs);
+  if (keys.length !== options.length) return { ok: false, usage };
+  let sum = 0;
+  for (const option of options) {
+    const probability = reply.probs[option];
+    if (typeof probability !== "number" || probability < 0 || probability > 1) {
+      return { ok: false, usage };
+    }
+    sum += probability;
   }
+  if (Math.abs(sum - 1) > 0.01 + 1e-9) return { ok: false, usage };
+  const confidence2 = reply.probs[reply.pick];
+  if (typeof confidence2 !== "number") return { ok: false, usage };
+  return { ok: true, pick: reply.pick, confidence: confidence2, usage };
 }
-
-// src/role/run.ts
-import { appendFile } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join9 } from "pathe";
-var DRAFT_KINDS = /* @__PURE__ */ new Set(["code", "scenario", "release"]);
-var FORBIDDEN = /* @__PURE__ */ new Set([
-  "accept_spec",
-  "replace_decision",
-  "write_qa",
-  "generate_release",
-  "sdd_next",
-  "sdd_complete",
-  "create_change"
-]);
-var UNAVAILABLE = /* @__PURE__ */ new Set(["commit", "push", "tag", "pull_request", "merge", "deploy"]);
-var CLOSED = /* @__PURE__ */ new Set(["applied", "denied", "rejected", "unavailable", "stopped", "expired"]);
-function ok2(stdout = "", runId) {
-  return runId ? { exitCode: 0, stdout, runId } : { exitCode: 0, stdout };
+function storedModel(entry, usage) {
+  if (usage.model) return usage.model;
+  if (entry.provider === "ollama") return entry.model;
+  return null;
 }
-function fail2(stdout, runId) {
-  return runId ? { exitCode: 1, stdout, runId } : { exitCode: 1, stdout };
+async function recordCall(input, entry, usage) {
+  if (!input.metrics) return;
+  if (entry.provider === "rules") return;
+  await recordDecisionMetric(
+    input.metrics.projectRoot,
+    input.metrics.config,
+    input.metrics.changeId,
+    {
+      workType: input.ctx.workType,
+      kind: entry.kind,
+      provider: entry.provider,
+      model: storedModel(entry, usage),
+      startedAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+      inputTokens: usage.inputTokens,
+      cacheReadTokens: usage.cacheReadTokens,
+      cacheWriteTokens: usage.cacheWriteTokens,
+      outputTokens: usage.outputTokens
+    }
+  );
 }
-function linesOf(...parts) {
-  return parts.filter((part) => part.length > 0).join("\n");
+function judge(choice, entry, scored, floor) {
+  const minimum = minimumOf(entry) ?? floor;
+  if (!scored.ok) {
+    return {
+      kept: false,
+      missing: false,
+      escalate: minimum !== void 0,
+      confidence: 0,
+      outcome: humanOutcome(choice, 0)
+    };
+  }
+  if (minimum !== void 0 && scored.confidence < minimum) {
+    return {
+      kept: false,
+      missing: false,
+      escalate: true,
+      confidence: scored.confidence,
+      outcome: humanOutcome(choice, scored.confidence)
+    };
+  }
+  const source = choice.kind === "reason" ? "reason" : "decide";
+  return {
+    kept: true,
+    missing: false,
+    escalate: false,
+    confidence: scored.confidence,
+    outcome: { pick: scored.pick, source, choice, confidence: scored.confidence }
+  };
 }
-function runIdFrom(date) {
-  const iso = date.toISOString();
-  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(iso);
-  if (!match) return "unknown";
-  return `${match[1]}${match[2]}${match[3]}T${match[4]}${match[5]}${match[6]}Z`;
+async function runOne(input, choice, floor) {
+  const entry = input.models?.models[choice.id];
+  if (!entry) {
+    return {
+      kept: false,
+      missing: true,
+      escalate: false,
+      confidence: null,
+      outcome: humanOutcome(choice, null)
+    };
+  }
+  if (entry.provider === "rules") {
+    rulesDecision(input.options);
+    return {
+      kept: true,
+      missing: false,
+      escalate: false,
+      confidence: null,
+      outcome: { pick: "human", source: "rules", choice, confidence: null }
+    };
+  }
+  if (entry.provider === "command") {
+    const command = input.env[entry.command_env]?.trim();
+    if (!command || !input.runCommand) {
+      return {
+        kept: false,
+        missing: true,
+        escalate: false,
+        confidence: null,
+        outcome: humanOutcome(choice, null)
+      };
+    }
+    let stdout = "";
+    try {
+      stdout = await input.runCommand(command, decideStdin(input));
+    } catch {
+      await recordCall(input, entry, emptyUsage());
+      return judge(choice, entry, { ok: false }, floor);
+    }
+    const scored2 = scoreReply(stdout, input.options, emptyUsage());
+    await recordCall(input, entry, scored2.usage);
+    return judge(choice, entry, scored2, floor);
+  }
+  const baseUrl = input.env[entry.base_url_env]?.trim();
+  if (!baseUrl || !input.fetch) {
+    return {
+      kept: false,
+      missing: true,
+      escalate: false,
+      confidence: null,
+      outcome: humanOutcome(choice, null)
+    };
+  }
+  const remote = await ollamaDecision({
+    baseUrl,
+    model: entry.model,
+    state: input.state,
+    question: input.question,
+    options: input.options,
+    fetch: input.fetch
+  });
+  if (!remote.called) {
+    return {
+      kept: false,
+      missing: true,
+      escalate: false,
+      confidence: null,
+      outcome: humanOutcome(choice, null)
+    };
+  }
+  const base = {
+    model: remote.model,
+    inputTokens: remote.inputTokens,
+    cacheReadTokens: null,
+    cacheWriteTokens: null,
+    outputTokens: remote.outputTokens
+  };
+  const scored = remote.content ? scoreReply(remote.content, input.options, base) : { ok: false, usage: base };
+  await recordCall(input, entry, scored.usage);
+  return judge(choice, entry, scored, floor);
+}
+async function decide(input) {
+  if (!input.models) return { pick: "human", source: "human", choice: null, confidence: null };
+  const choice = selectModel(input.models, input.ctx);
+  const first = await runOne(input, choice);
+  if (first.kept) return first.outcome;
+  if (first.missing || !first.escalate) return first.outcome;
+  const floor = minimumOf(input.models.models[choice.id]);
+  const fallbackId = input.models.defaults.fallback_reason;
+  if (choice.id === fallbackId) return first.outcome;
+  const fallbackEntry = input.models.models[fallbackId];
+  if (!fallbackEntry) return first.outcome;
+  const fallback = {
+    id: fallbackId,
+    kind: fallbackEntry.kind,
+    provider: fallbackEntry.provider,
+    why: "fallback"
+  };
+  const second = await runOne(input, fallback, floor);
+  if (second.kept) return second.outcome;
+  return second.outcome;
 }
-function mentionsX(task) {
-  return /@X|x\.com|twitter\.com/.test(task);
+
+// src/role/run.ts
+import { appendFile as appendFile5 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join14 } from "pathe";
+
+// src/team/facts.ts
+import { appendFile } from "fs/promises";
+import { join as join9 } from "pathe";
+function ok(stdout = "") {
+  return { exitCode: 0, stdout };
 }
-function safeChangeId(id) {
-  if (!id || id.length > 200) return false;
-  if (id === "." || id === "..") return false;
-  return !id.includes("/") && !id.includes("\\") && !id.includes("\0");
+function fail(stdout) {
+  return { exitCode: 1, stdout };
 }
-function safeRunId(id) {
-  if (!id || id.length > 80) return false;
-  if (id === "." || id === "..") return false;
-  return !id.includes("/") && !id.includes("\\") && !id.includes("\0");
+function factsPath(root) {
+  return join9(root, ".sdd", "facts.jsonl");
 }
-function isSafeProductPath(rel) {
-  if (typeof rel !== "string" || rel.length === 0 || rel.includes("\0")) return false;
-  if (isAbsolute3(rel) || rel.startsWith("\\")) return false;
-  if (/^[A-Za-z]:/.test(rel)) return false;
-  const parts = rel.split(/[/\\]/);
-  for (const part of parts) {
-    if (part === "" || part === "." || part === ".." || part === ".active" || part === ".sdd") {
-      return false;
-    }
+function sharesWords(left, right) {
+  const bag = wordsOf(left);
+  for (const word of wordsOf(right)) {
+    if (bag.has(word)) return true;
   }
-  return parts[parts.length - 1] !== "accepted.md";
+  return false;
 }
-function canonicalJson(value) {
-  return JSON.stringify(sortKeys(value));
+function wordsOf(text2) {
+  return new Set(text2.toLowerCase().match(/[\p{L}\p{N}_]{4,}/gu) ?? []);
 }
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
+async function readFactLines(root) {
+  const file = factsPath(root);
+  if (!await pathExists(file)) return [];
+  const out = [];
+  for (const line of (await readText(file)).split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const rec = value;
+      if (typeof rec.key !== "string" || typeof rec.value !== "string") continue;
+      out.push({
+        key: rec.key,
+        value: rec.value,
+        ts: typeof rec.ts === "string" ? rec.ts : "",
+        by: typeof rec.by === "string" ? rec.by : "",
+        source: typeof rec.source === "string" ? rec.source : ""
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+async function getFacts(root, query) {
+  const lines = await readFactLines(root);
+  const order = [];
+  const newest = /* @__PURE__ */ new Map();
+  for (const fact of lines) {
+    if (!newest.has(fact.key)) order.push(fact.key);
+    newest.set(fact.key, fact);
+  }
+  let facts = order.map((key) => newest.get(key));
+  if (query?.keys) {
+    const want = new Set(query.keys);
+    facts = facts.filter((fact) => want.has(fact.key));
+  }
+  if (query?.query) {
+    const text2 = query.query;
+    facts = facts.filter((fact) => sharesWords(text2, `${fact.key} ${fact.value}`));
+  }
+  return facts;
+}
+async function setFact(root, input) {
+  const rawKey = input.key ?? "";
+  const rawValue = input.value ?? "";
+  const rawSource = input.source ?? "";
+  if (rawKey.includes("\n") || rawKey.includes("\r") || rawValue.includes("\n") || rawValue.includes("\r") || rawSource.includes("\n") || rawSource.includes("\r")) {
+    return fail("A fact is one line.");
+  }
+  const key = rawKey.trim();
+  const value = rawValue.trim();
+  if (!key || !value) return fail("A fact needs a key and a value.");
+  if (key.includes("/") || key.includes("\\") || key.includes("\0")) {
+    return fail("A fact key is not valid.");
+  }
+  if (await contradicts(root, value)) return escalate(root, key);
+  const fact = {
+    key,
+    value,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    by: gitUserName(root) ?? "unknown",
+    source: rawSource.trim() || "person"
+  };
+  const file = factsPath(root);
+  await ensureDir(join9(file, ".."));
+  await appendFile(file, `${JSON.stringify(fact)}
+`, "utf8");
+  return ok("Fact set.");
+}
+async function showFact(root, key) {
+  const name = (key ?? "").trim();
+  if (!name) return fail("A fact needs a key and a value.");
+  const facts = await getFacts(root, { keys: [name] });
+  const hit = facts[0];
+  if (!hit) return fail("Fact not set.");
+  return ok(hit.value);
+}
+async function listFacts(root, query) {
+  const facts = await getFacts(root, query ? { query } : void 0);
+  if (facts.length === 0) return ok("No facts.");
+  return ok(facts.map((fact) => `${fact.key}: ${fact.value}`).join("\n"));
+}
+async function contradicts(root, value) {
+  if (!/\b(ignore|skip|override)\b/i.test(value)) return false;
+  let text2 = "";
+  try {
+    const config = await loadConfig(root);
+    const file = join9(root, guidancePaths(config).constitution);
+    if (await pathExists(file)) text2 = await readText(file);
+  } catch {
+    const file = join9(root, "memory", "constitution.md");
+    if (await pathExists(file)) text2 = await readText(file);
+  }
+  for (const line of text2.split(/\r?\n/)) {
+    if (!line.startsWith("- ")) continue;
+    const bullet = line.slice(2).trim();
+    if (bullet.length >= 12 && value.includes(bullet)) return true;
+  }
+  return false;
+}
+async function escalate(root, key) {
+  const note = `fact ${key} contradicts constitution`;
+  let changeId = null;
+  try {
+    const config = await loadConfig(root);
+    changeId = await getActiveChangeId(root, config);
+  } catch {
+    changeId = null;
+  }
+  if (!changeId) return fail("A fact contradicts the constitution.");
+  return recordDecisionRequest(root, { note, change: changeId });
+}
+
+// src/team/memory.ts
+import { appendFile as appendFile2 } from "fs/promises";
+import { join as join10 } from "pathe";
+var BRAIN_FILES = ["memory.md", "lessons.jsonl"];
+function ok2(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail2(stdout) {
+  return { exitCode: 1, stdout };
+}
+async function knownBot(root, name) {
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail2(team.error);
+  if (!team.team.bots.some((bot) => bot.name === name)) return fail2("Bot not found.");
+  return null;
+}
+async function readMemory(root, bot) {
+  const file = join10(memoryDir2(root, bot, true), "memory.md");
+  if (!await pathExists(file)) return "";
+  return readText(file);
+}
+async function readLessons(root, bot) {
+  const file = join10(memoryDir2(root, bot, true), "lessons.jsonl");
+  if (!await pathExists(file)) return [];
+  const lessons = [];
+  for (const line of (await readText(file)).split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const rec = value;
+      if (typeof rec.text !== "string" || !rec.text.trim()) continue;
+      const tags = Array.isArray(rec.tags) ? rec.tags.filter((tag) => typeof tag === "string") : void 0;
+      lessons.push({
+        ts: typeof rec.ts === "string" ? rec.ts : "",
+        by: typeof rec.by === "string" ? rec.by : "",
+        text: rec.text,
+        source: typeof rec.source === "string" ? rec.source : void 0,
+        tags
+      });
+    } catch {
+    }
+  }
+  return lessons;
+}
+async function appendLesson(root, bot, lesson) {
+  const file = join10(memoryDir2(root, bot, true), "lessons.jsonl");
+  await ensureDir(join10(file, ".."));
+  await appendFile2(file, `${JSON.stringify(lesson)}
+`, "utf8");
+}
+async function showMemory(root, bot) {
+  const name = canonicalRoleName(bot);
+  if (!name) return fail2(ROLE_TEXT.badName);
+  const missing = await knownBot(root, name);
+  if (missing) return missing;
+  const text2 = await readMemory(root, name);
+  if (!text2) return ok2("No memory.");
+  return ok2(text2.endsWith("\n") ? text2.slice(0, -1) : text2);
+}
+async function addLesson(root, bot, text2) {
+  const name = canonicalRoleName(bot);
+  if (!name) return fail2(ROLE_TEXT.badName);
+  const missing = await knownBot(root, name);
+  if (missing) return missing;
+  if (text2.includes("\n") || text2.includes("\r")) return fail2("A lesson is one line.");
+  const words = text2.trim();
+  if (!words) return fail2("A lesson needs text.");
+  await appendLesson(root, name, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    by: gitUserName(root) ?? "unknown",
+    text: words,
+    source: "person"
+  });
+  return ok2("Lesson added.");
+}
+async function addReviewerLesson(root, bot, lesson) {
+  const text2 = lesson.text.trim();
+  if (!text2 || text2.includes("\n") || text2.includes("\r")) return;
+  const existing = await readLessons(root, bot);
+  if (existing.some((item) => item.text === text2)) return;
+  await appendLesson(root, bot, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    by: lesson.by || "reviewer",
+    text: text2,
+    source: "reviewer"
+  });
+}
+async function migrateTeamMemory(root) {
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail2(team.error);
+  const base = join10(root, ".sdd", "role-runs", "memory");
+  const lines = [];
+  for (const name of (await listDirs(base)).sort()) {
+    if (!canonicalRoleName(name)) continue;
+    for (const file of BRAIN_FILES) {
+      const from = join10(base, name, file);
+      if (!await pathExists(from)) continue;
+      const fromRel = `.sdd/role-runs/memory/${name}/${file}`;
+      const toRel = `.sdd/agents/${name}/${file}`;
+      const to = join10(memoryDir2(root, name, true), file);
+      if (await pathExists(to)) {
+        lines.push(`left ${fromRel}`);
+        continue;
+      }
+      await ensureDir(join10(to, ".."));
+      await writeText(to, await readText(from));
+      await removePath(from);
+      lines.push(`moved ${fromRel} -> ${toRel}`);
+    }
+    if ((await listFiles(join10(base, name))).length === 0) await removePath(join10(base, name));
+  }
+  if (lines.length === 0) return ok2("Nothing to migrate.");
+  return ok2(lines.join("\n"));
+}
+
+// src/team/brain.ts
+var WARNING = "Memory is longer than the budget.";
+async function loadBrain(root, cfg, bot, item, budgetTokens) {
+  const spec = cfg.bots.find((entry) => entry.name === bot);
+  if (!spec) return { error: "Bot not found." };
+  const role = await readRole(root, spec.role);
+  if (!role) return { error: ROLE_TEXT.notFound };
+  const file = roleFilePath(root, spec.role);
+  if (!await pathExists(file)) return { error: ROLE_TEXT.notFound };
+  const roleText = await readText(file);
+  const memoryAll = await readMemory(root, spec.name);
+  const lessonsNewest = (await readLessons(root, spec.name)).slice().reverse();
+  const factsNewest = (await getFacts(root, { query: item.text })).slice().reverse();
+  const packed = pack({
+    roleText,
+    memoryAll,
+    lessons: lessonsNewest,
+    facts: factsNewest,
+    item: item.text,
+    budget: budgetTokens
+  });
+  return {
+    role,
+    bot: spec,
+    memory: packed.memory,
+    lessons: packed.lessons,
+    facts: packed.facts,
+    inputs: [],
+    prompt: packed.prompt,
+    warning: packed.warning
+  };
+}
+function pack(input) {
+  let memory = input.memoryAll;
+  let lessons = input.lessons.slice();
+  let facts = input.facts.slice();
+  let warning = "";
+  const itemBlock = `Item:
+${input.item}`;
+  const render = () => {
+    const parts = [input.roleText.trimEnd()];
+    if (warning) parts.push(warning);
+    if (memory.trim()) parts.push(`Memory:
+${memory.trimEnd()}`);
+    if (lessons.length > 0) {
+      parts.push(`Lessons:
+${lessons.map((lesson) => `- ${lesson.text}`).join("\n")}`);
+    }
+    if (facts.length > 0) {
+      parts.push(`Facts:
+${facts.map((fact) => `${fact.key}: ${fact.value}`).join("\n")}`);
+    }
+    parts.push(itemBlock);
+    return parts.join("\n");
+  };
+  const roleOnly = countTokens(input.roleText) > input.budget;
+  if (roleOnly) {
+    memory = "";
+    lessons = [];
+    facts = [];
+    warning = input.memoryAll.trim() ? WARNING : "";
+    return { memory, lessons, facts, prompt: render(), warning };
+  }
+  while (countTokens(render()) > input.budget && facts.length > 0) facts.pop();
+  while (countTokens(render()) > input.budget && lessons.length > 0) lessons.pop();
+  if (countTokens(render()) > input.budget && memory.trim()) {
+    const lines = memory.split(/\r?\n/);
+    while (lines.length > 0 && countTokens(render()) > input.budget) {
+      lines.shift();
+      memory = lines.join("\n");
+    }
+  }
+  if (input.memoryAll.trim() && memory.trim() !== input.memoryAll.trim()) {
+    warning = WARNING;
+    while (countTokens(render()) > input.budget && facts.length > 0) facts.pop();
+    while (countTokens(render()) > input.budget && lessons.length > 0) lessons.pop();
+    if (countTokens(render()) > input.budget) memory = "";
+  }
+  return { memory, lessons, facts, prompt: render(), warning };
+}
+
+// src/team/loop.ts
+import { appendFile as appendFile4 } from "fs/promises";
+import { basename, join as join13 } from "pathe";
+import { z as z5 } from "zod";
+
+// src/team/room.ts
+import { appendFile as appendFile3 } from "fs/promises";
+import { join as join12 } from "pathe";
+import { z as z4 } from "zod";
+
+// src/role/prompts.ts
+function critiquePrompt(role, section, draft) {
+  return [
+    `Job: ${role.job}`,
+    "Check ids:",
+    ...section.checks,
+    `Cite: ${section.id}:${section.decision}`,
+    "Draft:",
+    draft
+  ].join("\n");
+}
+function revisionPrompt(role, draft, gaps) {
+  return [
+    `Job: ${role.job}`,
+    "Draft:",
+    draft,
+    "Gaps:",
+    ...gaps.map((gap) => `${gap.cite}: ${gap.text}`),
+    "changed must list every gap cite."
+  ].join("\n");
+}
+
+// src/team/tools.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { isAbsolute as isAbsolute3, join as join11 } from "pathe";
+import { z as z3 } from "zod";
+var OUTPUT_CAP = 4e3;
+var SCOPES = /* @__PURE__ */ new Set(["code", "specs", "memory"]);
+var ToolsSchema = z3.object({
+  allow: z3.array(z3.object({ run: z3.string().trim().min(1) }).strict()).default([])
+}).strict();
+var EvidenceSchema = z3.object({
+  sha: z3.string(),
+  runs: z3.array(
+    z3.object({
+      command: z3.string(),
+      exitCode: z3.number().int().nullable(),
+      output: z3.string()
+    }).strict()
+  )
+}).strict();
+var BLOCKED_CHECK = /\bsdd\s+(next|complete)\b|\bgit\s+(push|merge)\b|\bgh\s+pr\s+(create|merge)\b/;
+var NEGATED = /\b(?:not|no|never|cannot|can't|cant|dont|don't|doesnt|doesn't|isnt|isn't)\s+(?:yet\s+)?(?:pass|works|fixed)\b/gi;
+function claimsPass(text2) {
+  return /\b(?:pass|works|fixed)\b/i.test(text2.replace(NEGATED, " "));
+}
+function safePath(rel) {
+  if (typeof rel !== "string" || rel.length === 0 || rel.includes("\0")) return false;
+  if (isAbsolute3(rel) || rel.startsWith("\\")) return false;
+  if (/^[A-Za-z]:/.test(rel)) return false;
+  const parts = rel.split(/[/\\]/);
+  for (const part of parts) {
+    if (part === "" || part === "." || part === ".." || part === ".active" || part === ".sdd") {
+      return false;
+    }
+  }
+  return parts[parts.length - 1] !== "accepted.md";
+}
+function clip(text2) {
+  return text2.length > OUTPUT_CAP ? text2.slice(-OUTPUT_CAP) : text2;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function result(name, ok8, text2) {
+  return { ok: ok8, name, text: clip(text2) };
+}
+async function git(cwd, args) {
+  return new Promise((resolve) => {
+    const child = spawn4("git", args, { cwd, env: process.env });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => resolve({ code: 1, stdout, stderr: String(error) }));
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+  });
+}
+async function shell(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn4(command, { cwd, shell: true, env: process.env });
+    let output = "";
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.on("error", (error) => resolve({ code: 1, output: String(error) }));
+    child.on("close", (code) => resolve({ code, output }));
+  });
+}
+async function headOf(root) {
+  try {
+    return await getHeadSha(root);
+  } catch {
+    return null;
+  }
+}
+async function activeChange(root) {
+  const config = await loadConfig(root);
+  const id = await getActiveChangeId(root, config);
+  if (!id) return null;
+  return { id, path: changePath(root, config, id) };
+}
+function evidenceRel(changesPath, changeId, sha) {
+  return `${changesPath}/${changeId}/evidence/${sha}.json`.replace(/\\/g, "/");
+}
+async function evidenceFile(root, changeId, sha) {
+  const config = await loadConfig(root);
+  return join11(changePath(root, config, changeId), "evidence", `${sha}.json`);
+}
+async function evidenceSupports(root, changeId, cite) {
+  const sha = await headOf(root);
+  if (!sha) return false;
+  const config = await loadConfig(root);
+  const expected = evidenceRel(config.changes_path, changeId, sha);
+  if (cite.trim().replace(/\\/g, "/").replace(/^\.\//, "") !== expected) return false;
+  const file = join11(root, ...expected.split("/"));
+  if (!await pathExists(file)) return false;
+  let parsed;
+  try {
+    const value = EvidenceSchema.safeParse(JSON.parse(await readText(file)));
+    if (!value.success) return false;
+    parsed = value.data;
+  } catch {
+    return false;
+  }
+  if (parsed.sha !== sha || parsed.runs.length === 0) return false;
+  return parsed.runs[parsed.runs.length - 1]?.exitCode === 0;
+}
+async function passClaimRefusal(root, text2, cites) {
+  if (!claimsPass(text2)) return null;
+  const change = await activeChange(root).catch(() => null);
+  if (!change) return "A pass claim needs evidence at this SHA.";
+  for (const cite of cites) {
+    if (await evidenceSupports(root, change.id, cite)) return null;
+  }
+  return "A pass claim needs evidence at this SHA.";
+}
+async function allowList(root) {
+  const change = await activeChange(root);
+  const stageRuns = [];
+  if (change) {
+    const config = await loadConfig(root);
+    const ctx = await buildContext(root, config, change.id);
+    const stage = getStage(ctx.workflow, ctx.meta, ctx.meta.stage);
+    for (const command of stage?.verify?.commands ?? []) stageRuns.push(command.run);
+  }
+  const file = join11(root, ".sdd", "tools.yaml");
+  if (!await pathExists(file)) return stageRuns;
+  let raw;
+  try {
+    raw = await readYaml(file);
+  } catch {
+    return { error: "tools.yaml is invalid: tools could not be parsed" };
+  }
+  const parsed = ToolsSchema.safeParse(raw ?? {});
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const path = issue?.path.join(".") || "tools";
+    return { error: `tools.yaml is invalid: ${path} ${issue?.message ?? "invalid"}` };
+  }
+  return [...stageRuns, ...parsed.data.allow.map((entry) => entry.run)];
+}
+async function readFileTool(root, args) {
+  const rel = typeof args.path === "string" ? args.path : "";
+  if (!safePath(rel)) return result("read_file", false, "That path is outside the project.");
+  if (isSecretPath(rel)) return result("read_file", false, "That path is not readable.");
+  const file = join11(root, ...rel.split(/[/\\]/));
+  if (!await pathExists(file)) return result("read_file", false, "That path is not readable.");
+  try {
+    const text2 = await readText(file);
+    return result("read_file", true, `${rel}
+${text2}`);
+  } catch {
+    return result("read_file", false, "That path is not readable.");
+  }
+}
+async function searchTool(root, args) {
+  const query = typeof args.query === "string" ? args.query.trim() : "";
+  if (!query) return result("search", false, "A search needs a query.");
+  const scope = typeof args.scope === "string" && args.scope ? args.scope : "code";
+  if (!SCOPES.has(scope)) {
+    return result("search", false, "A search scope is code, specs, or memory.");
+  }
+  const found = await searchProject(root, query, {
+    scope,
+    k: 8,
+    budget: 2e3
+  });
+  return result("search", true, found.text || query);
+}
+async function contextTool(root, args) {
+  const path = typeof args.path === "string" ? args.path : "";
+  const query = typeof args.query === "string" ? args.query : "";
+  const symbol = typeof args.symbol === "string" ? args.symbol : "";
+  const change = await activeChange(root).catch(() => null);
+  const found = await generateCodeContext({
+    projectRoot: root,
+    changeId: change?.id,
+    paths: path ? [path] : void 0,
+    query: query || void 0,
+    symbols: symbol ? [symbol] : void 0
+  });
+  return result(
+    "context",
+    found.ok,
+    found.markdown || found.gaps.map((gap) => gap.message).join("\n")
+  );
+}
+async function appendRun(root, changeId, sha, command, exitCode, output) {
+  const file = await evidenceFile(root, changeId, sha);
+  let body = { sha, runs: [] };
+  if (await pathExists(file)) {
+    try {
+      const parsed = EvidenceSchema.safeParse(JSON.parse(await readText(file)));
+      if (!parsed.success || parsed.data.sha !== sha) {
+        return { error: "Evidence at this commit cannot be read." };
+      }
+      body = parsed.data;
+    } catch {
+      return { error: "Evidence at this commit cannot be read." };
+    }
+  }
+  body.runs.push({ command, exitCode, output: clip(output) });
+  await ensureDir(join11(file, ".."));
+  await writeText(file, `${JSON.stringify(body, null, 2)}
+`);
+  const config = await loadConfig(root);
+  return evidenceRel(config.changes_path, changeId, sha);
+}
+async function runCheck(root, args) {
+  const command = typeof args.run === "string" ? args.run.trim() : "";
+  if (!command) return result("run_check", false, "That check is not allowlisted.");
+  if (BLOCKED_CHECK.test(command)) {
+    return result("run_check", false, "That check cannot run sdd next, sdd complete, or merge.");
+  }
+  const allowed = await allowList(root);
+  if ("error" in allowed) return result("run_check", false, allowed.error);
+  if (!allowed.includes(command))
+    return result("run_check", false, "That check is not allowlisted.");
+  const change = await activeChange(root);
+  if (!change) return result("run_check", false, "No active change.");
+  const sha = await headOf(root);
+  if (!sha) return result("run_check", false, "Git HEAD is unavailable.");
+  const dir = await mkdtemp(join11(tmpdir(), "sdd-check-"));
+  const added = await git(root, ["worktree", "add", "--detach", dir, sha]);
+  if (added.code !== 0) {
+    await rm(dir, { recursive: true, force: true });
+    return result("run_check", false, "Git HEAD is unavailable.");
+  }
+  let ran = { code: 1, output: "" };
+  let removeFailed = false;
+  try {
+    ran = await shell(command, dir);
+  } finally {
+    const removed = await git(root, ["worktree", "remove", "--force", dir]);
+    await rm(dir, { recursive: true, force: true });
+    removeFailed = removed.code !== 0;
+  }
+  if (removeFailed) return result("run_check", false, "The check worktree could not be removed.");
+  const stored = await appendRun(root, change.id, sha, command, ran.code, ran.output);
+  if (typeof stored !== "string") return result("run_check", false, stored.error);
+  const text2 = [`${command}`, `exit ${ran.code ?? "none"}`, stored, clip(ran.output)].join("\n");
+  return result("run_check", ran.code === 0, text2);
+}
+async function writeFileTool(root, args) {
+  const rel = typeof args.path === "string" ? args.path : "";
+  const contents = args.contents;
+  if (!safePath(rel) || typeof contents !== "string" || isSecretPath(rel)) {
+    return result("write_file", false, "That file cannot be written.");
+  }
+  await writeText(join11(root, ...rel.split(/[/\\]/)), contents);
+  return result("write_file", true, `Wrote ${rel}.`);
+}
+function branchName(team, bot, changeId) {
+  return team.branch.replaceAll("{bot}", bot).replaceAll("{change}", changeId);
+}
+async function currentBranch(root) {
+  const found = await git(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return found.code === 0 ? found.stdout.trim() : "";
+}
+async function commitTool(root, team, bot, args) {
+  const change = await activeChange(root);
+  if (!change) return result("commit", false, "No active change.");
+  const expected = branchName(team, bot, change.id);
+  const branch = await currentBranch(root);
+  if (branch !== expected) return result("commit", false, "A bot commits only on its own branch.");
+  const message = typeof args.message === "string" ? args.message.trim() : "";
+  const paths = Array.isArray(args.paths) ? args.paths.filter((item) => typeof item === "string") : [];
+  if (!message || message.includes("\n") || paths.length === 0) {
+    return result("commit", false, "A commit needs a message and a path.");
+  }
+  for (const rel of paths) {
+    if (!safePath(rel) || isSecretPath(rel))
+      return result("commit", false, "That path is outside the project.");
+  }
+  const added = await git(root, ["add", "--", ...paths]);
+  if (added.code !== 0) return result("commit", false, clip(added.stderr || added.stdout));
+  const committed = await git(root, ["commit", "-m", message]);
+  if (committed.code !== 0)
+    return result("commit", false, clip(committed.stderr || committed.stdout));
+  return result("commit", true, clip(committed.stdout || message));
+}
+async function refusedShip(root, name, text2) {
+  const sha = await headOf(root);
+  return result(name, false, text2.replace("this SHA", sha ?? "this SHA"));
+}
+async function runTool(root, team, bot, call) {
+  const args = asRecord(call.args);
+  const name = call.name.trim();
+  if (name === "read_file") return readFileTool(root, args);
+  if (name === "search") return searchTool(root, args);
+  if (name === "context") return contextTool(root, args);
+  if (name === "run_check") return runCheck(root, args);
+  if (name === "write_file") return writeFileTool(root, args);
+  if (name === "commit") return commitTool(root, team, bot, args);
+  if (name === "push") return refusedShip(root, name, "Push needs a person at this SHA.");
+  if (name === "pull_request")
+    return refusedShip(root, name, "A pull request needs a person at this SHA.");
+  if (name === "merge" || name === "tag" || name === "deploy") {
+    return result(name, false, "A bot cannot merge.");
+  }
+  if (name === "sdd_next" || name === "sdd_complete" || name === "accept_spec") {
+    return result(name, false, "A role cannot do that.");
+  }
+  return result(name, false, "That tool is not available.");
+}
+async function reviewNeedsEvidence(root, changeId, commands, type, text2, cite) {
+  const claim = claimsPass(text2);
+  const agree = type === "agree" && commands > 0;
+  if (!claim && !agree) return null;
+  if (await evidenceSupports(root, changeId, cite)) return null;
+  return claim ? "A pass claim needs evidence at this SHA." : "A review needs evidence at this SHA.";
+}
+
+// src/team/room.ts
+var ROOM_TYPES = ["post", "objection", "agree", "block", "decision"];
+var RoomEntrySchema = z4.object({
+  ts: z4.string(),
+  from: z4.string(),
+  type: z4.enum(ROOM_TYPES),
+  text: z4.string(),
+  round: z4.number().int(),
+  cite: z4.string().optional(),
+  sha: z4.string().optional(),
+  evidence: z4.array(z4.string()).optional()
+}).strict();
+function ok3(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail3(stdout) {
+  return { exitCode: 1, stdout };
+}
+function safeId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value);
+}
+function oneLine(value, empty, broken) {
+  const raw = value ?? "";
+  if (raw.includes("\n") || raw.includes("\r")) return fail3(broken);
+  const words = raw.trim();
+  if (!words) return fail3(empty);
+  return words;
+}
+function roomPath(root, change, stage) {
+  return join12(root, ".sdd", "rooms", change, `${stage}.jsonl`);
+}
+function roomRounds(team) {
+  return team.limits?.room_rounds ?? 2;
+}
+function consensus(entries) {
+  const agreed = [];
+  const open = [];
+  for (const entry of entries) {
+    if (entry.type === "agree" && !agreed.includes(entry.from)) agreed.push(entry.from);
+    if (entry.type === "objection" || entry.type === "block") open.push(entry);
+  }
+  return { agreed, open, blocked: entries.some((entry) => entry.type === "block") };
+}
+async function readEntries(file) {
+  if (!await pathExists(file)) return [];
+  const entries = [];
+  for (const line of (await readText(file)).split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = RoomEntrySchema.safeParse(JSON.parse(line));
+      if (parsed.success) entries.push(parsed.data);
+    } catch {
+    }
+  }
+  return entries;
+}
+async function headSha(root) {
+  try {
+    return await getHeadSha(root);
+  } catch {
+    return null;
+  }
+}
+async function openChange(root, change) {
+  let config;
+  try {
+    config = await loadConfig(root);
+  } catch (error) {
+    return fail3(error instanceof Error ? error.message : "Config is invalid.");
+  }
+  const id = (change?.trim() || await getActiveChangeId(root, config) || "").trim();
+  if (!id) return fail3("No active change.");
+  if (!safeId(id)) return fail3("A change id is not valid.");
+  try {
+    const ctx = await buildContext(root, config, id);
+    return { id, path: ctx.path, stage: ctx.meta.stage, workflow: ctx.workflow, meta: ctx.meta };
+  } catch (error) {
+    return fail3(error instanceof Error ? error.message : "Change not found.");
+  }
+}
+function isFailure(value) {
+  return "exitCode" in value;
+}
+function memberBots(team, names) {
+  const bots = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const exact = team.bots.find((bot) => bot.name === name);
+    const chosen = exact ?? team.bots.find((bot) => bot.role === name);
+    if (!chosen) return { error: "Bot not found." };
+    if (seen.has(chosen.name)) continue;
+    seen.add(chosen.name);
+    bots.push(chosen);
+  }
+  if (bots.length === 0) return { error: "A room needs a member." };
+  return bots;
+}
+async function draftOf(changePath2, stage) {
+  const rel = stage?.artifacts[0]?.path;
+  if (!rel || rel.includes("..")) return "";
+  const file = join12(changePath2, rel);
+  if (!await pathExists(file)) return "";
+  return readText(file);
+}
+function formatEntry(entry) {
+  const cite = entry.cite ? ` ${entry.cite}` : "";
+  return `${entry.round} ${entry.from} ${entry.type}${cite} ${entry.text}`;
+}
+async function appendEntry(file, entry) {
+  await ensureDir(join12(file, ".."));
+  await appendFile3(file, `${JSON.stringify(entry)}
+`, "utf8");
+}
+async function consensusLine(changePath2, stage, sha, entries) {
+  const found = consensus(entries);
+  const agreed = found.agreed.join(",") || "none";
+  const open = found.open.map((entry) => entry.cite || entry.text).join(",") || "none";
+  await appendFile3(
+    join12(changePath2, "decisions.md"),
+    `${nowIso()} room ${stage} ${sha ?? "none"} agreed ${agreed} open ${open}
+`
+  );
+}
+async function showRoom(root, input) {
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail3(team.error);
+  const opened = await openChange(root, input.change);
+  if (isFailure(opened)) return opened;
+  const stage = (input.stage?.trim() || opened.stage).trim();
+  if (!safeId(stage)) return fail3("A stage id is not valid.");
+  const entries = await readEntries(roomPath(root, opened.id, stage));
+  if (entries.length === 0) return ok3("No room.");
+  return ok3(entries.map(formatEntry).join("\n"));
+}
+async function postRoom(root, input) {
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail3(team.error);
+  const opened = await openChange(root, input.change);
+  if (isFailure(opened)) return opened;
+  const stage = (input.stage?.trim() || opened.stage).trim();
+  if (!safeId(stage)) return fail3("A stage id is not valid.");
+  const text2 = oneLine(input.text, "A room entry needs text.", "A room entry is one line.");
+  if (typeof text2 !== "string") return text2;
+  const type = input.type?.trim() || "post";
+  if (!ROOM_TYPES.includes(type)) return fail3("A room entry is not valid.");
+  const cite = input.cite?.trim() ?? "";
+  if (cite && (cite.includes("\n") || cite.includes("\r"))) return fail3("A cite is one line.");
+  if (type === "objection" && !cite) return fail3("An objection needs a cite.");
+  const stageDef = getStage(opened.workflow, opened.meta, stage);
+  const needed = await reviewNeedsEvidence(
+    root,
+    opened.id,
+    stageDef?.verify?.commands?.length ?? 0,
+    type,
+    text2,
+    cite
+  );
+  if (needed) return fail3(needed);
+  const evidence = [];
+  for (const item of input.evidence ?? []) {
+    const line = oneLine(item, "Evidence needs text.", "Evidence is one line.");
+    if (typeof line !== "string") return line;
+    evidence.push(line);
+  }
+  const file = roomPath(root, opened.id, stage);
+  const prior = await readEntries(file);
+  const round = prior.reduce((max, entry2) => Math.max(max, entry2.round), 1);
+  const sha = await headSha(root);
+  const entry = {
+    ts: nowIso(),
+    from: input.from?.trim() || gitUserName(root) || "person",
+    type,
+    text: text2,
+    round: prior.length === 0 ? 1 : round
+  };
+  if (cite) entry.cite = cite;
+  if (sha) entry.sha = sha;
+  if (evidence.length > 0) entry.evidence = evidence;
+  await appendEntry(file, entry);
+  return ok3("Posted.");
+}
+async function classifyReply(root, text2, env, runCommand2) {
+  const loaded = await loadModels(root);
+  if (loaded === null) return "post";
+  if ("error" in loaded) return fail3(loaded.error);
+  const decision = await decide({
+    models: loaded.config,
+    ctx: { workType: "classify" },
+    state: text2,
+    question: "What kind of room entry is this?",
+    options: ROOM_TYPES,
+    env,
+    runCommand: runCommand2
+  });
+  if (decision.pick === "human") return "post";
+  return decision.pick;
+}
+async function reviewRoom(root, input) {
+  if (!input.model) return fail3(ROLE_TEXT.noModel);
+  const loaded = await readTeamConfig(root);
+  if ("error" in loaded) return fail3(loaded.error);
+  const opened = await openChange(root, input.change);
+  if (isFailure(opened)) return opened;
+  const stageId = (input.stage?.trim() || opened.stage).trim();
+  if (!safeId(stageId)) return fail3("A stage id is not valid.");
+  const stage = getStage(opened.workflow, opened.meta, stageId);
+  if (!stage) return fail3("Stage not found.");
+  const names = input.roles && input.roles.length > 0 ? input.roles : [stage.owner, ...stage.collaborates ?? []].filter((name) => !!name);
+  const bots = memberBots(loaded.team, names);
+  if ("error" in bots) return fail3(bots.error);
+  const file = roomPath(root, opened.id, stageId);
+  const prior = await readEntries(file);
+  const highest = prior.reduce((max, entry) => Math.max(max, entry.round), 0);
+  const round = highest + 1;
+  const cap = roomRounds(loaded.team);
+  if (round > cap) return ok3("Round limit reached.");
+  const draft = await draftOf(opened.path, stage);
+  const before = consensus(prior.filter((entry) => entry.round === highest));
+  const sha = await headSha(root);
+  const written = [];
+  for (const bot of bots) {
+    const role = await readRole(root, bot.role);
+    if (!role) return fail3(ROLE_TEXT.notFound);
+    const section = {
+      id: stageId,
+      decision: "room",
+      checks: before.open.map((entry2) => entry2.cite || "room"),
+      body: draft
+    };
+    if (section.checks.length === 0) section.checks = ["room"];
+    const rows = [critiquePrompt(role, section, draft || "(none)"), "Room:"];
+    for (const entry2 of prior) rows.push(formatEntry(entry2));
+    const owner = stage.owner === bot.role || stage.owner === bot.name;
+    if (owner && before.open.length > 0) {
+      rows.push(
+        revisionPrompt(
+          role,
+          draft || "(none)",
+          before.open.map((entry2) => ({ cite: entry2.cite || "room", text: entry2.text }))
+        )
+      );
+    }
+    rows.push('Reply with JSON {"type":"post","text":"...","cite":"..."}');
+    rows.push("An objection needs a cite.");
+    let raw = "";
+    try {
+      raw = await input.model.complete({ roleId: role.name, prompt: rows.join("\n") });
+    } catch {
+      return fail3("A room entry is not valid.");
+    }
+    const stored = await entryFromReply(root, raw, input.env, input.runCommand);
+    if (isFailure(stored)) return stored;
+    const needed = await reviewNeedsEvidence(
+      root,
+      opened.id,
+      stage.verify?.commands?.length ?? 0,
+      stored.type,
+      stored.text,
+      stored.cite ?? ""
+    );
+    if (needed) return fail3(needed);
+    const entry = {
+      ts: nowIso(),
+      from: bot.name,
+      type: stored.type,
+      text: stored.text,
+      round
+    };
+    if (stored.cite) entry.cite = stored.cite;
+    if (sha) entry.sha = sha;
+    await appendEntry(file, entry);
+    written.push(entry);
+  }
+  const latest = written;
+  await consensusLine(opened.path, stageId, sha, latest);
+  if (round >= cap && consensus(latest).open.length > 0) {
+    const asked = await recordDecisionRequest(root, {
+      change: opened.id,
+      note: `Room ${stageId} still open after ${round} rounds.`
+    });
+    if (asked.exitCode !== 0) return asked;
+    return ok3("Decision needed.");
+  }
+  return ok3(`Round ${round}.`);
+}
+async function entryFromReply(root, raw, env = process.env, runCommand2) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    value = null;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const rec = value;
+    if (typeof rec.type === "string" && typeof rec.text === "string") {
+      return checked(rec.type, rec.text, typeof rec.cite === "string" ? rec.cite : "");
+    }
+  }
+  const text2 = raw.trim();
+  if (!text2 || text2.includes("\n") || text2.includes("\r"))
+    return fail3("A room entry is not valid.");
+  const typed = await classifyReply(root, text2, env, runCommand2);
+  if (typeof typed !== "string") return typed;
+  return checked(typed, text2, "");
+}
+function checked(type, text2, cite) {
+  if (!ROOM_TYPES.includes(type)) return fail3("A room entry is not valid.");
+  const words = oneLine(text2, "A room entry needs text.", "A room entry is one line.");
+  if (typeof words !== "string") return words;
+  const citeWords = cite.trim();
+  if (citeWords && (cite.includes("\n") || cite.includes("\r"))) return fail3("A cite is one line.");
+  if (type === "objection" && !citeWords) return fail3("An objection needs a cite.");
+  return citeWords ? { type, text: words, cite: citeWords } : { type, text: words };
+}
+async function activeRoom(root) {
+  try {
+    const config = await loadConfig(root);
+    const id = await getActiveChangeId(root, config);
+    if (!id || !safeId(id)) return null;
+    const ctx = await buildContext(root, config, id);
+    const stage = ctx.meta.stage;
+    if (!safeId(stage)) return null;
+    const file = roomPath(root, id, stage);
+    if (!await pathExists(file)) return null;
+    return { file, text: await readText(file) };
+  } catch {
+    return null;
+  }
+}
+async function roomForPrompt(root) {
+  const room = await activeRoom(root);
+  return room?.text.trim() ?? "";
+}
+async function postLoopDone(root, bot, text2, cite) {
+  const words = text2.trim();
+  if (!words || words.includes("\n") || words.includes("\r")) return;
+  const room = await activeRoom(root);
+  if (!room) return;
+  let storedCite = "";
+  if (claimsPass(words)) {
+    try {
+      const config = await loadConfig(root);
+      const id = await getActiveChangeId(root, config);
+      if (!id || !cite || !await evidenceSupports(root, id, cite)) return;
+      storedCite = cite;
+    } catch {
+      return;
+    }
+  }
+  const prior = await readEntries(room.file);
+  const round = prior.reduce((max, entry2) => Math.max(max, entry2.round), 1);
+  const sha = await headSha(root);
+  const entry = {
+    ts: nowIso(),
+    from: bot,
+    type: "post",
+    text: words,
+    round: prior.length === 0 ? 1 : round
+  };
+  if (storedCite) entry.cite = storedCite;
+  if (sha) entry.sha = sha;
+  await appendEntry(room.file, entry);
+}
+
+// src/team/loop.ts
+var planStep = z5.object({ step: z5.literal("plan"), items: z5.array(z5.string()) }).strict();
+var toolStep = z5.object({ step: z5.literal("tool"), name: z5.string().min(1), args: z5.unknown() }).strict();
+var checkStep = z5.object({
+  step: z5.literal("check"),
+  claim: z5.string().min(1),
+  evidence: z5.array(z5.string()).optional()
+}).strict();
+var askStep = z5.object({
+  step: z5.literal("ask"),
+  question: z5.string().min(1),
+  options: z5.array(z5.string()),
+  suggest: z5.string().optional()
+}).strict();
+var doneStep = z5.object({
+  step: z5.literal("done"),
+  summary: z5.string(),
+  outputs: z5.array(z5.string()),
+  evidence: z5.array(z5.string()).optional()
+}).strict();
+var LoopStepSchema = z5.discriminatedUnion("step", [
+  planStep,
+  toolStep,
+  checkStep,
+  askStep,
+  doneStep
+]);
+function ok4(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail4(stdout) {
+  return { exitCode: 1, stdout };
+}
+async function appendLine(file, value) {
+  await ensureDir(join13(file, ".."));
+  await appendFile4(file, `${JSON.stringify(value)}
+`, "utf8");
+}
+async function runLoop(input) {
+  const max = input.cfg.limits?.loop_max_steps ?? 8;
+  const room = await roomForPrompt(input.root);
+  const base = room ? `${input.brain.prompt}
+Room:
+${room}` : input.brain.prompt;
+  let tools = "";
+  const promptFor = () => tools ? `${base}
+Tools:
+${tools}` : base;
+  const remember = (text2) => {
+    const piece = text2.trim().slice(-4e3);
+    tools = `${tools}
+${piece}`.trim().slice(-8e3);
+  };
+  let taken = 0;
+  let copied = false;
+  const copyReviewer = async () => {
+    if (copied) return;
+    copied = true;
+    const lesson = await priorLesson(input.root, input.logName, input.file, input.roleName);
+    if (!lesson) return;
+    await addReviewerLesson(input.root, input.brain.bot.name, lesson);
+  };
+  while (taken < max) {
+    let raw;
+    try {
+      raw = await input.model.complete({ roleId: input.roleName, prompt: promptFor() });
+    } catch {
+      await appendLine(input.file, { type: "bad_call", roleId: input.roleName });
+      return fail4("A loop step is not valid.");
+    }
+    taken += 1;
+    const step = parseStep(raw);
+    if (!step) {
+      await appendLine(input.file, { type: "bad_call", roleId: input.roleName });
+      return fail4("A loop step is not valid.");
+    }
+    if (step.kind === "understand") {
+      await appendLine(input.file, { type: "step", step: "understand" });
+      continue;
+    }
+    if (step.kind === "reflect") {
+      await appendLine(input.file, { type: "step", step: "reflect" });
+      await copyReviewer();
+      continue;
+    }
+    if (step.kind === "schema") {
+      const body = step.step;
+      if (body.step === "plan") {
+        await appendLine(input.file, { type: "step", step: "plan", items: body.items });
+        continue;
+      }
+      if (body.step === "tool") {
+        const ran = await runTool(input.root, input.cfg, input.brain.bot.name, {
+          name: body.name,
+          args: body.args
+        });
+        remember(ran.text);
+        await appendLine(input.file, { type: "step", step: "tool", name: body.name, ok: ran.ok });
+        continue;
+      }
+      if (body.step === "check") {
+        const refusal2 = await passClaimRefusal(input.root, body.claim, body.evidence ?? []);
+        if (refusal2) {
+          remember(refusal2);
+          await appendLine(input.file, { type: "step", step: "refused", text: refusal2 });
+          continue;
+        }
+        await appendLine(input.file, {
+          type: "step",
+          step: "check",
+          claim: body.claim,
+          evidence: body.evidence ?? []
+        });
+        continue;
+      }
+      if (body.step === "ask") return ask(input.root, input.file, body.question, body.options);
+      const cites = body.evidence ?? [];
+      const refusal = await passClaimRefusal(input.root, body.summary, cites);
+      if (refusal) {
+        remember(refusal);
+        await appendLine(input.file, { type: "step", step: "refused", text: refusal });
+        continue;
+      }
+      await appendLine(input.file, { type: "step", step: "done", summary: body.summary });
+      await copyReviewer();
+      await postLoopDone(input.root, input.brain.bot.name, body.summary, cites[0]);
+      return ok4(body.summary);
+    }
+  }
+  return ask(input.root, input.file, `Stopped after ${max} steps.`, ["continue", "stop"]);
+}
+async function ask(root, file, question, options) {
+  await appendLine(file, { type: "step", step: "ask", question, options });
+  const note = question.trim();
+  if (note && !note.includes("\n") && !note.includes("\r")) {
+    await recordDecisionRequest(root, { note });
+  }
+  return ok4(question);
+}
+function parseStep(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const rec = { ...value };
+  if (rec.step === "understand") return { kind: "understand" };
+  if (rec.step === "reflect") return { kind: "reflect" };
+  if (rec.step === "stop") {
+    rec.step = "done";
+    if (typeof rec.summary !== "string") rec.summary = typeof rec.text === "string" ? rec.text : "";
+    if (!Array.isArray(rec.outputs)) rec.outputs = [];
+  }
+  if (rec.step === "act") {
+    rec.step = "tool";
+    if (typeof rec.name !== "string" || !rec.name) rec.name = "act";
+    if (rec.args === void 0) rec.args = {};
+  }
+  if (rec.step === void 0 && typeof rec.text === "string") {
+    const summary = rec.text;
+    const { text: _ignored, ...rest } = rec;
+    const done = LoopStepSchema.safeParse({ ...rest, step: "done", summary, outputs: [] });
+    if (!done.success) return null;
+    return { kind: "schema", step: done.data };
+  }
+  const parsed = LoopStepSchema.safeParse(rec);
+  if (!parsed.success) return null;
+  return { kind: "schema", step: parsed.data };
+}
+async function priorLesson(root, logName, file, roleName) {
+  const dir = conversationDir(root, logName);
+  const names = (await listFiles(dir)).filter((item) => item.endsWith(".jsonl")).sort();
+  const index = names.indexOf(basename(file));
+  if (index <= 0) return null;
+  const prior = join13(dir, names[index - 1]);
+  if (!await pathExists(prior)) return null;
+  let fromChange = null;
+  let fromOther = null;
+  for (const line of (await readText(prior)).split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const rec = value;
+    if (rec.type !== "model") continue;
+    const roleId = typeof rec.roleId === "string" ? rec.roleId : "reviewer";
+    const changed = Array.isArray(rec.changed) ? rec.changed.filter((cite) => typeof cite === "string" && cite.trim() !== "") : [];
+    if (changed.length > 0) fromChange = { by: roleId, text: changed.join(", ") };
+    else if (roleId !== roleName && typeof rec.text === "string" && !rec.text.includes("\n")) {
+      fromOther = { by: roleId, text: rec.text };
+    }
+  }
+  return fromChange ?? fromOther;
+}
+
+// src/role/run.ts
+var DRAFT_KINDS = /* @__PURE__ */ new Set(["code", "scenario", "release"]);
+var FORBIDDEN = /* @__PURE__ */ new Set([
+  "accept_spec",
+  "replace_decision",
+  "write_qa",
+  "generate_release",
+  "sdd_next",
+  "sdd_complete",
+  "create_change"
+]);
+var UNAVAILABLE = /* @__PURE__ */ new Set(["commit", "push", "tag", "pull_request", "merge", "deploy"]);
+var CLOSED = /* @__PURE__ */ new Set(["applied", "denied", "rejected", "unavailable", "stopped", "expired"]);
+function ok5(stdout = "", runId) {
+  return runId ? { exitCode: 0, stdout, runId } : { exitCode: 0, stdout };
+}
+function fail5(stdout, runId) {
+  return runId ? { exitCode: 1, stdout, runId } : { exitCode: 1, stdout };
+}
+function linesOf(...parts) {
+  return parts.filter((part) => part.length > 0).join("\n");
+}
+function runIdFrom(date) {
+  const iso = date.toISOString();
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(iso);
+  if (!match) return "unknown";
+  return `${match[1]}${match[2]}${match[3]}T${match[4]}${match[5]}${match[6]}Z`;
+}
+function mentionsX(task) {
+  return /@X|x\.com|twitter\.com/.test(task);
+}
+function safeChangeId(id) {
+  if (!id || id.length > 200) return false;
+  if (id === "." || id === "..") return false;
+  return !id.includes("/") && !id.includes("\\") && !id.includes("\0");
+}
+function safeRunId(id) {
+  if (!id || id.length > 80) return false;
+  if (id === "." || id === "..") return false;
+  return !id.includes("/") && !id.includes("\\") && !id.includes("\0");
+}
+function isSafeProductPath(rel) {
+  if (typeof rel !== "string" || rel.length === 0 || rel.includes("\0")) return false;
+  if (isAbsolute4(rel) || rel.startsWith("\\")) return false;
+  if (/^[A-Za-z]:/.test(rel)) return false;
+  const parts = rel.split(/[/\\]/);
+  for (const part of parts) {
+    if (part === "" || part === "." || part === ".." || part === ".active" || part === ".sdd") {
+      return false;
+    }
+  }
+  return parts[parts.length - 1] !== "accepted.md";
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
   if (value && typeof value === "object") {
     const rec = value;
     const out = {};
@@ -2811,8 +4470,8 @@ function parseReply(raw) {
   return { text: rec.text, gaps, changed, action };
 }
 async function appendJson(file, value) {
-  await ensureDir(join9(file, ".."));
-  await appendFile(file, `${JSON.stringify(value)}
+  await ensureDir(join14(file, ".."));
+  await appendFile5(file, `${JSON.stringify(value)}
 `, "utf8");
 }
 async function readJsonLines(file) {
@@ -2828,7 +4487,7 @@ async function readJsonLines(file) {
   return lines;
 }
 async function timeoutMinutes(root) {
-  const path = join9(root, ".sdd", "role.yaml");
+  const path = join14(root, ".sdd", "role.yaml");
   if (!await pathExists(path)) return 10;
   let data;
   try {
@@ -2865,30 +4524,10 @@ function authorPrompt(role, task, kind, section) {
   }
   return rows.join("\n");
 }
-function critiquePrompt(role, section, draft) {
-  return [
-    `Job: ${role.job}`,
-    "Check ids:",
-    ...section.checks,
-    `Cite: ${section.id}:${section.decision}`,
-    "Draft:",
-    draft
-  ].join("\n");
-}
-function revisionPrompt(role, draft, gaps) {
-  return [
-    `Job: ${role.job}`,
-    "Draft:",
-    draft,
-    "Gaps:",
-    ...gaps.map((gap) => `${gap.cite}: ${gap.text}`),
-    "changed must list every gap cite."
-  ].join("\n");
-}
 async function acceptedFile(root, changeId) {
-  if (!await pathExists(configPath(root))) return join9(root, "changes", changeId, "accepted.md");
+  if (!await pathExists(configPath(root))) return join14(root, "changes", changeId, "accepted.md");
   const config = await loadConfig(root);
-  return join9(changesDir(root, config), changeId, "accepted.md");
+  return join14(changesDir(root, config), changeId, "accepted.md");
 }
 async function callModel(model, file, roleId, prompt, pass) {
   let raw;
@@ -2915,12 +4554,16 @@ async function readRule(root, roleName) {
   const name = typeof rec.tool === "string" ? rec.tool : typeof rec.name === "string" ? rec.name : "";
   if (!name) return null;
   if (!rec.inputs || typeof rec.inputs !== "object" || Array.isArray(rec.inputs)) return null;
+  const stored = typeof rec.sha === "string" ? rec.sha : "";
+  const head = await getHeadSha(root);
+  if (head && stored !== head) return null;
   return { name, inputs: rec.inputs };
 }
 async function saveRule(root, roleName, rule) {
   const path = allowFilePath(root);
   const existing = await readAllowFile(root) ?? {};
-  existing[roleName] = { tool: rule.name, inputs: rule.inputs };
+  const head = await getHeadSha(root);
+  existing[roleName] = head ? { tool: rule.name, inputs: rule.inputs, sha: head } : { tool: rule.name, inputs: rule.inputs };
   await writeText(path, `${JSON.stringify(existing, null, 2)}
 `);
 }
@@ -2939,7 +4582,7 @@ async function applyAction(root, file, roleName, action, mode) {
     await appendJson(file, { type: "rejected" });
     return { exitCode: 1, stdout: ROLE_TEXT.cannot, applied: false };
   }
-  await writeText(join9(root, ...path.split(/[/\\]/)), contents);
+  await writeText(join14(root, ...path.split(/[/\\]/)), contents);
   if (mode === "always")
     await saveRule(root, roleName, { name: action.name, inputs: action.inputs });
   await appendJson(file, { type: "applied", name: "write_file" });
@@ -2947,16 +4590,16 @@ async function applyAction(root, file, roleName, action, mode) {
 }
 async function finishRun(root, file, role, final, minutes, now, runId) {
   const action = final.action;
-  if (!action) return ok2(final.text, runId);
+  if (!action) return ok5(final.text, runId);
   if (FORBIDDEN.has(action.name) || !UNAVAILABLE.has(action.name) && action.name !== "write_file") {
     await appendJson(file, { type: "rejected" });
-    return fail2(linesOf(final.text, ROLE_TEXT.cannot), runId);
+    return fail5(linesOf(final.text, ROLE_TEXT.cannot), runId);
   }
   const rule = await readRule(root, role.name);
   if (!role.askFirst && rule && rule.name === action.name && sameInputs(rule.inputs, action.inputs)) {
     const applied = await applyAction(root, file, role.name, action, "always");
     const stdout = applied.applied ? final.text : linesOf(final.text, applied.stdout);
-    return applied.exitCode === 0 ? ok2(stdout, runId) : fail2(stdout, runId);
+    return applied.exitCode === 0 ? ok5(stdout, runId) : fail5(stdout, runId);
   }
   const expiresAt = new Date(now.getTime() + minutes * 6e4).toISOString();
   await appendJson(file, {
@@ -2964,12 +4607,12 @@ async function finishRun(root, file, role, final, minutes, now, runId) {
     action: { name: action.name, words: action.words, inputs: action.inputs },
     expiresAt
   });
-  if (role.askFirst) return ok2(linesOf(action.words, ROLE_TEXT.askFirst), runId);
-  return ok2(linesOf(action.words, ROLE_TEXT.choice), runId);
+  if (role.askFirst) return ok5(linesOf(action.words, ROLE_TEXT.askFirst), runId);
+  return ok5(linesOf(action.words, ROLE_TEXT.choice), runId);
 }
 async function settleRoleReply(root, file, role, reply, now, runId) {
   const minutes = await timeoutMinutes(root);
-  if (minutes === "invalid") return fail2(ROLE_TEXT.badYaml, runId);
+  if (minutes === "invalid") return fail5(ROLE_TEXT.badYaml, runId);
   return finishRun(
     root,
     file,
@@ -2984,54 +4627,69 @@ async function latestRunFile(root, name) {
   const dir = conversationDir(root, name);
   const files = (await listFiles(dir)).filter((file) => file.endsWith(".jsonl")).sort();
   const last = files[files.length - 1];
-  return last ? join9(dir, last) : null;
+  return last ? join14(dir, last) : null;
 }
 async function runRole(root, input) {
   const name = canonicalRoleName(input.name);
-  if (!name) return fail2(ROLE_TEXT.badName);
+  if (!name) return fail5(ROLE_TEXT.badName);
   if (input.stop) {
-    if (!await readRole(root, name)) return fail2(ROLE_TEXT.notFound);
+    if (!await readRole(root, name)) return fail5(ROLE_TEXT.notFound);
     const latest = await latestRunFile(root, name);
-    if (!latest) return fail2(ROLE_TEXT.runNotFound);
+    if (!latest) return fail5(ROLE_TEXT.runNotFound);
     await appendJson(latest, { type: "stopped" });
-    return ok2();
+    return ok5();
+  }
+  let roleName = name;
+  let team = null;
+  let botName = "";
+  if (await pathExists(join14(root, ".sdd", "team.yaml"))) {
+    const loaded = await readTeamConfig(root);
+    if ("error" in loaded) return fail5(loaded.error);
+    const resolved = resolveBot(loaded.team, name);
+    if ("error" in resolved) {
+      if (resolved.error === "Name the bot.") return fail5(resolved.error);
+    } else {
+      team = loaded.team;
+      botName = resolved.name;
+      roleName = resolved.role;
+    }
   }
-  const role = await readRole(root, name);
-  if (!role) return fail2(ROLE_TEXT.notFound);
-  if (!role.job.trim()) return fail2(ROLE_TEXT.needsJob);
+  const role = await readRole(root, roleName);
+  if (!role) return fail5(ROLE_TEXT.notFound);
+  if (!role.job.trim()) return fail5(ROLE_TEXT.needsJob);
   const task = input.task ?? "";
   let withName = "";
   if (input.withRole !== void 0 && input.withRole.trim() !== "") {
     const canonical = canonicalRoleName(input.withRole);
-    if (!canonical) return fail2(ROLE_TEXT.badName);
-    if (canonical === name) return fail2(ROLE_TEXT.self);
+    if (!canonical) return fail5(ROLE_TEXT.badName);
+    if (canonical === name) return fail5(ROLE_TEXT.self);
     withName = canonical;
   }
-  if (mentionsX(task)) return fail2(ROLE_TEXT.x);
+  if (mentionsX(task)) return fail5(ROLE_TEXT.x);
   const kind = input.kind?.trim() || "reading";
   let section;
   if (kind !== "reading") {
-    if (!DRAFT_KINDS.has(kind)) return fail2(ROLE_TEXT.needsSection);
+    if (!DRAFT_KINDS.has(kind)) return fail5(ROLE_TEXT.needsSection);
     const changeId = input.change?.trim() ?? "";
     const sectionId = input.section?.trim() ?? "";
-    if (!safeChangeId(changeId) || !sectionId) return fail2(ROLE_TEXT.needsSection);
+    if (!safeChangeId(changeId) || !sectionId) return fail5(ROLE_TEXT.needsSection);
     const acceptedPath = await acceptedFile(root, changeId);
-    if (!await pathExists(acceptedPath)) return fail2(ROLE_TEXT.needsSection);
+    if (!await pathExists(acceptedPath)) return fail5(ROLE_TEXT.needsSection);
     const parsed = parseSection(await readText(acceptedPath), sectionId);
-    if (!parsed) return fail2(ROLE_TEXT.needsSection);
+    if (!parsed) return fail5(ROLE_TEXT.needsSection);
     section = parsed;
   }
   let critic = null;
   if (withName && section) {
     critic = await readRole(root, withName);
-    if (!critic) return fail2(ROLE_TEXT.notFound);
+    if (!critic) return fail5(ROLE_TEXT.notFound);
   }
   const minutes = await timeoutMinutes(root);
-  if (minutes === "invalid") return fail2(ROLE_TEXT.badYaml);
-  if (!input.model) return fail2(ROLE_TEXT.noModel);
+  if (minutes === "invalid") return fail5(ROLE_TEXT.badYaml);
+  if (!input.model) return fail5(ROLE_TEXT.noModel);
   const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
   const runId = runIdFrom(now);
-  const file = join9(conversationDir(root, name), `${runId}.jsonl`);
+  const file = join14(conversationDir(root, name), `${runId}.jsonl`);
   if (section) {
     await appendJson(file, {
       type: "checks",
@@ -3040,6 +4698,27 @@ async function runRole(root, input) {
       decision: section.decision
     });
   }
+  if (team && botName) {
+    let budget = 12e3;
+    try {
+      const search = await loadSearchConfig(root);
+      budget = budgetForStage(search, void 0);
+    } catch (error) {
+      if (error instanceof SearchConfigError) return fail5("search.yaml is invalid", runId);
+      throw error;
+    }
+    const brain = await loadBrain(root, team, botName, { text: task }, budget);
+    if ("error" in brain) return fail5(brain.error, runId);
+    return runLoop({
+      root,
+      cfg: team,
+      brain,
+      model: input.model,
+      file,
+      roleName: role.name,
+      logName: name
+    });
+  }
   const draft = await callModel(
     input.model,
     file,
@@ -3047,7 +4726,7 @@ async function runRole(root, input) {
     authorPrompt(role, task, kind, section),
     1
   );
-  if (!draft) return fail2("", runId);
+  if (!draft) return fail5("", runId);
   let final = draft;
   if (critic && section) {
     const accepted = section;
@@ -3058,10 +4737,10 @@ async function runRole(root, input) {
       critiquePrompt(critic, accepted, draft.text),
       2
     );
-    if (!critique) return fail2(draft.text, runId);
+    if (!critique) return fail5(draft.text, runId);
     if (critique.gaps.some((gap) => !citeOk(gap.cite, accepted))) {
       await appendJson(file, { type: "bad_call", roleId: critic.name });
-      return fail2(draft.text, runId);
+      return fail5(draft.text, runId);
     }
     if (critique.gaps.length > 0) {
       const revision = await callModel(
@@ -3071,11 +4750,11 @@ async function runRole(root, input) {
         revisionPrompt(role, draft.text, critique.gaps),
         3
       );
-      if (!revision) return fail2(draft.text, runId);
+      if (!revision) return fail5(draft.text, runId);
       const cites = critique.gaps.map((gap) => gap.cite);
       if (revision.changed === null || !sameCiteSet(revision.changed, cites)) {
         await appendJson(file, { type: "bad_call", roleId: role.name });
-        return fail2(draft.text, runId);
+        return fail5(draft.text, runId);
       }
       final = revision;
     }
@@ -3114,7 +4793,7 @@ async function findRun(root, runId) {
   if (!safeRunId(runId)) return null;
   const hits = [];
   for (const roleName of await listConversationRoles(root)) {
-    const file = join9(conversationDir(root, roleName), `${runId}.jsonl`);
+    const file = join14(conversationDir(root, roleName), `${runId}.jsonl`);
     if (await pathExists(file)) hits.push({ file, roleName });
   }
   if (hits.length === 1) return hits[0];
@@ -3126,33 +4805,482 @@ async function findRun(root, runId) {
 }
 async function allowRole(root, input) {
   const found = await findRun(root, input.runId);
-  if (!found) return fail2(ROLE_TEXT.runNotFound);
+  if (!found) return fail5(ROLE_TEXT.runNotFound);
   const pending = openPending(await readJsonLines(found.file));
-  if (!pending) return fail2(ROLE_TEXT.runNotFound);
+  if (!pending) return fail5(ROLE_TEXT.runNotFound);
   const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
   const expires = Date.parse(pending.expiresAt);
   if (!Number.isFinite(expires) || now.getTime() >= expires) {
     await appendJson(found.file, { type: "expired" });
-    return fail2(ROLE_TEXT.expired);
+    return fail5(ROLE_TEXT.expired);
   }
   if (input.mode === "deny") {
     await appendJson(found.file, { type: "denied" });
-    return ok2("", input.runId);
+    return ok5("", input.runId);
   }
   const role = await readRole(root, found.roleName);
-  if (!role) return fail2(ROLE_TEXT.notFound);
-  if (role.askFirst) return ok2(ROLE_TEXT.askFirst, input.runId);
+  if (!role) return fail5(ROLE_TEXT.notFound);
+  if (role.askFirst) return ok5(ROLE_TEXT.askFirst, input.runId);
   const applied = await applyAction(root, found.file, found.roleName, pending, input.mode);
-  return applied.exitCode === 0 ? ok2(applied.stdout, input.runId) : fail2(applied.stdout, input.runId);
+  return applied.exitCode === 0 ? ok5(applied.stdout, input.runId) : fail5(applied.stdout, input.runId);
+}
+
+// src/role/routing.ts
+var matcher = z6.string().trim().min(1);
+var RoutingRuleSchema = z6.object({
+  id: matcher,
+  role: matcher,
+  stage: matcher.optional(),
+  artifact: matcher.optional(),
+  owns: matcher.optional(),
+  skill: matcher.optional()
+}).strict().superRefine((rule, ctx) => {
+  if (!rule.stage && !rule.artifact && !rule.owns && !rule.skill) {
+    ctx.addIssue({
+      code: "custom",
+      message: "needs stage, artifact, owns, or skill"
+    });
+  }
+});
+var RoutingSchema = z6.object({
+  rules: z6.array(RoutingRuleSchema)
+}).strict().superRefine((file, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, rule] of file.rules.entries()) {
+    if (seen.has(rule.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["rules", index, "id"],
+        message: "is repeated"
+      });
+    }
+    seen.add(rule.id);
+  }
+});
+function ok6(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail6(stdout) {
+  return { exitCode: 1, stdout };
+}
+function formatRoutingError(error) {
+  const issue = error.issues[0];
+  const path = issue?.path.join(".") || "routing";
+  const message = issue?.message ?? "invalid";
+  return `routing.yaml is invalid: ${path} ${message}`;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function cleanItem(input) {
+  const item = {};
+  const id = input.id?.trim();
+  const stage = input.stage?.trim();
+  const artifact = input.artifact?.trim();
+  const skill = input.skill?.trim();
+  const bot = input.bot?.trim();
+  if (id) item.id = id;
+  if (stage) item.stage = stage;
+  if (artifact) item.artifact = artifact;
+  if (skill) item.skill = skill;
+  if (bot) item.bot = bot;
+  return item;
+}
+function inboxFile(root, name) {
+  const canonical = canonicalRoleName(name);
+  if (!canonical) return null;
+  return join15(root, ".sdd", "agents", canonical, "inbox.jsonl");
+}
+async function writeHandoffInboxes(root, record) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of [record.from, record.to]) {
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const file = inboxFile(root, name);
+    if (!file) continue;
+    await appendJson(file, record);
+  }
+}
+async function readRouting(root) {
+  const path = join15(root, ".sdd", "routing.yaml");
+  if (!await pathExists(path)) return { rules: [] };
+  let raw;
+  try {
+    raw = parseYaml2(await readText(path));
+  } catch {
+    return { error: "routing.yaml is invalid: routing could not be parsed" };
+  }
+  const parsed = RoutingSchema.safeParse(raw);
+  if (!parsed.success) return { error: formatRoutingError(parsed.error) };
+  return parsed.data;
+}
+async function loadRoles(root) {
+  const dir = join15(root, ".sdd", "roles");
+  const files = (await listFiles(dir)).filter((file) => file.endsWith(".md")).sort();
+  const roles = [];
+  for (const file of files) {
+    const name = file.slice(0, -".md".length);
+    let parsed;
+    try {
+      parsed = parseRoleDocument(name, await readText(join15(dir, file)));
+    } catch {
+      return { error: `Role file is invalid: ${name}.` };
+    }
+    if (!parsed) return { error: `Role file is invalid: ${name}.` };
+    roles.push(parsed);
+  }
+  return roles;
+}
+function ruleMatches(rule, item) {
+  if (rule.stage && rule.stage !== item.stage) return false;
+  if (rule.artifact && rule.artifact !== item.artifact) return false;
+  if (rule.owns && rule.owns !== item.artifact) return false;
+  if (rule.skill && rule.skill !== item.skill) return false;
+  return true;
+}
+function listedOwners(roles, item) {
+  if (item.artifact) {
+    const names = roles.filter((role) => role.owns.includes(item.artifact ?? "")).map((role) => role.name);
+    if (names.length > 0) return { rule: "owns", names };
+  }
+  if (item.skill) {
+    const names = roles.filter((role) => role.skills.includes(item.skill ?? "")).map((role) => role.name);
+    if (names.length > 0) return { rule: "skill", names };
+  }
+  return null;
+}
+async function stageOwner(root, stageId) {
+  let config;
+  try {
+    config = await loadConfig(root);
+  } catch {
+    return void 0;
+  }
+  const changeId = await getActiveChangeId(root, config);
+  if (!changeId) return void 0;
+  try {
+    const context = await buildContext(root, config, changeId);
+    return context.workflow.stages.find((stage) => stage.id === stageId)?.owner;
+  } catch {
+    return { error: "Change is unreadable." };
+  }
+}
+async function matchRoute(root, input) {
+  const item = cleanItem(input);
+  const routing = await readRouting(root);
+  if ("error" in routing) return { ok: false, message: routing.error };
+  const rule = routing.rules.find((candidate) => ruleMatches(candidate, item));
+  if (rule) {
+    return {
+      ok: true,
+      match: { kind: "role", role: rule.role, reason: `Rule ${rule.id} matches.`, rule: rule.id }
+    };
+  }
+  const roles = await loadRoles(root);
+  if ("error" in roles) return { ok: false, message: roles.error };
+  const listed = listedOwners(roles, item);
+  if (listed && listed.names.length > 1) {
+    return { ok: true, match: { kind: "ask", reason: "Two roles own this." } };
+  }
+  if (listed && listed.names.length === 1) {
+    const role = listed.names[0] ?? "";
+    if (listed.rule === "owns") {
+      return {
+        ok: true,
+        match: {
+          kind: "role",
+          role,
+          reason: `One role owns ${item.artifact}.`,
+          rule: "owns"
+        }
+      };
+    }
+    return {
+      ok: true,
+      match: {
+        kind: "role",
+        role,
+        reason: `One role has skill ${item.skill}.`,
+        rule: "skill"
+      }
+    };
+  }
+  if (item.stage) {
+    const owner = await stageOwner(root, item.stage);
+    if (owner && typeof owner === "object") return { ok: false, message: owner.error };
+    if (typeof owner === "string" && roles.some((role) => role.name === owner)) {
+      return {
+        ok: true,
+        match: {
+          kind: "role",
+          role: owner,
+          reason: `Stage ${item.stage} is owned by ${owner}.`,
+          rule: "stage-owner"
+        }
+      };
+    }
+  }
+  return { ok: true, match: { kind: "ask", reason: "No rule matched." } };
+}
+async function activeStageItem(root) {
+  let config;
+  try {
+    config = await loadConfig(root);
+  } catch {
+    return { error: "No active change." };
+  }
+  const changeId = await getActiveChangeId(root, config);
+  if (!changeId) return { error: "No active change." };
+  try {
+    const context = await buildContext(root, config, changeId);
+    const stage = context.workflow.stages.find((item2) => item2.id === context.meta.stage) ?? context.active[0];
+    if (!stage) return { error: "No active change." };
+    const artifact = stage.artifacts.find((item2) => !item2.path.endsWith("/"))?.path;
+    const item = { stage: stage.id };
+    if (artifact) item.artifact = artifact;
+    return item;
+  } catch {
+    return { error: "Change is unreadable." };
+  }
+}
+async function prepareItem(root, input) {
+  const item = cleanItem(input);
+  if (item.stage || item.artifact || item.skill) return item;
+  const active = await activeStageItem(root);
+  if ("error" in active) return active;
+  const merged = { ...active };
+  if (item.id) merged.id = item.id;
+  if (item.bot) merged.bot = item.bot;
+  return merged;
+}
+function formatHit(match) {
+  if (match.kind === "ask") return `Ask the human.
+${match.reason}`;
+  return `role ${match.role}
+reason ${match.reason}
+rule ${match.rule}`;
+}
+function routeState(item) {
+  return JSON.stringify({
+    stage: item.stage ?? null,
+    artifact: item.artifact ?? null,
+    skill: item.skill ?? null,
+    id: item.id ?? null
+  });
+}
+async function routeMetrics(root) {
+  try {
+    const config = await loadConfig(root);
+    const changeId = await getActiveChangeId(root, config);
+    if (!changeId) return void 0;
+    return { projectRoot: root, config, changeId };
+  } catch {
+    return void 0;
+  }
+}
+async function routeRole(root, input, deps) {
+  const item = await prepareItem(root, input);
+  if ("error" in item) return fail6(item.error);
+  const matched = await matchRoute(root, item);
+  if (!matched.ok) return fail6(matched.message);
+  if (matched.match.kind !== "ask" || matched.match.reason !== "No rule matched.") {
+    return ok6(formatHit(matched.match));
+  }
+  const loaded = await loadModels(root);
+  if (loaded === null) return ok6(formatHit(matched.match));
+  if ("error" in loaded) return fail6(loaded.error);
+  const roles = await loadRoles(root);
+  if ("error" in roles) return fail6(roles.error);
+  const names = roles.map((role) => role.name).sort((left, right) => left.localeCompare(right));
+  const options = names.includes("human") ? names : [...names, "human"];
+  const decision = await decide({
+    models: loaded.config,
+    ctx: { workType: "route", stage: item.stage, bot: item.bot },
+    state: routeState(item),
+    question: "No rule matched.",
+    options,
+    env: deps?.env ?? {},
+    fetch: deps?.fetch,
+    runCommand: deps?.runCommand,
+    now: deps?.now,
+    metrics: await routeMetrics(root)
+  });
+  if (decision.pick !== "human" && names.includes(decision.pick)) {
+    const id = decision.choice?.id ?? "model";
+    return ok6(`role ${decision.pick}
+reason Model ${id} picked ${decision.pick}.`);
+  }
+  return ok6("Ask the human.\nNo rule matched.");
+}
+async function readInbox(root, name) {
+  const file = inboxFile(root, name);
+  if (!file) return { error: ROLE_TEXT.badName };
+  if (!await pathExists(file)) return [];
+  let raw;
+  try {
+    raw = await readText(file);
+  } catch {
+    return { error: "inbox.jsonl is invalid" };
+  }
+  const entries = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      return { error: "inbox.jsonl is invalid" };
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { error: "inbox.jsonl is invalid" };
+    }
+    const record = value;
+    if (record.type === "item") {
+      const id = text(record.id);
+      if (!id || record.status !== "active" && record.status !== "done") {
+        return { error: "inbox.jsonl is invalid" };
+      }
+      entries.push({
+        type: "item",
+        id,
+        status: record.status,
+        stage: text(record.stage),
+        artifact: text(record.artifact)
+      });
+      continue;
+    }
+    if (record.type === "handoff") {
+      const from = text(record.from);
+      const to = text(record.to);
+      if (!from || !to) return { error: "inbox.jsonl is invalid" };
+      entries.push({ type: "handoff", from, to });
+      continue;
+    }
+    if (typeof record.type === "string" && record.type.trim()) {
+      entries.push({ type: "other", label: record.type.trim() });
+      continue;
+    }
+    return { error: "inbox.jsonl is invalid" };
+  }
+  return entries;
+}
+function formatInbox(name, entries) {
+  if (entries.length === 0) return `${name}
+- (empty)`;
+  const lines = entries.map((entry) => {
+    if (entry.type === "item") {
+      const stage = entry.stage ? ` ${entry.stage}` : "";
+      const artifact = entry.artifact ? ` ${entry.artifact}` : "";
+      return `- ${entry.id} ${entry.status}${stage}${artifact}`;
+    }
+    if (entry.type === "handoff") return `- handoff from ${entry.from} to ${entry.to}`;
+    return `- ${entry.label}`;
+  });
+  return `${name}
+${lines.join("\n")}`;
+}
+async function queueNames(root, bot) {
+  if (bot) {
+    if (!canonicalRoleName(bot)) return { error: ROLE_TEXT.badName };
+    return [bot];
+  }
+  const team = await readTeamConfig(root);
+  if ("team" in team) return team.team.bots.map((item) => item.name);
+  const dirs = (await listDirs(join15(root, ".sdd", "agents"))).sort();
+  if (dirs.length === 0) return { error: team.error };
+  return dirs;
+}
+async function queueRole(root, bot) {
+  const names = await queueNames(root, bot?.trim());
+  if ("error" in names) return fail6(names.error);
+  const blocks = [];
+  for (const name of names) {
+    const entries = await readInbox(root, name);
+    if ("error" in entries) return fail6(entries.error);
+    blocks.push(formatInbox(name, entries));
+  }
+  return ok6(blocks.join("\n\n"));
+}
+function itemId(item) {
+  if (item.id) return item.id;
+  if (item.artifact) {
+    const base = item.artifact.split("/").pop() ?? "";
+    const stem = base.replace(/\.[A-Za-z0-9]+$/, "");
+    if (stem) return stem;
+  }
+  return item.stage ?? null;
+}
+async function takeRole(root, input) {
+  const item = await prepareItem(root, input);
+  if ("error" in item) return fail6(item.error);
+  const matched = await matchRoute(root, item);
+  if (!matched.ok) return fail6(matched.message);
+  const match = matched.match;
+  if (match.kind === "ask") return fail6(formatHit(match));
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail6(team.error);
+  const bots = team.team.bots.filter((bot) => bot.role === match.role);
+  if (bots.length === 0) return fail6(`No bot has role ${match.role}.`);
+  const requested = input.bot?.trim();
+  if (requested && !canonicalRoleName(requested)) return fail6(ROLE_TEXT.badName);
+  if (requested && !bots.some((bot) => bot.name === requested)) {
+    const known = team.team.bots.some((bot) => bot.name === requested);
+    if (!known) return fail6("Bot not found.");
+    return fail6(`${requested} is not a ${match.role}.`);
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const bot of team.team.bots) {
+    const entries = await readInbox(root, bot.name);
+    if ("error" in entries) return fail6(entries.error);
+    counts.set(
+      bot.name,
+      entries.filter((entry) => entry.type === "item" && entry.status === "active").length
+    );
+  }
+  const roleCount = bots.reduce((sum, bot) => sum + (counts.get(bot.name) ?? 0), 0);
+  const roleCap = team.team.role_wip?.[match.role];
+  if (roleCap !== void 0 && roleCount >= roleCap) {
+    return fail6(`${match.role} is at the limit.`);
+  }
+  const chosen = requested ? bots.find((bot) => bot.name === requested) : bots.find((bot) => (counts.get(bot.name) ?? 0) < bot.wip);
+  if (!chosen || (counts.get(chosen.name) ?? 0) >= chosen.wip) {
+    return fail6(`${requested || bots[0]?.name || match.role} is at the limit.`);
+  }
+  const id = itemId(item);
+  if (!id) return fail6("An item needs an id.");
+  for (const bot of team.team.bots) {
+    const entries = await readInbox(root, bot.name);
+    if ("error" in entries) return fail6(entries.error);
+    if (entries.some((entry) => entry.type === "item" && entry.status === "active" && entry.id === id)) {
+      return fail6(`${id} is already active.`);
+    }
+  }
+  const record = {
+    type: "item",
+    id,
+    status: "active",
+    role: match.role,
+    rule: match.rule,
+    reason: match.reason
+  };
+  if (item.stage) record.stage = item.stage;
+  if (item.artifact) record.artifact = item.artifact;
+  if (item.skill) record.skill = item.skill;
+  const file = inboxFile(root, chosen.name);
+  if (!file) return fail6(ROLE_TEXT.badName);
+  await appendJson(file, record);
+  return ok6(`${chosen.name} took ${id}
+role ${match.role}
+rule ${match.rule}`);
 }
 
 // src/role/handoff.ts
 var ID = /^[a-z][a-z0-9-]{0,39}$/;
 var ROLE_YAML = ["role.yaml"];
-function ok3(stdout = "", runId) {
+function ok7(stdout = "", runId) {
   return runId ? { exitCode: 0, stdout, runId } : { exitCode: 0, stdout };
 }
-function fail3(stdout, runId) {
+function fail7(stdout, runId) {
   return runId ? { exitCode: 1, stdout, runId } : { exitCode: 1, stdout };
 }
 function mentionsX2(task) {
@@ -3163,10 +5291,10 @@ function safeChangeId2(id) {
   return !id.includes("/") && !id.includes("\\") && !id.includes("\0");
 }
 function yamlPath(root) {
-  return join10(root, ".sdd", ...ROLE_YAML);
+  return join16(root, ".sdd", ...ROLE_YAML);
 }
 function planPath(root, changeId, sectionId) {
-  return join10(root, ".sdd", "role-runs", "plans", changeId, `${sectionId}.json`);
+  return join16(root, ".sdd", "role-runs", "plans", changeId, `${sectionId}.json`);
 }
 async function loadYaml(root) {
   const path = yamlPath(root);
@@ -3197,11 +5325,11 @@ async function messagingOn(root) {
 }
 async function setRoleMessaging(root, enabled) {
   const loaded = await loadYaml(root);
-  if (loaded === "invalid") return fail3(ROLE_TEXT.badYaml);
+  if (loaded === "invalid") return fail7(ROLE_TEXT.badYaml);
   const raw = loaded === "missing" ? {} : loaded;
   raw.role_messaging = enabled;
-  await writeText(yamlPath(root), stringifyYaml2(raw));
-  return ok3(enabled ? "Messaging between roles is on." : "Messaging between roles is off.");
+  await writeText(yamlPath(root), stringifyYaml(raw));
+  return ok7(enabled ? "Messaging between roles is on." : "Messaging between roles is off.");
 }
 function field(body, prefix) {
   const found = [];
@@ -3300,29 +5428,30 @@ function receiverPrompt(role, task, section) {
 async function handoffRole(root, input) {
   const from = canonicalRoleName(input.from);
   const to = canonicalRoleName(input.to);
-  if (!from || !to) return fail3(ROLE_TEXT.badName);
-  if (from === to) return fail3("A role cannot hand off to itself.");
+  if (!from || !to) return fail7(ROLE_TEXT.badName);
+  if (from === to) return fail7("A role cannot hand off to itself.");
   const sender = await readRole(root, from);
   const receiver = await readRole(root, to);
-  if (!sender || !receiver) return fail3(ROLE_TEXT.notFound);
+  if (!sender || !receiver) return fail7(ROLE_TEXT.notFound);
   const task = input.task ?? "";
-  if (mentionsX2(task)) return fail3(ROLE_TEXT.x);
+  if (mentionsX2(task)) return fail7(ROLE_TEXT.x);
   const loaded = await acceptedFacts(root, input.change?.trim() ?? "", input.section?.trim() ?? "");
-  if (!loaded) return fail3(ROLE_TEXT.needsSection);
+  if (!loaded) return fail7(ROLE_TEXT.needsSection);
   if (loaded.current.owners.length > 0 && !loaded.current.owners.includes(to)) {
-    return fail3("One owner handles this section.");
+    return fail7("One owner handles this section.");
   }
   const messaging = await messagingOn(root);
-  if (messaging === false) return ok3("Messaging between roles is off.");
-  if (!input.model) return fail3(ROLE_TEXT.noModel);
-  if (messaging === "invalid") return fail3(ROLE_TEXT.badYaml);
+  if (messaging === false) return ok7("Messaging between roles is off.");
+  if (!input.model) return fail7(ROLE_TEXT.noModel);
+  if (messaging === "invalid") return fail7(ROLE_TEXT.badYaml);
   const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
   const runId = runIdFrom(now);
-  const senderFile = join10(conversationDir(root, from), `${runId}.jsonl`);
-  const receiverFile = join10(conversationDir(root, to), `${runId}.jsonl`);
+  const senderFile = join16(conversationDir(root, from), `${runId}.jsonl`);
+  const receiverFile = join16(conversationDir(root, to), `${runId}.jsonl`);
   const record = handoffRecord(from, to, input.change?.trim() ?? "", loaded.current);
   await appendJson(senderFile, record);
   await appendJson(receiverFile, record);
+  await writeHandoffInboxes(root, record);
   let raw;
   try {
     raw = await input.model.complete({
@@ -3331,12 +5460,12 @@ async function handoffRole(root, input) {
     });
   } catch {
     await appendJson(receiverFile, { type: "bad_call", roleId: to });
-    return fail3("", runId);
+    return fail7("", runId);
   }
   const parsed = parseReply(raw);
   if (!parsed) {
     await appendJson(receiverFile, { type: "bad_call", roleId: to });
-    return fail3("", runId);
+    return fail7("", runId);
   }
   await appendJson(receiverFile, { type: "model", pass: 1, roleId: to, text: parsed.text });
   const settled = await settleRoleReply(root, receiverFile, receiver, parsed, now, runId);
@@ -3353,7 +5482,7 @@ async function handoffRole(root, input) {
 }
 async function showRoleGroup(root, changeId) {
   const path = safeChangeId2(changeId) ? await acceptedFile(root, changeId) : "";
-  if (!path || !await pathExists(path)) return ok3("No roles in this group.");
+  if (!path || !await pathExists(path)) return ok7("No roles in this group.");
   const seen = /* @__PURE__ */ new Set();
   const owners = [];
   for (const section of factsFrom(await readText(path))) {
@@ -3363,7 +5492,7 @@ async function showRoleGroup(root, changeId) {
       owners.push(owner);
     }
   }
-  return ok3(owners.length > 0 ? owners.join("\n") : "No roles in this group.");
+  return ok7(owners.length > 0 ? owners.join("\n") : "No roles in this group.");
 }
 function distinctServices(all) {
   const services = /* @__PURE__ */ new Map();
@@ -3491,19 +5620,20 @@ function leadPrompt(task, services) {
 }
 async function connectionResult(root, changeId, section, now) {
   const messaging = await messagingOn(root);
-  if (messaging === "invalid") return fail3(ROLE_TEXT.badYaml);
-  if (!messaging) return ok3("Messaging between roles is off.");
+  if (messaging === "invalid") return fail7(ROLE_TEXT.badYaml);
+  if (!messaging) return ok7("Messaging between roles is off.");
   const owners = unique(section.owners);
   const runId = runIdFrom(now);
   for (let i = 0; i < owners.length - 1; i++) {
     const from = owners[i] ?? "";
     const to = owners[i + 1] ?? "";
     const record = handoffRecord(from, to, changeId, section);
-    await appendJson(join10(conversationDir(root, from), `${runId}.jsonl`), record);
-    await appendJson(join10(conversationDir(root, to), `${runId}.jsonl`), record);
+    await appendJson(join16(conversationDir(root, from), `${runId}.jsonl`), record);
+    await appendJson(join16(conversationDir(root, to), `${runId}.jsonl`), record);
+    await writeHandoffInboxes(root, record);
   }
   const lines = ["Connection hands off. Lead is absent.", ...owners];
-  return ok3(lines.join("\n"));
+  return ok7(lines.join("\n"));
 }
 function freshPlan(task, nodes) {
   return { status: "pending", rebuilds: 0, stalled: false, task, nodes, results: [] };
@@ -3512,7 +5642,7 @@ async function planNetwork(root, input) {
   const changeId = input.change?.trim() ?? "";
   const sectionId = input.section?.trim() ?? "";
   const loaded = await acceptedFacts(root, changeId, sectionId);
-  if (!loaded) return fail3(ROLE_TEXT.needsSection);
+  if (!loaded) return fail7(ROLE_TEXT.needsSection);
   const task = input.task ?? "";
   const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
   const connection = loaded.all.find(
@@ -3520,23 +5650,23 @@ async function planNetwork(root, input) {
   );
   if (connection?.connection) return connectionResult(root, changeId, connection, now);
   const services = distinctServices(loaded.all);
-  if (services.size === 0) return ok3("One scope. No lead.");
+  if (services.size === 0) return ok7("One scope. No lead.");
   if (services.size === 1) {
     const entry = [...services.entries()][0];
-    if (!entry) return ok3("One scope. No lead.");
+    if (!entry) return ok7("One scope. No lead.");
     const [name, section] = entry;
     const owner = section.owners[0];
-    if (!owner) return fail3("This service needs an owner.");
-    if (!await readRole(root, owner)) return fail3(ROLE_TEXT.notFound);
-    return ok3(`Service ${name} runs ${owner}.`);
+    if (!owner) return fail7("This service needs an owner.");
+    if (!await readRole(root, owner)) return fail7(ROLE_TEXT.notFound);
+    return ok7(`Service ${name} runs ${owner}.`);
   }
-  const picked = pickLead(loaded.all, services);
-  if (picked.kind === "none") return ok3("One scope. No lead.");
-  if (picked.kind === "missing") return fail3(picked.sentence);
+  const picked = await pickLead(root, loaded.all, services);
+  if (picked.kind === "none") return ok7("One scope. No lead.");
+  if (picked.kind === "missing") return fail7(picked.sentence);
   const lead = await readRole(root, picked.name);
-  if (!lead) return fail3(ROLE_TEXT.notFound);
-  if (await messagingOn(root) === "invalid") return fail3(ROLE_TEXT.badYaml);
-  if (!input.model) return fail3(ROLE_TEXT.noModel);
+  if (!lead) return fail7(ROLE_TEXT.notFound);
+  if (await messagingOn(root) === "invalid") return fail7(ROLE_TEXT.badYaml);
+  if (!input.model) return fail7(ROLE_TEXT.noModel);
   return storeLeadPlan(
     root,
     changeId,
@@ -3554,17 +5684,17 @@ async function storeLeadPlan(root, changeId, sectionId, task, lead, services, al
   try {
     raw = await model.complete({ roleId: lead.name, prompt: leadPrompt(task, services) });
   } catch {
-    return fail3("");
+    return fail7("");
   }
   const parsed = await parsePlan(root, raw, contextOf(all));
-  if (previous && (parsed === "invalid" || parsed === "deep")) return fail3(planFailure(parsed));
-  if (parsed === "invalid") return fail3("The plan is not valid.");
-  if (parsed === "deep") return fail3("A plan is deeper than 2.");
+  if (previous && (parsed === "invalid" || parsed === "deep")) return fail7(planFailure(parsed));
+  if (parsed === "invalid") return fail7("The plan is not valid.");
+  if (parsed === "deep") return fail7("A plan is deeper than 2.");
   if (previous && sameArtifacts(previous.nodes, parsed)) {
     previous.stalled = true;
     previous.rebuilds += 1;
     await writePlan(root, changeId, sectionId, previous);
-    return ok3("Stopped. The plan made no progress.");
+    return ok7("Stopped. The plan made no progress.");
   }
   const next = previous ? {
     ...previous,
@@ -3575,7 +5705,7 @@ async function storeLeadPlan(root, changeId, sectionId, task, lead, services, al
     results: []
   } : freshPlan(task, parsed);
   await writePlan(root, changeId, sectionId, next);
-  return ok3(["Accept this plan before anyone writes.", ...planLines(parsed)].join("\n"));
+  return ok7(["Accept this plan before anyone writes.", ...planLines(parsed)].join("\n"));
 }
 function planFailure(parsed) {
   return parsed === "deep" ? "A plan is deeper than 2." : "The plan is not valid.";
@@ -3588,13 +5718,13 @@ function sameArtifacts(left, right) {
 async function acceptNetwork(root, input) {
   const changeId = input.change?.trim() ?? "";
   const sectionId = input.section?.trim() ?? "";
-  if (!safeChangeId2(changeId) || !sectionId) return fail3("No plan is stored.");
+  if (!safeChangeId2(changeId) || !sectionId) return fail7("No plan is stored.");
   const plan = await readPlan(root, changeId, sectionId);
-  if (!plan) return fail3("No plan is stored.");
-  if (plan.status !== "pending") return fail3("The plan is not waiting for acceptance.");
+  if (!plan) return fail7("No plan is stored.");
+  if (plan.status !== "pending") return fail7("The plan is not waiting for acceptance.");
   plan.status = "accepted";
   await writePlan(root, changeId, sectionId, plan);
-  return ok3("Plan accepted.");
+  return ok7("Plan accepted.");
 }
 function walk(nodes) {
   const flat = [];
@@ -3615,16 +5745,16 @@ function ready(node, results) {
 async function runNetwork(root, input) {
   const changeId = input.change?.trim() ?? "";
   const sectionId = input.section?.trim() ?? "";
-  if (!safeChangeId2(changeId) || !sectionId) return fail3("No plan is stored.");
+  if (!safeChangeId2(changeId) || !sectionId) return fail7("No plan is stored.");
   const plan = await readPlan(root, changeId, sectionId);
-  if (!plan) return fail3("No plan is stored.");
-  if (plan.status === "pending") return ok3("Accept this plan before anyone writes.");
-  if (plan.status === "done") return ok3("The parent is done.");
-  if (plan.status !== "accepted" && plan.status !== "open") return fail3("No plan is stored.");
-  if (await messagingOn(root) === "invalid") return fail3(ROLE_TEXT.badYaml);
+  if (!plan) return fail7("No plan is stored.");
+  if (plan.status === "pending") return ok7("Accept this plan before anyone writes.");
+  if (plan.status === "done") return ok7("The parent is done.");
+  if (plan.status !== "accepted" && plan.status !== "open") return fail7("No plan is stored.");
+  if (await messagingOn(root) === "invalid") return fail7(ROLE_TEXT.badYaml);
   const minutes = await timeoutMinutes(root);
-  if (minutes === "invalid") return fail3(ROLE_TEXT.badYaml);
-  if (!input.model) return fail3(ROLE_TEXT.noModel);
+  if (minutes === "invalid") return fail7(ROLE_TEXT.badYaml);
+  if (!input.model) return fail7(ROLE_TEXT.noModel);
   const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
   const summaries = [];
   const called = /* @__PURE__ */ new Set();
@@ -3644,7 +5774,7 @@ async function runNetwork(root, input) {
       const when = new Date(now.getTime() + index * 1e3);
       index += 1;
       const runId = runIdFrom(when);
-      const file = join10(conversationDir(root, owner.name), `${runId}.jsonl`);
+      const file = join16(conversationDir(root, owner.name), `${runId}.jsonl`);
       let raw;
       try {
         raw = await input.model.complete({
@@ -3688,7 +5818,7 @@ async function runNetwork(root, input) {
   const waiting = all.some((node) => !plan.results.some((item) => item.decision === node.decision));
   plan.status = waiting ? "open" : "done";
   await writePlan(root, changeId, sectionId, plan);
-  if (missingOwner) return fail3(ROLE_TEXT.notFound);
+  if (missingOwner) return fail7(ROLE_TEXT.notFound);
   const lines = [...summaries];
   if (waiting) {
     lines.push("A branch is waiting for its prerequisites.");
@@ -3696,27 +5826,27 @@ async function runNetwork(root, input) {
   } else {
     lines.push("The parent is done.");
   }
-  return ok3(lines.join("\n"));
+  return ok7(lines.join("\n"));
 }
 async function rebuildNetwork(root, input) {
   const changeId = input.change?.trim() ?? "";
   const sectionId = input.section?.trim() ?? "";
-  if (!safeChangeId2(changeId) || !sectionId) return fail3("No plan is stored.");
+  if (!safeChangeId2(changeId) || !sectionId) return fail7("No plan is stored.");
   const plan = await readPlan(root, changeId, sectionId);
-  if (!plan) return fail3("No plan is stored.");
+  if (!plan) return fail7("No plan is stored.");
   const allowed = plan.rebuilds === 0 || plan.rebuilds === 1 && !plan.stalled && plan.status === "accepted";
-  if (!allowed) return fail3("A second rebuild does not start.");
+  if (!allowed) return fail7("A second rebuild does not start.");
   const loaded = await acceptedFacts(root, changeId, sectionId);
-  if (!loaded) return fail3(ROLE_TEXT.needsSection);
-  if (!input.model) return fail3(ROLE_TEXT.noModel);
+  if (!loaded) return fail7(ROLE_TEXT.needsSection);
+  if (!input.model) return fail7(ROLE_TEXT.noModel);
   const services = distinctServices(loaded.all);
-  const picked = pickLead(loaded.all, services);
-  if (picked.kind === "missing") return fail3(picked.sentence);
-  if (picked.kind !== "lead") return fail3("This module needs a lead.");
+  const picked = await pickLead(root, loaded.all, services);
+  if (picked.kind === "missing") return fail7(picked.sentence);
+  if (picked.kind !== "lead") return fail7("This module needs a lead.");
   const lead = await readRole(root, picked.name);
-  if (!lead) return fail3(ROLE_TEXT.notFound);
+  if (!lead) return fail7(ROLE_TEXT.notFound);
   const before = JSON.stringify(plan);
-  const result = await storeLeadPlan(
+  const result2 = await storeLeadPlan(
     root,
     changeId,
     sectionId,
@@ -3727,15 +5857,35 @@ async function rebuildNetwork(root, input) {
     input.model,
     plan
   );
-  if (result.exitCode !== 0) {
+  if (result2.exitCode !== 0) {
     const current = await readPlan(root, changeId, sectionId);
     if (current && JSON.stringify(current) !== before) {
       await writePlan(root, changeId, sectionId, JSON.parse(before));
     }
   }
-  return result;
+  return result2;
 }
-function pickLead(all, services) {
+async function chooseLead(root, sections, missing) {
+  const routed = await matchRoute(root, { stage: "network", skill: "name the next owner" });
+  if (!routed.ok) return { kind: "missing", sentence: routed.message };
+  if (routed.match.kind === "role") return { kind: "lead", name: routed.match.role };
+  if (routed.match.reason !== "No rule matched.") {
+    return { kind: "missing", sentence: "Ask the human." };
+  }
+  const names = [];
+  for (const section of sections) {
+    for (const lead of section.leads) {
+      if (!names.includes(lead)) names.push(lead);
+    }
+  }
+  if (names.length === 1) {
+    const name = names[0];
+    if (name) return { kind: "lead", name };
+  }
+  if (names.length === 0) return { kind: "missing", sentence: missing };
+  return { kind: "missing", sentence: "Ask the human." };
+}
+async function pickLead(root, all, services) {
   const modules = /* @__PURE__ */ new Set();
   let missingModule = false;
   for (const section of services.values()) {
@@ -3745,20 +5895,61 @@ function pickLead(all, services) {
   }
   const moduleId = [...modules][0];
   if (!missingModule && modules.size === 1 && moduleId && services.size > 1) {
-    const name = all.find((item) => item.modules.includes(moduleId) && item.leads[0])?.leads[0] ?? "";
-    if (!name) return { kind: "missing", sentence: "This module needs a lead." };
-    return { kind: "lead", name };
+    return chooseLead(
+      root,
+      all.filter((item) => item.modules.includes(moduleId)),
+      "This module needs a lead."
+    );
   }
   if (modules.size > 1) {
-    const name = all.find((item) => item.product && item.leads[0])?.leads[0] ?? "";
-    if (!name) return { kind: "missing", sentence: "This product needs a lead." };
-    return { kind: "lead", name };
+    return chooseLead(
+      root,
+      all.filter((item) => item.product),
+      "This product needs a lead."
+    );
   }
   return { kind: "none" };
 }
 
+// src/role/models/show.ts
+function formatModelChoice(workType, choice) {
+  return `${workType}  ${choice.id}  ${choice.kind}  ${choice.provider}  ${choice.why}`;
+}
+function confidence(model) {
+  return "min_confidence" in model && model.min_confidence !== void 0 ? String(model.min_confidence) : "n/a";
+}
+function formatEntry2(id, model) {
+  if (model.provider === "rules") return `${id}  decide  rules`;
+  if (model.provider === "command") {
+    return `${id}  ${model.kind}  command  command_env ${model.command_env}  min_confidence ${confidence(model)}`;
+  }
+  return `${id}  decide  ollama  model ${model.model}  base_url_env ${model.base_url_env}  min_confidence ${confidence(model)}`;
+}
+function formatModels(config) {
+  const lines = Object.keys(config.models).sort().map((id) => formatEntry2(id, config.models[id]));
+  for (const workType of WORK_TYPES) {
+    lines.push(formatModelChoice(workType, selectModel(config, { workType })));
+  }
+  const reason = config.models[config.defaults.fallback_reason];
+  const decide2 = config.models[config.defaults.fallback_decide];
+  if (reason) {
+    lines.push(
+      `fallback_reason  ${config.defaults.fallback_reason}  ${reason.kind}  ${reason.provider}  fallback`
+    );
+  }
+  if (decide2) {
+    lines.push(
+      `fallback_decide  ${config.defaults.fallback_decide}  ${decide2.kind}  ${decide2.provider}  fallback`
+    );
+  }
+  return lines.join("\n");
+}
+function explainModel(config, workType, ctx) {
+  return formatModelChoice(workType, selectModel(config, { workType, ...ctx }));
+}
+
 // src/stories.ts
-import { join as join11 } from "pathe";
+import { join as join17 } from "pathe";
 var STORY_ID = /^S-\d+$/i;
 var EPIC_KEY = /^[A-Za-z0-9][A-Za-z0-9-]{0,39}$/;
 function validBranchName(name) {
@@ -3800,7 +5991,7 @@ function parseStoryDraft(input) {
 async function metasIn(dir) {
   const out = [];
   for (const id of await listDirs(dir)) {
-    const path = join11(dir, id, "meta.yaml");
+    const path = join17(dir, id, "meta.yaml");
     if (!await pathExists(path)) continue;
     try {
       out.push(ChangeMetaSchema.parse(await readYaml(path)));
@@ -3933,6 +6124,7 @@ export {
   ConfigSchema,
   DEFAULT_CODE_CONTEXT_CAPS,
   DEFAULT_INIT_INTEGRATION,
+  DecisionMetricSchema,
   EMBEDDINGS_UNAVAILABLE,
   EMBEDDING_MODEL,
   GateSchema,
@@ -3940,6 +6132,7 @@ export {
   McpInvokeSchema,
   McpSourceSchema,
   McpWhenSchema,
+  ModelsConfigSchema,
   PROTOCOL_MD,
   PhaseMetricSchema,
   RRF_K,
@@ -3950,12 +6143,15 @@ export {
   SddError,
   SearchConfigError,
   StageSchema,
+  TeamSchema,
   TokenUsageMetricSchema,
   VerifyCommandSchema,
+  WORK_TYPES,
   WorkflowSchema,
   acceptNetwork,
   activePointerPath,
   activeStages,
+  addLesson,
   addMcpSource,
   advanceStage,
   agentHostPaths,
@@ -3978,6 +6174,8 @@ export {
   changePath,
   changesDir,
   changesPathRel,
+  checkModels,
+  checkTeam,
   chunkCode,
   chunkMarkdown,
   classifyPath,
@@ -3995,12 +6193,15 @@ export {
   createChange,
   createFastembedEmbedder,
   createRole,
+  createRoleFromTemplate,
+  decide,
   defaultConfig,
   defaultMcpConfig,
   defaultMcpYamlPath,
   defaultMemoryDir,
   defaultPricesYamlPath,
   defaultSearchYamlPath,
+  defaultTeamsDir,
   defaultTemplatesDir,
   defaultWorkflowsDir,
   defaultsRoot,
@@ -4019,6 +6220,7 @@ export {
   errorMessage,
   executeSearch,
   explainMatch,
+  explainModel,
   extractiveSummary,
   fallbackAdapter,
   fallbackIncompleteStageId,
@@ -4030,7 +6232,10 @@ export {
   formatEpicGraph,
   formatJsonSummary,
   formatMcpContextForHandoff,
+  formatModels,
   formatStatus,
+  formatTeam,
+  formatTokenInventory,
   ftsTokens,
   fuseByRank,
   fuseHits,
@@ -4039,9 +6244,11 @@ export {
   generateCodeContext,
   generatedState,
   getActiveChangeId,
+  getFacts,
   getHeadSha,
   getIntegration,
   getStage,
+  gitUserName,
   guidancePaths,
   handoffRole,
   hideRole,
@@ -4050,6 +6257,7 @@ export {
   indexDbPath,
   inferComplexity,
   initProject,
+  initTeam,
   installAgentIntegration,
   installAgentIntegrations,
   integrationKeyFor,
@@ -4063,15 +6271,21 @@ export {
   isSecretPath,
   isStageSkipped,
   isSubstantiveArtifactContent,
+  isWorkType,
   keywordHits,
   listBacklogFeatures,
+  listBundledWorkflowNames,
   listChanges,
   listDirs,
+  listFacts,
   listFiles,
   listMatchingSourceIds,
   listMcpSourceTools,
+  listRoleTemplates,
   listScopeHits,
+  listTeamTemplates,
   listWorkflowNames,
+  loadBrain,
   loadChangeMeta,
   loadConfig,
   loadEpicStories,
@@ -4079,7 +6293,9 @@ export {
   loadGeneratedManifest,
   loadInstalledAgent,
   loadMcpConfig,
+  loadModels,
   loadPrices,
+  loadProductTeam,
   loadSearchConfig,
   loadWorkflow,
   markGenerated,
@@ -4091,6 +6307,9 @@ export {
   mergeCaps,
   mergeConfigDefaults,
   mergeRankedHits,
+  migrateTeamMemory,
+  missingBundledWorkflows,
+  modelFromEnv,
   nextStageId,
   nowIso,
   optionForTarget,
@@ -4104,15 +6323,22 @@ export {
   pinRole,
   planAgentIntegration,
   planNetwork,
+  postRoom,
+  productTeamHome,
   promoteGreenfieldToMemory,
+  queueRole,
   rankScope,
   readChangeMetrics,
   readHandoffCodePoints,
+  readTeamConfig,
   readText,
   readYaml,
   rebuildNetwork,
   recommendWorkflow,
   reconcileGeneratedTree,
+  recordDecisionMetric,
+  recordDecisionRequest,
+  recordSignoff,
   refreshActiveAgentContext,
   refreshConfiguredGuidance,
   registerSearchProvider,
@@ -4124,6 +6350,7 @@ export {
   renderBlock,
   renderChangeReport,
   renderMemoryIndex,
+  renderProductTeamSection,
   renderProtocolMd,
   renderSddReadme,
   renderThinAgent,
@@ -4131,13 +6358,17 @@ export {
   reportAllChanges,
   reportChange,
   resolveActiveDirectory,
+  resolveBot,
   resolveChangeId,
   resolveEmbedder,
   resolveFocus,
   resolveSearchProvider,
   resolveStages,
+  reviewRoom,
+  routeRole,
   rrf,
   runLocalVerify,
+  runLoop,
   runNetwork,
   runRole,
   saveChangeMeta,
@@ -4148,19 +6379,27 @@ export {
   sddRoot,
   searchConfigPath,
   searchPreamble,
+  selectModel,
   setActiveChange,
+  setFact,
   setRoleMessaging,
   shouldAutoSkip,
+  showFact,
+  showMemory,
   showRoleGroup,
   showRoles,
+  showRoom,
+  showTeam,
   skipStage,
   slugify,
+  spawnModelCommand,
   startFeatureFromBacklog,
   startGreenfield,
   startPhase,
   storyIdTaken,
   switchWorkflow,
   syncChangeHead,
+  takeRole,
   templatesDir,
   toProcessEnv,
   todayIsoDate,
@@ -4171,6 +6410,8 @@ export {
   updateFeatureStatus,
   validBranchName,
   withMcpSource,
+  workKind,
+  workflowUnavailableMessage,
   workflowsDir,
   writeAgentHandoff,
   writeRefineBrief,