tldr-experts 0.3.0 → 0.4.0

package/dist/hooks/session-start.js

@@ -1,36 +1,42 @@
 #!/usr/bin/env node
-import"./chunk-kw4tffzf.js";
-import"./chunk-x98qs959.js";
+import"./chunk-t1ywrfr4.js";
 import {
   allow,
   readPayload,
   runHook,
   sessionContext
-} from "./chunk-1zwcxd3f.js";
-import"./chunk-a8p2rc94.js";
+} from "./chunk-tzzwddct.js";
+import"./chunk-b8kxzna2.js";
 import {
   RunStore,
   isMovable,
   openQuestions,
   runSnapshot,
   whatIsWaiting
-} from "./chunk-y0jdr3et.js";
+} from "./chunk-s1c5h7yx.js";
 import {
-  openRunViews
-} from "./chunk-sdjnnmzz.js";
-import"./chunk-azctppjh.js";
-import"./chunk-ae6bkfs5.js";
+  evidencePath,
+  expertsDir,
+  gateEvidencePath,
+  loadExperts,
+  openRunViews,
+  parseEvidence,
+  pathsIntersect,
+  readExpertDomain,
+  stackExpertNames
+} from "./chunk-4cp363kv.js";
+import"./chunk-rz541e2b.js";
+import"./chunk-9zsqxr6y.js";
+import"./chunk-phmdk72a.js";
+import"./chunk-c6t5nx0r.js";
 import {
   openBlocks,
   parseQuestions
-} from "./chunk-j234zf0t.js";
-import"./chunk-t56k6146.js";
-import {
-  classifySrc
-} from "./chunk-g395gk7e.js";
+} from "./chunk-rpcxsqh3.js";
+import"./chunk-m3mewgnw.js";
 import {
   isRecord
-} from "./chunk-0bt6yb2q.js";
+} from "./chunk-39zh2e44.js";
 import {
   PROJECT_FRAMEWORK_DIR,
   PROJECT_WORK_DIR,
@@ -39,7 +45,7 @@ import {
   findWorkspaceRoot,
   listRunDirs,
   parseYaml
-} from "./chunk-p274ckxv.js";
+} from "./chunk-sq44k6g2.js";
 
 // src/core/status/PendingItem.ts
 function isPending(item) {
@@ -97,39 +103,6 @@ function statusLineOf(text) {
 }
 var DOCUMENT_EXTENSIONS = new Set([".md", ".txt", ".markdown", ".rst", ".adoc", ".pdf", ".doc", ".docx"]);
 
-// src/core/detect/walk.ts
-var SKIPPED_DIRS = new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "out",
-  "bin",
-  "obj",
-  "target",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".next",
-  ".expo",
-  ".gradle",
-  "vendor",
-  "coverage",
-  "graphify-out",
-  ".tldrx",
-  "tldrx-work",
-  ".idea",
-  ".vscode",
-  "Pods",
-  "DerivedData",
-  ".terraform",
-  ".turbo",
-  ".cache",
-  "storybook-static",
-  "playwright-report",
-  "test-results"
-]);
-
 // src/core/seed/collectSeed.ts
 var MAX_SEED_BYTES = 2 * 1024 * 1024;
 
@@ -454,6 +427,125 @@ function chainsOf(inputs, runs) {
   return chains;
 }
 
+// src/core/run/decisionCards.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+function questionsCard(ctx) {
+  const blocks = openQuestionBlocks(join3(ctx.runDir, ctx.phaseId, "questions.md"));
+  if (blocks.length === 0)
+    return null;
+  const recommendations = readRecommendations(ctx);
+  return {
+    kind: "questions",
+    run: ctx.runId,
+    gate: `${ctx.phaseId}/${ctx.stageId}`,
+    headline: "",
+    questions: blocks.map((block) => toQuestion(block, ctx.runId, recommendations)),
+    detail: [],
+    commands: []
+  };
+}
+function toQuestion(block, runId, recommendations) {
+  const recommended = recommendations.get(block.id);
+  return {
+    id: block.id,
+    title: block.title,
+    whyAsked: block.whyAsked,
+    options: block.options.map(firstLine),
+    recommendation: recommended === undefined ? null : toRecommendation(recommended),
+    answerCommand: `tldrx answer ${block.id} "…" --run ${runId}`
+  };
+}
+function firstLine(option) {
+  return { letter: option.letter, text: option.text.split(`
+`)[0] ?? "" };
+}
+function toRecommendation(entry) {
+  return { option: entry.option, why: entry.why, src: entry.src };
+}
+function openQuestionBlocks(path) {
+  if (!existsSync3(path))
+    return [];
+  try {
+    return openBlocks(parseQuestions(readFileSync3(path, "utf8")).blocks);
+  } catch {
+    return [];
+  }
+}
+function readRecommendations(ctx) {
+  const out = new Map;
+  const paths = [
+    evidencePath(ctx.runDir, ctx.stageId),
+    gateEvidencePath(ctx.runDir, ctx.phaseId, ctx.stageId)
+  ];
+  for (const path of paths) {
+    const text = readOrNull(path);
+    if (text === null)
+      continue;
+    const front = parseEvidence(text).front;
+    if (front === null)
+      continue;
+    for (const entry of front.recommend) {
+      if (!out.has(entry.q))
+        out.set(entry.q, entry);
+    }
+    if (out.size > 0)
+      return out;
+  }
+  return out;
+}
+function readOrNull(path) {
+  if (!existsSync3(path))
+    return null;
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// src/core/ui/decisionCard.ts
+function decisionHeader(card) {
+  return `DECISION — ${card.run} · ${card.gate}`;
+}
+function renderDecisionCard(card) {
+  const lines = [decisionHeader(card)];
+  if (card.kind === "questions") {
+    card.questions.forEach((question, index) => {
+      if (index > 0)
+        lines.push("");
+      lines.push(...renderQuestion(question));
+    });
+    return lines;
+  }
+  if (card.headline !== "")
+    lines.push(card.headline);
+  for (const line of card.detail)
+    lines.push(`  ${line}`);
+  for (const command of card.commands)
+    lines.push(`  ${command}`);
+  return lines;
+}
+function renderQuestion(question) {
+  const lines = [`${question.id} · ${question.title}`];
+  if (question.whyAsked !== null)
+    lines.push(`  Why asked: ${question.whyAsked}`);
+  for (const option of question.options)
+    lines.push(`  ${option.letter}) ${option.text}`);
+  const recommendation = renderRecommendation(question.recommendation);
+  if (recommendation !== null)
+    lines.push(recommendation);
+  lines.push(`  ${question.answerCommand}`);
+  return lines;
+}
+function renderRecommendation(recommendation) {
+  if (recommendation === null)
+    return null;
+  const why = recommendation.why.trim();
+  const head = `Recommends ${recommendation.option}${why === "" ? "" : ` — ${why}`}`;
+  return recommendation.src.trim() === "" ? head : `${head} [src: ${recommendation.src.trim()}]`;
+}
+
 // src/core/status/runItems.ts
 var NEXT_MARK = "← next";
 function dependencyInputs(root) {
@@ -508,8 +600,17 @@ function runItems(root) {
     if (waiting.kind === "gate") {
       details.push(`disagree instead: \`tldrx reject --run ${run.run} --note "<why>"\``);
     }
-    if (waiting.kind === "answer" && waiting.questions.length > 1) {
-      details.push(`open questions: ${waiting.questions.join(", ")}`);
+    if (waiting.kind === "answer") {
+      const card = questionsCard({
+        runDir: store.runDir,
+        runId: run.run,
+        phaseId: run.cursor.phase,
+        stageId: run.cursor.stage
+      });
+      if (card === null)
+        details.push(`open questions: ${waiting.questions.join(", ")}`);
+      else
+        details.push(...renderDecisionCard(card));
     }
     if (waiting.kind === "failed")
       details.push(waiting.message);
@@ -593,356 +694,12 @@ function commandFor(run, waiting) {
       return "";
   }
 }
-// src/core/experts/loadExperts.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-
-// src/core/init/competencyLevel.ts
-var EVIDENCE_KINDS = ["code", "run", "test", "doc", "answer"];
-var ALLOWED_KINDS = EVIDENCE_KINDS.join(", ");
-function isEvidenceKind(value) {
-  return EVIDENCE_KINDS.includes(value);
-}
-var EVIDENCE_CONFIDENCES = ["measured", "inferred", "assumed"];
-function isEvidenceConfidence(value) {
-  return EVIDENCE_CONFIDENCES.includes(value);
-}
-var WEIGHTS = { code: 1, run: 1, test: 1, doc: 0.5, answer: 0.8 };
-var CROSS_MULTIPLIER = 2;
-var ASSUMED_MULTIPLIER = 0.5;
-var THRESHOLDS = [0.5, 1.5, 3, 6, 20];
-var RECENCY_FLOOR = 0.25;
-var RECENCY_HALFLIFE_DAYS = 365;
-var NO_RUN_CAP = 3;
-var MIN_KINDS_FOR_TOP = 2;
-var DAY_MS = 86400000;
-function competencyLevel(evidence, now = new Date) {
-  if (evidence.length === 0)
-    return 0;
-  let weighted = 0;
-  const sources = new Set;
-  const kinds = new Set;
-  for (const item of evidence) {
-    const ageDays = daysBetween(item.at, now);
-    if (ageDays === null)
-      continue;
-    weighted += recency(ageDays) * weightOf(item);
-    sources.add(item.src);
-    kinds.add(item.kind);
-  }
-  let level = THRESHOLDS.filter((threshold) => weighted >= threshold).length;
-  if (!kinds.has("run"))
-    level = Math.min(level, NO_RUN_CAP);
-  if (level === 5 && kinds.size < MIN_KINDS_FOR_TOP)
-    level = 4;
-  return Math.min(level, sources.size);
-}
-function weightOf(item) {
-  const base = WEIGHTS[item.kind];
-  const cross = item.cross === true ? CROSS_MULTIPLIER : 1;
-  const confidence = item.confidence === "assumed" ? ASSUMED_MULTIPLIER : 1;
-  return base * cross * confidence;
-}
-function recency(ageDays) {
-  return Math.max(RECENCY_FLOOR, 1 - ageDays / RECENCY_HALFLIFE_DAYS);
-}
-function daysBetween(at, now) {
-  const then = Date.parse(at);
-  if (Number.isNaN(then))
-    return null;
-  return Math.max(0, (now.getTime() - then) / DAY_MS);
-}
-
-// src/core/experts/evidenceSrc.ts
-function checkEvidenceSrc(kind, src) {
-  const parsed = classifySrc(src);
-  if ("message" in parsed)
-    return { reason: "malformed-src" };
-  return matchesKind(kind, parsed) ? null : { reason: "kind-mismatch" };
-}
-function matchesKind(kind, ref) {
-  switch (kind) {
-    case "code":
-      return ref.kind === "file";
-    case "run":
-      return ref.kind === "cmd" || isRunArtifact(ref);
-    case "test":
-      return ref.kind === "file" || ref.kind === "cmd";
-    case "doc":
-      return ref.kind === "doc";
-    case "answer":
-      return ref.kind === "fact";
-  }
-}
-function isRunArtifact(ref) {
-  return ref.kind === "file" && ref.repo === null && ref.path.startsWith("tldrx-work/");
-}
-
-// src/core/experts/readEvidenceRows.ts
-function readEvidenceRows(input) {
-  if (!Array.isArray(input))
-    return { evidence: [], ignored: [] };
-  const evidence = [];
-  const counts = new Map;
-  const refuse = (reason, kind, src) => {
-    const key = `${reason} ${reason === "unknown-kind" ? kind : `${kind} ${src}`}`;
-    const seen = counts.get(key);
-    counts.set(key, seen === undefined ? { reason, kind, src, count: 1 } : { ...seen, count: seen.count + 1 });
-  };
-  for (const raw of input) {
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-      continue;
-    const row = raw;
-    const kind = str(row.kind);
-    const src = str(row.src);
-    const at = str(row.at);
-    if (src === "" || at === "")
-      continue;
-    if (!isEvidenceKind(kind)) {
-      refuse("unknown-kind", kind, "");
-      continue;
-    }
-    const problem = checkEvidenceSrc(kind, src);
-    if (problem !== null) {
-      refuse(problem.reason, kind, src);
-      continue;
-    }
-    const confidence = str(row.confidence);
-    evidence.push({
-      kind,
-      src,
-      at,
-      ...row.cross === true ? { cross: true } : {},
-      ...isEvidenceConfidence(confidence) ? { confidence } : {}
-    });
-  }
-  return { evidence, ignored: [...counts.values()] };
-}
-function str(value) {
-  return typeof value === "string" ? value : "";
-}
-
-// src/core/experts/loadExperts.ts
-var EXPERTS_DIRNAME = "experts";
-var COMPETENCIES_FILE = "competencies.yml";
-var EXPERT_FILE = "expert.md";
-function expertsDir(root) {
-  return join3(root, PROJECT_FRAMEWORK_DIR, EXPERTS_DIRNAME);
-}
-function expertDir(root, name) {
-  return join3(expertsDir(root), name);
-}
-function loadExperts(root, now = new Date) {
-  const dir = expertsDir(root);
-  if (!existsSync3(dir))
-    return [];
-  const names = readdirSync2(dir).filter((entry) => statSync2(join3(dir, entry)).isDirectory()).sort();
-  return names.map((name) => loadExpert(root, name, now));
-}
-function loadExpert(root, name, now = new Date) {
-  const dir = expertDir(root, name);
-  const path = join3(dir, COMPETENCIES_FILE);
-  const empty = { name, dir, status: "unknown", lastTrained: null, areas: [], drifted: [] };
-  if (!existsSync3(path))
-    return { ...empty, error: `${COMPETENCIES_FILE} is missing` };
-  let doc;
-  try {
-    const parsed = parseYaml(readFileSync3(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return { ...empty, error: `${COMPETENCIES_FILE} is not a mapping` };
-    }
-    doc = parsed;
-  } catch (error) {
-    return { ...empty, error: error instanceof Error ? error.message : String(error) };
-  }
-  const areas = Array.isArray(doc.areas) ? doc.areas.map((area) => toArea(name, area, now)).filter((area) => area !== null) : [];
-  return {
-    name: typeof doc.expert === "string" && doc.expert !== "" ? doc.expert : name,
-    dir,
-    status: typeof doc.status === "string" ? doc.status : "unknown",
-    lastTrained: typeof doc.last_trained === "string" ? doc.last_trained : null,
-    areas,
-    drifted: areas.filter((area) => area.storedLevel !== null && area.storedLevel !== area.level),
-    error: null
-  };
-}
-function toArea(expert, input, now) {
-  if (typeof input !== "object" || input === null || Array.isArray(input))
-    return null;
-  const raw = input;
-  const id = str2(raw.id) !== "" ? str2(raw.id) : str2(raw.area);
-  if (id === "")
-    return null;
-  const { evidence, ignored } = readEvidenceRows(raw.evidence);
-  return {
-    id,
-    title: str2(raw.title) !== "" ? str2(raw.title) : id,
-    storedLevel: typeof raw.level === "number" ? raw.level : null,
-    level: competencyLevel(evidence, now),
-    trainPrompt: str2(raw.train_prompt) !== "" ? str2(raw.train_prompt) : `tldrx expert train ${expert} --area ${id} --mode light`,
-    evidence,
-    ignored,
-    newestEvidence: newestDate(evidence)
-  };
-}
-function newestDate(evidence) {
-  let newest = null;
-  for (const item of evidence) {
-    if (newest === null || item.at > newest)
-      newest = item.at;
-  }
-  return newest;
-}
-function str2(value) {
-  return typeof value === "string" ? value : "";
-}
 // src/core/experts/stageCoverage.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { join as join6 } from "node:path";
-
-// src/core/experts/stackExperts.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
 import { join as join4 } from "node:path";
-function stackExpertNames(root, repos) {
-  const path = join4(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
-  if (!existsSync4(path))
-    return [];
-  let doc;
-  try {
-    doc = parseYaml(readFileSync4(path, "utf8"));
-  } catch {
-    return [];
-  }
-  const list = doc?.repos;
-  if (!Array.isArray(list))
-    return [];
-  const names = [];
-  for (const row of list) {
-    if (typeof row?.name !== "string" || !repos.includes(row.name))
-      continue;
-    const stack = Array.isArray(row.stack) ? row.stack : [];
-    for (const language of stack) {
-      if (typeof language !== "string" || language === "")
-        continue;
-      const expert = `${language}-stack`;
-      if (!names.includes(expert))
-        names.push(expert);
-    }
-  }
-  return names;
-}
-
-// src/core/experts/selectExperts.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-
-// src/core/experts/expertDocument.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
-var H2_RE = /^##\s+(.+?)\s*$/;
-function readExpertDocument(root, name) {
-  const path = join5(expertDir(root, name), EXPERT_FILE);
-  if (!existsSync5(path)) {
-    return { path, exists: false, frontMatter: new Map, body: "" };
-  }
-  const text = readFileSync5(path, "utf8");
-  const { frontMatter, body } = splitFrontMatter(text);
-  return { path, exists: true, frontMatter, body };
-}
-function splitFrontMatter(text) {
-  const frontMatter = new Map;
-  if (!text.startsWith(`---
-`))
-    return { frontMatter, body: text };
-  const end = text.indexOf(`
----`, 3);
-  if (end === -1)
-    return { frontMatter, body: text };
-  for (const line of text.slice(4, end).split(`
-`)) {
-    const colon = line.indexOf(":");
-    if (colon <= 0 || line.trimStart().startsWith("#"))
-      continue;
-    const key = line.slice(0, colon).trim();
-    const value = line.slice(colon + 1).replace(/#.*$/, "").trim().replace(/^"(.*)"$/, "$1");
-    if (key !== "")
-      frontMatter.set(key, value);
-  }
-  const newline = text.indexOf(`
-`, end + 1);
-  return { frontMatter, body: newline === -1 ? "" : text.slice(newline + 1) };
-}
-function section(body, heading) {
-  const lines = body.split(`
-`);
-  const collected = [];
-  let inside = false;
-  for (const line of lines) {
-    const match = H2_RE.exec(line);
-    if (match !== null) {
-      if (inside)
-        break;
-      inside = match[1] === heading;
-      continue;
-    }
-    if (inside)
-      collected.push(line);
-  }
-  return collected.join(`
-`).trim();
-}
-
-// src/core/experts/expertDomain.ts
-var PLACEHOLDER_PATHS = new Set(["path/to/module", "path/to/other"]);
-function readExpertDomain(root, name) {
-  const doc = readExpertDocument(root, name);
-  if (!doc.exists)
-    return { name, exists: false, kind: "", repos: [], paths: [] };
-  return {
-    name,
-    exists: true,
-    kind: doc.frontMatter.get("kind") ?? "",
-    repos: parseList(doc.frontMatter.get("repos") ?? ""),
-    paths: domainPaths(section(doc.body, "Domain"))
-  };
-}
-function parseList(value) {
-  const inner = value.trim().replace(/^\[/, "").replace(/\]$/, "");
-  return inner.split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter((item) => item !== "");
-}
-function domainPaths(body) {
-  const paths = [];
-  for (const line of body.split(`
-`)) {
-    const bullet = /^\s*[-*]\s+(.*)$/.exec(line);
-    if (bullet === null)
-      continue;
-    const text = (bullet[1] ?? "").trim();
-    if (/^repo\s/i.test(text))
-      continue;
-    const code = /`([^`]+)`/.exec(text);
-    const raw = (code?.[1] ?? text.split(/\s+—\s+/)[0] ?? "").trim();
-    const path = normalisePath(raw);
-    if (path === "" || PLACEHOLDER_PATHS.has(path) || !path.includes("/"))
-      continue;
-    if (!paths.includes(path))
-      paths.push(path);
-  }
-  return paths;
-}
-function normalisePath(raw) {
-  return raw.trim().replace(/^[a-z0-9-]+:(?=[^/])/i, "").replace(/^\.\//, "").replace(/\/+$/, "").replace(/\\/g, "/");
-}
-function pathsIntersect(a, b) {
-  const left = normalisePath(a);
-  const right = normalisePath(b);
-  if (left === "" || right === "")
-    return false;
-  if (left === right)
-    return true;
-  return left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
-}
 
 // src/core/experts/selectExperts.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 var MAX_DOMAIN_SELECTED = 8;
 var LEGACY_STAGE_EXPERTS = ["domain", "stack"];
 function selectExperts(input) {
@@ -982,18 +739,18 @@ function selectExperts(input) {
 }
 function expertNames(root) {
   const dir = expertsDir(root);
-  if (!existsSync6(dir))
+  if (!existsSync4(dir))
     return [];
-  return readdirSync3(dir).filter((entry) => {
+  return readdirSync2(dir).filter((entry) => {
     try {
-      return statSync3(`${dir}/${entry}`).isDirectory();
+      return statSync2(`${dir}/${entry}`).isDirectory();
     } catch {
       return false;
     }
   }).sort();
 }
 function hasExpert(root, name) {
-  return existsSync6(`${expertsDir(root)}/${name}`);
+  return existsSync4(`${expertsDir(root)}/${name}`);
 }
 var DIRECT_WEIGHT = 10;
 var GRAPH_HOPS = 2;
@@ -1083,18 +840,18 @@ function stagesLoadingExperts(root) {
 }
 function stageIds(root) {
   const ids = new Set([
-    ...dirsIn(join6(root, PROJECT_FRAMEWORK_DIR, "stages")),
+    ...dirsIn(join4(root, PROJECT_FRAMEWORK_DIR, "stages")),
     ...dirsIn(STAGES_DIR)
   ]);
   return [...ids].sort();
 }
 function dirsIn(dir) {
-  if (!existsSync7(dir))
+  if (!existsSync5(dir))
     return [];
   try {
-    return readdirSync4(dir).filter((entry) => {
+    return readdirSync3(dir).filter((entry) => {
       try {
-        return statSync4(join6(dir, entry)).isDirectory() && existsSync7(join6(dir, entry, "stage.yml"));
+        return statSync3(join4(dir, entry)).isDirectory() && existsSync5(join4(dir, entry, "stage.yml"));
       } catch {
         return false;
       }
@@ -1104,23 +861,23 @@ function dirsIn(dir) {
   }
 }
 function readStage(root, id) {
-  const local = join6(root, PROJECT_FRAMEWORK_DIR, "stages", id, "stage.yml");
-  const path = existsSync7(local) ? local : join6(STAGES_DIR, id, "stage.yml");
-  if (!existsSync7(path))
+  const local = join4(root, PROJECT_FRAMEWORK_DIR, "stages", id, "stage.yml");
+  const path = existsSync5(local) ? local : join4(STAGES_DIR, id, "stage.yml");
+  if (!existsSync5(path))
     return null;
   try {
-    const doc = parseYaml(readFileSync6(path, "utf8"));
+    const doc = parseYaml(readFileSync4(path, "utf8"));
     return isRecord(doc) ? doc : null;
   } catch {
     return null;
   }
 }
 function workspaceRepos(root) {
-  const path = join6(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
-  if (!existsSync7(path))
+  const path = join4(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
+  if (!existsSync5(path))
     return [];
   try {
-    const doc = parseYaml(readFileSync6(path, "utf8"));
+    const doc = parseYaml(readFileSync4(path, "utf8"));
     const list = isRecord(doc) && Array.isArray(doc.repos) ? doc.repos : [];
     return list.map((row) => isRecord(row) && typeof row.name === "string" ? row.name : "").filter((name) => name !== "");
   } catch {
@@ -1135,17 +892,14 @@ function strings(value) {
 function evidenceCount(expert) {
   return expert.areas.reduce((total, area) => total + area.evidence.length, 0);
 }
-// src/core/experts/expertKnowledge.ts
-var DEFAULT_KNOWLEDGE_MAX_BYTES = 48 * 1024;
-
 // src/core/experts/roleExperts.ts
-import { join as join7 } from "node:path";
-var ROLE_TEMPLATES_DIR = join7(TEMPLATES_DIR, "experts");
+import { join as join5 } from "node:path";
+var ROLE_TEMPLATES_DIR = join5(TEMPLATES_DIR, "experts");
 // src/core/experts/domainRank.ts
 var MAX_GRAPH_BYTES = 64 * 1024 * 1024;
 // src/core/training/mineRuns.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
-import { join as join8, relative as relative2 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
+import { join as join6, relative as relative2 } from "node:path";
 var MAX_RUN_BYTES = 64 * 1024;
 var MINED_NAMES = ["handoff.md", "retro.md"];
 var MAX_DEPTH = 4;
@@ -1161,7 +915,7 @@ function findMined(dir, depth) {
     return [];
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync4(dir);
   } catch {
     return [];
   }
@@ -1169,10 +923,10 @@ function findMined(dir, depth) {
   for (const entry of [...entries].sort()) {
     if (entry.startsWith("."))
       continue;
-    const abs = join8(dir, entry);
+    const abs = join6(dir, entry);
     let isDir = false;
     try {
-      isDir = statSync5(abs).isDirectory();
+      isDir = statSync4(abs).isDirectory();
     } catch {
       continue;
     }