@structured-vibe-coding/core 0.17.2 → 0.19.0

package/dist/chunk-TGRV6WGS.js

@@ -0,0 +1,3436 @@
+import {
+  ConfigSchema,
+  defaultTeamsDir,
+  getStage,
+  isStageSkipped,
+  shouldAutoSkip
+} from "./chunk-HG7TPW5V.js";
+import {
+  SddError
+} from "./chunk-MHODNFIL.js";
+import {
+  activePointerPath,
+  changesPathRel,
+  configPath,
+  displayChangePath,
+  ensureDir,
+  guidancePaths,
+  indexDbPath,
+  listDirs,
+  listFiles,
+  memoryPathRel,
+  pathExists,
+  readText,
+  readYaml,
+  removePath,
+  sddRoot,
+  searchConfigPath,
+  writeText,
+  writeYaml
+} from "./chunk-O5SP6X5R.js";
+
+// src/config.ts
+async function isInitialized(projectRoot) {
+  return pathExists(configPath(projectRoot));
+}
+async function loadConfig(projectRoot) {
+  const path = configPath(projectRoot);
+  if (!await pathExists(path)) {
+    throw new SddError(`SDD is not initialized in ${projectRoot}. Run \`sdd init\` first.`, {
+      code: "NOT_INITIALIZED",
+      hint: "cd into your app and run: sdd init --here --ai copilot"
+    });
+  }
+  const raw = await readYaml(path);
+  return ConfigSchema.parse(raw);
+}
+async function saveConfig(projectRoot, config) {
+  await ensureDir(sddRoot(projectRoot));
+  await writeYaml(configPath(projectRoot), ConfigSchema.parse(config));
+}
+function defaultConfig() {
+  return ConfigSchema.parse({});
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeDefaults(defaults, overrides) {
+  if (!isRecord(defaults) || !isRecord(overrides)) return overrides ?? defaults;
+  const merged = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(defaults)) {
+    merged[key] = Object.hasOwn(overrides, key) ? mergeDefaults(value, overrides[key]) : value;
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    if (!Object.hasOwn(defaults, key)) merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfigDefaults(existing) {
+  return ConfigSchema.parse(mergeDefaults(defaultConfig(), existing));
+}
+
+// src/git-head.ts
+import { spawn } from "child_process";
+import { join } from "pathe";
+function runGitHead(projectRoot) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr.trim() || `git rev-parse exited with code ${code}`));
+    });
+  });
+}
+async function getHeadSha(projectRoot, runGit = runGitHead) {
+  if (!await pathExists(join(projectRoot, ".git"))) return null;
+  let sha;
+  try {
+    sha = await runGit(projectRoot);
+  } catch {
+    return null;
+  }
+  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(sha)) {
+    throw new Error("git rev-parse returned an invalid HEAD SHA.");
+  }
+  return sha.toLowerCase();
+}
+
+// src/role/types.ts
+function emptyRoleLists() {
+  return {
+    owns: [],
+    inputs: [],
+    outputs: [],
+    collaborates: [],
+    reviews: [],
+    approvers: [],
+    never: [],
+    askHumanWhen: [],
+    skills: [],
+    rules: [],
+    goals: []
+  };
+}
+var WORK_TYPES = [
+  "route",
+  "classify",
+  "check",
+  "draft",
+  "design",
+  "code",
+  "review"
+];
+function isWorkType(value) {
+  return WORK_TYPES.includes(value);
+}
+function workKind(workType) {
+  return workType === "route" || workType === "classify" || workType === "check" ? "decide" : "reason";
+}
+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/search/tokenize.ts
+import { encode } from "gpt-tokenizer/encoding/cl100k_base";
+function countTokens(text) {
+  return encode(text).length;
+}
+function ftsTokens(query) {
+  const tokens = [];
+  let current = "";
+  for (const ch of query) {
+    const code = ch.codePointAt(0) ?? 0;
+    const ok3 = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code > 127;
+    if (ok3) {
+      current += ch;
+    } else if (current) {
+      tokens.push(current);
+      current = "";
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+// src/search/config.ts
+import { z } from "zod";
+var SearchConfigError = class extends Error {
+  constructor() {
+    super("search.yaml is invalid");
+    this.name = "SearchConfigError";
+  }
+};
+var BudgetSchema = z.object({
+  default: z.number().int().min(1).default(12e3)
+}).catchall(z.number().int().min(1));
+var SearchConfigSchema = z.object({
+  version: z.literal(1).default(1),
+  provider: z.string().min(1).default("builtin"),
+  k: z.number().int().min(1).max(100).default(20),
+  embeddings: z.boolean().default(false),
+  budgets: BudgetSchema.default({ default: 12e3 }),
+  exclude: z.array(z.string().min(1)).default([])
+});
+function budgetForStage(config, stage) {
+  if (!stage) return config.budgets.default;
+  const value = config.budgets[stage];
+  return typeof value === "number" ? value : config.budgets.default;
+}
+async function loadSearchConfig(projectRoot) {
+  const file = searchConfigPath(projectRoot);
+  if (!await pathExists(file)) {
+    return SearchConfigSchema.parse({});
+  }
+  let raw;
+  try {
+    raw = await readYaml(file);
+  } catch {
+    throw new SearchConfigError();
+  }
+  const parsed = SearchConfigSchema.safeParse(raw ?? {});
+  if (!parsed.success) throw new SearchConfigError();
+  return parsed.data;
+}
+
+// src/search/pack.ts
+var EN_DASH = "\u2013";
+function searchPreamble(query, scope, budget, hybrid = false) {
+  if (hybrid) {
+    return `# Search
+Query: ${query}
+Scope: ${scope}
+Provider: builtin
+Mode: hybrid
+Budget: ${budget}
+
+`;
+  }
+  return `# Search
+Query: ${query}
+Scope: ${scope}
+Provider: builtin
+Budget: ${budget}
+
+`;
+}
+function renderBlock(hit, form) {
+  const fence = hit.language ? `\`\`\`${hit.language}` : "```";
+  const body = form === "full" ? hit.body : form === "summary" ? hit.summary ?? "" : hit.signature;
+  return `### \`${hit.path}\` \xB7 \`${hit.symbol}\` (lines ${hit.startLine}${EN_DASH}${hit.endLine}) \xB7 ${form}
+${fence}
+${body}
+\`\`\`
+`;
+}
+function contains(outer, inner) {
+  return outer.path === inner.path && inner.startLine >= outer.startLine && inner.endLine <= outer.endLine;
+}
+function packHits(input) {
+  const { preamble, hits, budget } = input;
+  if (countTokens(preamble) > budget) {
+    return { text: "", usedTokens: 0, hits: [] };
+  }
+  let text = preamble;
+  const packed = [];
+  const full = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    const id = `${hit.path}\0${hit.symbol}\0${hit.startLine}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    if (full.some((outer) => contains(outer, hit))) continue;
+    const summary = hit.summary;
+    if (summary && summary !== hit.body) {
+      const summaryBlock = renderBlock(hit, "summary");
+      const summaryText = text + summaryBlock;
+      if (countTokens(summaryText) <= budget) {
+        text = summaryText;
+        packed.push({ ...hit, form: "summary", text: summaryBlock });
+        continue;
+      }
+    }
+    const fullBlock = renderBlock(hit, "full");
+    const fullText = text + fullBlock;
+    if (countTokens(fullText) <= budget) {
+      text = fullText;
+      full.push(hit);
+      packed.push({ ...hit, form: "full", text: fullBlock });
+      continue;
+    }
+    const signatureBlock = renderBlock(hit, "signature");
+    const signatureText = text + signatureBlock;
+    if (countTokens(signatureText) <= budget) {
+      text = signatureText;
+      packed.push({ ...hit, form: "signature", text: signatureBlock });
+    }
+  }
+  if (!text) return { text: "", usedTokens: 0, hits: packed };
+  return { text, usedTokens: countTokens(text), hits: packed };
+}
+
+// src/code-context/secrets.ts
+import { basename, normalize } from "pathe";
+var SECRET_BASENAME_PATTERNS = [
+  /^\.env$/i,
+  /^\.env\..+/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /id_rsa/i,
+  /credentials/i,
+  /secret/i
+];
+function isSecretPath(filePath) {
+  const norm = normalize(filePath).replace(/\\/g, "/");
+  const parts = norm.split("/").filter(Boolean);
+  if (parts.includes(".git")) return true;
+  if (norm.includes("/.git/") || norm.startsWith(".git/") || norm === ".git") {
+    return true;
+  }
+  const base = basename(norm);
+  return SECRET_BASENAME_PATTERNS.some((re) => re.test(base));
+}
+
+// src/code-context/ignore.ts
+import { basename as basename2, extname, normalize as normalize2 } from "pathe";
+var IGNORED_DIR_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "coverage",
+  ".turbo",
+  ".next",
+  "build",
+  ".cache"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".tgz",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".wasm",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".lock"
+]);
+function isIgnoredPath(filePath) {
+  const norm = normalize2(filePath).replace(/\\/g, "/");
+  const parts = norm.split("/").filter(Boolean);
+  for (const p of parts) {
+    if (IGNORED_DIR_SEGMENTS.has(p)) return true;
+  }
+  const ext = extname(basename2(norm)).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) return true;
+  const base = basename2(norm);
+  if (base === "package-lock.json" || base === "pnpm-lock.yaml" || base === "yarn.lock" || base === "bun.lockb") {
+    return true;
+  }
+  return false;
+}
+function classifyPath(filePath) {
+  if (isSecretPath(filePath)) return "secret";
+  if (isIgnoredPath(filePath)) return "ignored";
+  return "allowed";
+}
+
+// src/search/exclude.ts
+import { readFile, readdir } from "fs/promises";
+import ignore from "ignore";
+import { join as join2 } from "pathe";
+function isHardDenied(rel) {
+  if (isSecretPath(rel) || isIgnoredPath(rel)) return true;
+  const slash = rel.indexOf("/");
+  const first = slash === -1 ? rel : rel.slice(0, slash);
+  return first === ".sdd" || first === ".git";
+}
+function isPrunedDir(rel) {
+  if (isIgnoredPath(rel)) return true;
+  const parts = rel.split("/");
+  for (const part of parts) {
+    if (part === ".git" || part === ".sdd") return true;
+  }
+  return false;
+}
+function rewriteNestedLine(dir, line) {
+  if (line.length === 0) return [line];
+  let i = 0;
+  while (i < line.length && (line.charCodeAt(i) === 32 || line.charCodeAt(i) === 9)) i += 1;
+  if (i >= line.length) return [line];
+  if (line.charCodeAt(i) === 35) return [line];
+  let negated = false;
+  if (line.charCodeAt(i) === 33) {
+    negated = true;
+    i += 1;
+  }
+  let pattern = line.slice(i);
+  let end = pattern.length;
+  while (end > 0 && (pattern.charCodeAt(end - 1) === 32 || pattern.charCodeAt(end - 1) === 9)) {
+    end -= 1;
+  }
+  pattern = pattern.slice(0, end);
+  if (!pattern) return [line];
+  const bang = negated ? "!" : "";
+  if (!pattern.includes("/")) {
+    return [`${bang}${dir}/${pattern}`, `${bang}${dir}/**/${pattern}`];
+  }
+  const body = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+  return [`${bang}${dir}/${body}`];
+}
+function rewriteNested(dir, content) {
+  const lines = content.split("\n");
+  const out = [];
+  for (const line of lines) {
+    const logical = line.endsWith("\r") ? line.slice(0, -1) : line;
+    out.push(...rewriteNestedLine(dir, logical));
+  }
+  return out.join("\n");
+}
+async function readIfPresent(file) {
+  if (!await pathExists(file)) return "";
+  return readFile(file, "utf8");
+}
+async function nestedGitignoreFiles(projectRoot) {
+  const found = [];
+  async function walk(dir, rel) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      if (isPrunedDir(child)) continue;
+      if (entry.isDirectory()) {
+        await walk(join2(dir, entry.name), child);
+      } else if (entry.isFile() && entry.name === ".gitignore" && rel) {
+        found.push(child);
+      }
+    }
+  }
+  await walk(projectRoot, "");
+  found.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return found;
+}
+async function loadExcluder(projectRoot, exclude) {
+  const git = ignore();
+  const rootIgnore = await readIfPresent(join2(projectRoot, ".gitignore"));
+  if (rootIgnore) git.add(rootIgnore);
+  for (const rel of await nestedGitignoreFiles(projectRoot)) {
+    if (git.ignores(rel)) continue;
+    const dir = rel.slice(0, rel.lastIndexOf("/"));
+    const body = await readIfPresent(join2(projectRoot, rel));
+    if (body) git.add(rewriteNested(dir, body));
+  }
+  const sdd = ignore();
+  const sddIgnore = await readIfPresent(join2(projectRoot, ".sddignore"));
+  if (sddIgnore) sdd.add(sddIgnore);
+  const extra2 = ignore();
+  if (exclude.length) extra2.add(exclude.join("\n"));
+  return (rel) => {
+    const path = rel.replaceAll("\\", "/");
+    if (isHardDenied(path)) return true;
+    if (git.ignores(path)) return true;
+    if (sdd.ignores(path)) return true;
+    return extra2.ignores(path);
+  };
+}
+
+// src/search/chunk-markdown.ts
+function toLines(text) {
+  let normalized = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  if (normalized.endsWith("\n")) normalized = normalized.slice(0, -1);
+  if (!normalized) return [];
+  return normalized.split("\n");
+}
+function leadingSpaces(line) {
+  let i = 0;
+  while (i < line.length && line.charCodeAt(i) === 32) i += 1;
+  return i;
+}
+function fenceOpen(line) {
+  const spaces = leadingSpaces(line);
+  if (spaces > 3) return null;
+  let i = spaces;
+  if (i >= line.length) return null;
+  const ch = line[i] ?? "";
+  if (ch !== "`" && ch !== "~") return null;
+  let len = 0;
+  while (i < line.length && line[i] === ch) {
+    len += 1;
+    i += 1;
+  }
+  if (len < 3) return null;
+  return { ch, len };
+}
+function fenceClose(line, open) {
+  const spaces = leadingSpaces(line);
+  if (spaces > 3) return false;
+  let i = spaces;
+  let len = 0;
+  while (i < line.length && line[i] === open.ch) {
+    len += 1;
+    i += 1;
+  }
+  if (len < open.len) return false;
+  while (i < line.length) {
+    if (line.charCodeAt(i) !== 32) return false;
+    i += 1;
+  }
+  return true;
+}
+function headingSymbol(line) {
+  let i = 0;
+  while (i < line.length && (line.charCodeAt(i) === 32 || line.charCodeAt(i) === 9)) i += 1;
+  let hashes = 0;
+  while (i < line.length && line[i] === "#" && hashes < 7) {
+    hashes += 1;
+    i += 1;
+  }
+  if (hashes < 1 || hashes > 6) return null;
+  if (line[i] !== " ") return null;
+  i += 1;
+  let text = line.slice(i);
+  let end = text.length;
+  while (end > 0 && text.charCodeAt(end - 1) === 32) end -= 1;
+  text = text.slice(0, end);
+  return text;
+}
+function hasNonWhitespace(lines) {
+  for (const line of lines) {
+    for (const ch of line) {
+      const code = ch.codePointAt(0) ?? 0;
+      if (code !== 32 && code !== 9 && code !== 10 && code !== 13) return true;
+    }
+  }
+  return false;
+}
+function chunkMarkdown(text) {
+  const lines = toLines(text);
+  if (!lines.length) return [];
+  let open = null;
+  const headings = [];
+  for (let n = 0; n < lines.length; n += 1) {
+    const line = lines[n] ?? "";
+    if (open) {
+      if (fenceClose(line, open)) open = null;
+      continue;
+    }
+    const fence = fenceOpen(line);
+    if (fence) {
+      open = fence;
+      continue;
+    }
+    const symbol = headingSymbol(line);
+    if (symbol != null) headings.push({ line: n + 1, symbol, raw: line });
+  }
+  const chunks = [];
+  const first = headings[0]?.line ?? lines.length + 1;
+  if (first > 1) {
+    const pre = lines.slice(0, first - 1);
+    if (hasNonWhitespace(pre)) {
+      chunks.push({
+        symbol: "(preamble)",
+        startLine: 1,
+        endLine: first - 1,
+        signature: "(preamble)",
+        body: pre.join("\n")
+      });
+    }
+  }
+  for (let i = 0; i < headings.length; i += 1) {
+    const heading = headings[i];
+    const next = headings[i + 1]?.line ?? lines.length + 1;
+    const start2 = heading.line;
+    const end = next - 1;
+    chunks.push({
+      symbol: heading.symbol,
+      startLine: start2,
+      endLine: end,
+      signature: heading.raw,
+      body: lines.slice(start2 - 1, end).join("\n")
+    });
+  }
+  return chunks;
+}
+
+// src/search/summarize.ts
+import { decode, encode as encode2 } from "gpt-tokenizer/encoding/cl100k_base";
+var SUMMARY_TOKEN_CAP = 80;
+function clipToTokens(text, cap) {
+  const ids = encode2(text);
+  let n = Math.min(cap, ids.length);
+  let clipped = n === 0 ? "" : decode(ids.slice(0, n));
+  if (clipped.endsWith("\n")) clipped = clipped.slice(0, -1);
+  while (n > 0 && countTokens(clipped) > cap) {
+    n -= 1;
+    clipped = n === 0 ? "" : decode(ids.slice(0, n));
+    if (clipped.endsWith("\n")) clipped = clipped.slice(0, -1);
+  }
+  return clipped;
+}
+function extractiveSummary(signature, body) {
+  if (countTokens(body) <= SUMMARY_TOKEN_CAP) return body;
+  const keepHeading = signature.length > 0 && signature !== "(preamble)" && body.startsWith(signature) && (body.length === signature.length || body.charCodeAt(signature.length) === 10) && countTokens(signature) <= SUMMARY_TOKEN_CAP;
+  if (!keepHeading) return clipToTokens(body, SUMMARY_TOKEN_CAP);
+  const rest = body.slice(signature.length);
+  const restIds = encode2(rest);
+  let lo = 0;
+  let hi = restIds.length;
+  let best = signature;
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    const tail = mid === 0 ? "" : decode(restIds.slice(0, mid));
+    const candidate = signature + tail;
+    if (countTokens(candidate) <= SUMMARY_TOKEN_CAP) {
+      best = candidate;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  if (best.endsWith("\n")) {
+    const stripped = best.slice(0, -1);
+    if (countTokens(stripped) <= SUMMARY_TOKEN_CAP && stripped.startsWith(signature)) {
+      best = stripped;
+    }
+  }
+  return best;
+}
+
+// src/search/embed.ts
+import { rm, stat } from "fs/promises";
+import { join as join3 } from "pathe";
+var EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5";
+var EMBEDDING_DIM = 384;
+var EMBEDDINGS_UNAVAILABLE = "Embeddings are unavailable. Using keyword search.";
+var MODEL_DIR = "Qdrant_bge-small-en-v1.5-onnx-Q";
+var CACHE_FILES = [
+  "model_optimized.onnx",
+  "tokenizer.json",
+  "tokenizer_config.json",
+  "config.json",
+  "special_tokens_map.json"
+];
+var fastembedImportCount = 0;
+var ready = /* @__PURE__ */ new Map();
+var projectSessions = /* @__PURE__ */ new Map();
+var runtimeSessions = /* @__PURE__ */ new WeakMap();
+async function cacheComplete(dir) {
+  for (const name of CACHE_FILES) {
+    try {
+      const info = await stat(join3(dir, name));
+      if (!info.isFile() || info.size <= 0) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function asFloat32(value) {
+  if (value instanceof Float32Array) return value;
+  return Float32Array.from(value);
+}
+function wrapModel(model) {
+  return {
+    async embedPassages(texts) {
+      const out = [];
+      for await (const batch of model.passageEmbed(texts, 16)) {
+        for (const vector of batch) out.push(asFloat32(vector));
+      }
+      if (out.length !== texts.length) throw new Error("Embedding batch length does not match.");
+      for (const vector of out) {
+        if (vector.length !== EMBEDDING_DIM) throw new Error("Embedding length is not 384.");
+      }
+      return out;
+    },
+    async embedQuery(text) {
+      const vector = asFloat32(await model.queryEmbed(text));
+      if (vector.length !== EMBEDDING_DIM) throw new Error("Embedding length is not 384.");
+      return vector;
+    }
+  };
+}
+async function importFastembed() {
+  fastembedImportCount += 1;
+  return import("fastembed");
+}
+async function initReal(cacheDir) {
+  const mod = await importFastembed();
+  return mod.FlagEmbedding.init({
+    model: mod.EmbeddingModel.BGESmallENV15,
+    executionProviders: [mod.ExecutionProvider.CPU],
+    maxLength: 512,
+    showDownloadProgress: false,
+    cacheDir
+  });
+}
+async function start(projectRoot, hooks) {
+  const cacheDir = join3(sddRoot(projectRoot), "models", "fastembed");
+  const modelDir = join3(cacheDir, MODEL_DIR);
+  const completeBefore = await cacheComplete(modelDir);
+  try {
+    const model = hooks?.init ? await hooks.init({
+      model: "BGESmallENV15",
+      executionProviders: ["cpu"],
+      maxLength: 512,
+      showDownloadProgress: false,
+      cacheDir
+    }) : await initReal(cacheDir);
+    return wrapModel(model);
+  } catch (err) {
+    if (!completeBefore) await rm(modelDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+function createFastembedEmbedder(projectRoot, hooks) {
+  if (hooks?.init) return start(projectRoot, hooks);
+  const cacheDir = join3(sddRoot(projectRoot), "models", "fastembed");
+  const existing = ready.get(cacheDir);
+  if (existing) return existing;
+  const pending = start(projectRoot).catch((err) => {
+    ready.delete(cacheDir);
+    throw err;
+  });
+  ready.set(cacheDir, pending);
+  return pending;
+}
+function resolveEmbedder(projectRoot, embeddings, runtime) {
+  if (!embeddings) return Promise.resolve(null);
+  if (runtime?.embedder) return Promise.resolve(runtime.embedder);
+  if (runtime?.embedderFactory) {
+    const existing2 = runtimeSessions.get(runtime);
+    if (existing2) return existing2;
+    const pending2 = runtime.embedderFactory().then((embedder) => embedder).catch(() => null);
+    runtimeSessions.set(runtime, pending2);
+    return pending2;
+  }
+  const existing = projectSessions.get(projectRoot);
+  if (existing) return existing;
+  const pending = createFastembedEmbedder(projectRoot).then(
+    (embedder) => embedder,
+    () => null
+  );
+  projectSessions.set(projectRoot, pending);
+  return pending;
+}
+async function embedSearchQuery(embedder, embeddings, query) {
+  if (!embeddings) return { queryVec: null, failure: "none" };
+  if (!embedder) return { queryVec: null, failure: "load" };
+  try {
+    const queryVec = await embedder.embedQuery(query);
+    if (queryVec.length !== EMBEDDING_DIM) return { queryVec: null, failure: "query" };
+    return { queryVec, failure: "none" };
+  } catch {
+    return { queryVec: null, failure: "query" };
+  }
+}
+
+// src/search/result-cache.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import Database from "better-sqlite3";
+import { isAbsolute } from "pathe";
+
+// src/search/schema.ts
+var SEARCH_SCHEMA_SQL = `
+PRAGMA journal_mode = DELETE;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY,
+  content_hash TEXT NOT NULL,
+  scope TEXT NOT NULL CHECK (scope IN ('code', 'specs', 'memory')),
+  language TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chunks (
+  id INTEGER PRIMARY KEY,
+  path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+  scope TEXT NOT NULL,
+  symbol TEXT NOT NULL,
+  start_line INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  signature TEXT NOT NULL,
+  body TEXT NOT NULL,
+  chunk_hash TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+  symbol,
+  body,
+  tokenize = 'unicode61'
+);
+
+CREATE TABLE IF NOT EXISTS chunks_fts_map (
+  chunk_id INTEGER PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+  fts_rowid INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS vec_meta (
+  chunk_id INTEGER PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+  chunk_hash TEXT NOT NULL,
+  scope TEXT NOT NULL CHECK (scope IN ('code', 'specs', 'memory'))
+);
+
+CREATE TABLE IF NOT EXISTS spec_summaries (
+  path TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  symbol TEXT NOT NULL,
+  start_line INTEGER NOT NULL,
+  summary TEXT NOT NULL,
+  PRIMARY KEY (path, content_hash, symbol, start_line)
+);
+
+CREATE TABLE IF NOT EXISTS result_cache (
+  cache_key TEXT PRIMARY KEY,
+  query TEXT NOT NULL,
+  channel TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  k INTEGER NOT NULL,
+  budget INTEGER NOT NULL,
+  embeddings INTEGER NOT NULL,
+  active_change TEXT NOT NULL,
+  filter TEXT NOT NULL,
+  index_version TEXT NOT NULL,
+  mode TEXT NOT NULL,
+  hybrid_scopes TEXT NOT NULL,
+  payload TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS result_cache_files (
+  cache_key TEXT NOT NULL,
+  path TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  PRIMARY KEY (cache_key, path)
+);
+`;
+var ADD_CHUNK_HASH_SQL = "ALTER TABLE chunks ADD COLUMN chunk_hash TEXT NOT NULL DEFAULT ''";
+
+// src/search/result-cache.ts
+var PRIVATE_MARKERS = ["FAKE_BIRTH_RECORD_S1", "fake-secret-s1-do-not-index"];
+function containsPrivate(text) {
+  return PRIVATE_MARKERS.some((marker) => text.includes(marker));
+}
+function field(value) {
+  return `${Buffer.byteLength(value, "utf8")}:${value}`;
+}
+function comparePath(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function filterText(paths, symbols) {
+  const pathText = [...paths].sort(comparePath).join("\n");
+  const symbolText = [...symbols].sort(comparePath).join("\n");
+  return `${pathText}
+/
+${symbolText}`;
+}
+function contributorText(rows) {
+  const sorted = [...rows].sort((a, b) => comparePath(a.path, b.path));
+  return sorted.map((row) => `${row.path}	${row.content_hash}
+`).join("");
+}
+function sha256(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function cacheMaterial(request, version, filter) {
+  return [
+    field(request.query),
+    field(request.channel),
+    field(request.scope),
+    field(String(request.k)),
+    field(String(request.budget)),
+    field(request.embeddings ? "1" : "0"),
+    field(request.activeChange),
+    field(version),
+    field(filter)
+  ].join("\n");
+}
+function under(rel, root) {
+  let end = root.length;
+  while (end > 0 && root.charCodeAt(end - 1) === 47) end -= 1;
+  const prefix = root.slice(0, end);
+  if (!prefix) return false;
+  return rel === prefix || rel.startsWith(`${prefix}/`);
+}
+function openCacheDb(projectRoot) {
+  const db = new Database(indexDbPath(projectRoot));
+  db.exec(SEARCH_SCHEMA_SQL);
+  return db;
+}
+function scopeState(db, scope) {
+  const counts = db.prepare(
+    `SELECT
+         (SELECT COUNT(*) FROM chunks WHERE scope = ?) AS chunks,
+         (SELECT COUNT(*) FROM chunks AS c
+            JOIN vec_meta AS m ON m.chunk_id = c.id AND m.chunk_hash = c.chunk_hash
+            WHERE c.scope = ?) AS ready`
+  ).get(scope, scope);
+  if (!counts || counts.chunks === 0) return "empty";
+  const model = db.prepare("SELECT value FROM meta WHERE key = ?").get("embedding_model");
+  const modelOk = !model || model.value === EMBEDDING_MODEL;
+  if (counts.ready === counts.chunks && modelOk) return "ready";
+  return "partial";
+}
+function readyList(db, scopes, embeddings) {
+  if (!embeddings) return "";
+  return scopes.filter((scope) => scopeState(db, scope) === "ready").sort(comparePath).join(",");
+}
+function normalizeHybrid(hybridScopes) {
+  return hybridScopes.split(",").filter(Boolean).sort(comparePath).join(",");
+}
+async function resolveActiveDirectory(projectRoot, config) {
+  let text;
+  try {
+    text = await readFile2(activePointerPath(projectRoot, config), "utf8");
+  } catch {
+    return "";
+  }
+  const id = text.trim();
+  if (!id || isAbsolute(id) || id.includes("\\")) return "";
+  const parts = id.split("/");
+  if (parts.some((part) => part === "" || part === "." || part === "..")) return "";
+  return displayChangePath(config, id);
+}
+function forgetPath(db, rel) {
+  const keys = db.prepare("SELECT cache_key FROM result_cache_files WHERE path = ?").all(rel);
+  const dropCache = db.prepare("DELETE FROM result_cache WHERE cache_key = ?");
+  const dropFiles = db.prepare("DELETE FROM result_cache_files WHERE cache_key = ?");
+  for (const row of keys) {
+    dropCache.run(row.cache_key);
+    dropFiles.run(row.cache_key);
+  }
+  db.prepare("DELETE FROM spec_summaries WHERE path = ?").run(rel);
+}
+function dropCacheKey(db, cacheKey) {
+  db.prepare("DELETE FROM result_cache WHERE cache_key = ?").run(cacheKey);
+  db.prepare("DELETE FROM result_cache_files WHERE cache_key = ?").run(cacheKey);
+}
+function hitFromPayload(value) {
+  if (!value || typeof value !== "object") return null;
+  const hit = value;
+  const formOk = hit.form === "full" || hit.form === "signature" || hit.form === "summary";
+  if (!formOk) return null;
+  if (typeof hit.path !== "string" || typeof hit.symbol !== "string") return null;
+  if (typeof hit.text !== "string" || typeof hit.signature !== "string") return null;
+  if (typeof hit.body !== "string" || typeof hit.language !== "string") return null;
+  if (typeof hit.startLine !== "number" || typeof hit.endLine !== "number") return null;
+  if (typeof hit.score !== "number" || typeof hit.scope !== "string") return null;
+  return {
+    scope: hit.scope,
+    path: hit.path,
+    startLine: hit.startLine,
+    endLine: hit.endLine,
+    symbol: hit.symbol,
+    score: hit.score,
+    form: hit.form,
+    text: hit.text,
+    signature: hit.signature,
+    body: hit.body,
+    language: hit.language
+  };
+}
+function payloadHits(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const body = parsed;
+  if (typeof body.text !== "string" || !Array.isArray(body.hits)) return null;
+  const hits = [];
+  for (const value of body.hits) {
+    const hit = hitFromPayload(value);
+    if (!hit) return null;
+    hits.push(hit);
+  }
+  return { text: body.text, hits };
+}
+function cachedWarning(db, request) {
+  if (!request.embeddings) return void 0;
+  const partial = request.scopes.some((scope) => scopeState(db, scope) === "partial");
+  return partial ? EMBEDDINGS_UNAVAILABLE : void 0;
+}
+function readPackedCache(request) {
+  if (containsPrivate(request.query)) return null;
+  const db = openCacheDb(request.projectRoot);
+  try {
+    const filter = filterText(request.filterPaths ?? [], request.filterSymbols ?? []);
+    const rows = db.prepare(
+      `SELECT cache_key, mode, hybrid_scopes, index_version, payload, query
+         FROM result_cache
+         WHERE query = ? AND channel = ? AND scope = ? AND k = ? AND budget = ?
+           AND embeddings = ? AND active_change = ? AND filter = ?`
+    ).all(
+      request.query,
+      request.channel,
+      request.scope,
+      request.k,
+      request.budget,
+      request.embeddings ? 1 : 0,
+      request.activeChange,
+      filter
+    );
+    const expected = readyList(db, request.scopes, request.embeddings);
+    for (const row of rows) {
+      const parsed = payloadHits(row.payload);
+      if (!parsed || containsPrivate(row.query) || containsPrivate(row.payload) || containsPrivate(parsed.text)) {
+        dropCacheKey(db, row.cache_key);
+        continue;
+      }
+      const files = db.prepare("SELECT path, content_hash FROM result_cache_files WHERE cache_key = ?").all(row.cache_key);
+      let fresh = true;
+      for (const file of files) {
+        const current = db.prepare("SELECT content_hash FROM files WHERE path = ?").get(file.path);
+        if (!current || current.content_hash !== file.content_hash) {
+          fresh = false;
+          break;
+        }
+      }
+      if (!fresh || sha256(contributorText(files)) !== row.index_version) {
+        dropCacheKey(db, row.cache_key);
+        continue;
+      }
+      const hybrid = normalizeHybrid(row.hybrid_scopes);
+      if (!request.embeddings) {
+        if (row.mode !== "bm25" || hybrid !== "") {
+          dropCacheKey(db, row.cache_key);
+          continue;
+        }
+      } else if (hybrid !== expected) {
+        dropCacheKey(db, row.cache_key);
+        continue;
+      }
+      return { text: parsed.text, hits: parsed.hits, warning: cachedWarning(db, request) };
+    }
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function serializeHit(hit) {
+  return {
+    scope: hit.scope,
+    path: hit.path,
+    startLine: hit.startLine,
+    endLine: hit.endLine,
+    symbol: hit.symbol,
+    score: hit.score,
+    form: hit.form,
+    text: hit.text,
+    signature: hit.signature,
+    body: hit.body,
+    language: hit.language,
+    rankedBy: hit.rankedBy ?? null
+  };
+}
+function writePackedCache(request, packed, contributors, mode, hybridScopes) {
+  if (containsPrivate(request.query) || containsPrivate(packed.text)) return;
+  if (packed.text.startsWith("Retrieved context skipped:")) return;
+  const db = openCacheDb(request.projectRoot);
+  try {
+    const byPath2 = /* @__PURE__ */ new Map();
+    for (const hit of contributors) {
+      if (byPath2.has(hit.path)) continue;
+      const row = db.prepare("SELECT content_hash FROM files WHERE path = ?").get(hit.path);
+      if (row) byPath2.set(hit.path, row.content_hash);
+    }
+    const files = [...byPath2.entries()].map(([path, content_hash]) => ({
+      path,
+      content_hash
+    }));
+    const version = sha256(contributorText(files));
+    const filter = filterText(request.filterPaths ?? [], request.filterSymbols ?? []);
+    const cacheKey = sha256(cacheMaterial(request, version, filter));
+    const payload = JSON.stringify({
+      text: packed.text,
+      hits: packed.hits.map((hit) => serializeHit(hit))
+    });
+    if (containsPrivate(payload)) return;
+    const hybrid = normalizeHybrid(hybridScopes);
+    const write = db.transaction(() => {
+      db.prepare(
+        `INSERT INTO result_cache (
+           cache_key, query, channel, scope, k, budget, embeddings, active_change, filter,
+           index_version, mode, hybrid_scopes, payload
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(cache_key) DO UPDATE SET
+           query = excluded.query,
+           channel = excluded.channel,
+           scope = excluded.scope,
+           k = excluded.k,
+           budget = excluded.budget,
+           embeddings = excluded.embeddings,
+           active_change = excluded.active_change,
+           filter = excluded.filter,
+           index_version = excluded.index_version,
+           mode = excluded.mode,
+           hybrid_scopes = excluded.hybrid_scopes,
+           payload = excluded.payload`
+      ).run(
+        cacheKey,
+        request.query,
+        request.channel,
+        request.scope,
+        request.k,
+        request.budget,
+        request.embeddings ? 1 : 0,
+        request.activeChange,
+        filter,
+        version,
+        mode,
+        hybrid,
+        payload
+      );
+      db.prepare("DELETE FROM result_cache_files WHERE cache_key = ?").run(cacheKey);
+      const insertFile = db.prepare(
+        "INSERT INTO result_cache_files (cache_key, path, content_hash) VALUES (?, ?, ?)"
+      );
+      for (const file of files) insertFile.run(cacheKey, file.path, file.content_hash);
+    });
+    write();
+  } finally {
+    db.close();
+  }
+}
+function attachSummaries(projectRoot, hits, activeChange) {
+  const db = openCacheDb(projectRoot);
+  try {
+    return hits.map((hit) => {
+      if (hit.scope === "code") return hit;
+      if (hit.scope === "specs" && under(hit.path, activeChange)) return hit;
+      if (hit.scope !== "specs" && hit.scope !== "memory") return hit;
+      try {
+        const file = db.prepare("SELECT content_hash FROM files WHERE path = ?").get(hit.path);
+        if (!file) return hit;
+        const stored = db.prepare(
+          `SELECT summary FROM spec_summaries
+             WHERE path = ? AND content_hash = ? AND symbol = ? AND start_line = ?`
+        ).get(hit.path, file.content_hash, hit.symbol, hit.startLine);
+        if (stored) return { ...hit, summary: stored.summary };
+        if (containsPrivate(hit.body) || containsPrivate(hit.signature)) return hit;
+        const summary = extractiveSummary(hit.signature, hit.body);
+        if (containsPrivate(summary)) return hit;
+        db.prepare("DELETE FROM spec_summaries WHERE path = ? AND content_hash != ?").run(
+          hit.path,
+          file.content_hash
+        );
+        db.prepare(
+          `INSERT INTO spec_summaries (path, content_hash, symbol, start_line, summary)
+           VALUES (?, ?, ?, ?, ?)`
+        ).run(hit.path, file.content_hash, hit.symbol, hit.startLine, summary);
+        return { ...hit, summary };
+      } catch {
+        return hit;
+      }
+    });
+  } catch {
+    return hits.slice();
+  } finally {
+    db.close();
+  }
+}
+
+// src/search/chunk-code.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join as join4 } from "pathe";
+import { Language, Parser } from "web-tree-sitter";
+var EMIT = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "generator_function_declaration",
+  "class_declaration",
+  "method_definition",
+  "interface_declaration",
+  "type_alias_declaration",
+  "enum_declaration",
+  "function_definition",
+  "class_definition",
+  "function_item",
+  "struct_item",
+  "enum_item",
+  "trait_item",
+  "impl_item",
+  "mod_item"
+]);
+var INNER_FUNCTION = /* @__PURE__ */ new Set(["arrow_function", "function", "function_expression"]);
+var NAME_TYPES = /* @__PURE__ */ new Set(["identifier", "property_identifier", "type_identifier"]);
+var WASM_BY_EXT = {
+  ".js": "tree-sitter-javascript.wasm",
+  ".mjs": "tree-sitter-javascript.wasm",
+  ".cjs": "tree-sitter-javascript.wasm",
+  ".jsx": "tree-sitter-javascript.wasm",
+  ".ts": "tree-sitter-typescript.wasm",
+  ".mts": "tree-sitter-typescript.wasm",
+  ".cts": "tree-sitter-typescript.wasm",
+  ".tsx": "tree-sitter-tsx.wasm",
+  ".py": "tree-sitter-python.wasm",
+  ".rs": "tree-sitter-rust.wasm"
+};
+var LANG_BY_EXT = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "js",
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".py": "py",
+  ".rs": "rs"
+};
+function languageForExt(ext) {
+  return LANG_BY_EXT[ext] ?? null;
+}
+function grammarForExt(ext) {
+  return WASM_BY_EXT[ext] ?? null;
+}
+function vendorDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join4(here, "..", "vendor", "tree-sitter"),
+    join4(here, "vendor", "tree-sitter"),
+    join4(here, "..", "..", "vendor", "tree-sitter")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return candidates[0];
+}
+var ready2 = null;
+var languages = /* @__PURE__ */ new Map();
+async function initParser() {
+  if (!ready2) {
+    const require2 = createRequire(import.meta.url);
+    const wasm = require2.resolve("web-tree-sitter/web-tree-sitter.wasm");
+    ready2 = Parser.init({ locateFile: () => wasm });
+  }
+  await ready2;
+}
+async function loadLanguage(ext) {
+  const file = grammarForExt(ext);
+  if (!file) return null;
+  const cached = languages.get(file);
+  if (cached) return cached;
+  await initParser();
+  const lang = await Language.load(join4(vendorDir(), file));
+  languages.set(file, lang);
+  return lang;
+}
+function sourceLines(text) {
+  let normalized = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  if (normalized.endsWith("\n")) normalized = normalized.slice(0, -1);
+  if (!normalized) return [];
+  return normalized.split("\n");
+}
+function startLine(node) {
+  return node.startPosition.row + 1;
+}
+function endLine(node) {
+  if (node.endPosition.column === 0 && node.endPosition.row > node.startPosition.row) {
+    return node.endPosition.row;
+  }
+  return node.endPosition.row + 1;
+}
+function ownName(node) {
+  for (let i = 0; i < node.childCount; i += 1) {
+    const child = node.child(i);
+    if (child && NAME_TYPES.has(child.type)) return child.text;
+  }
+  return null;
+}
+function hasChildType(node, type) {
+  for (let i = 0; i < node.childCount; i += 1) {
+    if (node.child(i)?.type === type) return true;
+  }
+  return false;
+}
+function hasDescendantType(node, types) {
+  for (let i = 0; i < node.childCount; i += 1) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (types.has(child.type) || hasDescendantType(child, types)) return true;
+  }
+  return false;
+}
+function declaresFunction(node) {
+  return (node.type === "lexical_declaration" || node.type === "variable_declaration") && hasDescendantType(node, INNER_FUNCTION);
+}
+function insideCapturedDeclaration(node) {
+  let parent = node.parent;
+  while (parent) {
+    if (declaresFunction(parent)) return true;
+    parent = parent.parent;
+  }
+  return false;
+}
+function classPrefix(node) {
+  if (node.type === "class_declaration" || node.type === "class_definition") return null;
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "class_declaration" || parent.type === "class_definition" || parent.type === "class") {
+      return ownName(parent);
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function spanNode(node) {
+  const parent = node.parent;
+  if (!parent) return node;
+  if (parent.type === "export_statement" || parent.type === "decorated_definition") return parent;
+  return node;
+}
+function shouldEmit(node) {
+  if (insideCapturedDeclaration(node)) return false;
+  if (declaresFunction(node)) return true;
+  if (!EMIT.has(node.type)) return false;
+  if (node.type === "mod_item" && !hasChildType(node, "declaration_list")) return false;
+  return true;
+}
+function symbolFor(node) {
+  const name = ownName(node);
+  if (node.type === "impl_item" && !name) return "(impl)";
+  const prefix = classPrefix(node);
+  if (prefix && name) return `${prefix}.${name}`;
+  if (name) return name;
+  return "(anonymous)";
+}
+function fileChunk(text, language) {
+  const lines = sourceLines(text);
+  if (!lines.length) return [];
+  let signature = "(file)";
+  for (const line of lines) {
+    let blank = true;
+    for (const ch of line) {
+      const code = ch.codePointAt(0) ?? 0;
+      if (code !== 32 && code !== 9) {
+        blank = false;
+        break;
+      }
+    }
+    if (!blank) {
+      signature = line;
+      break;
+    }
+  }
+  return [
+    {
+      symbol: "(file)",
+      startLine: 1,
+      endLine: lines.length,
+      signature,
+      body: lines.join("\n"),
+      language
+    }
+  ];
+}
+var parser = null;
+var parseQueue = Promise.resolve();
+function parseSerialized(lang, text) {
+  let release = () => void 0;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const previous = parseQueue;
+  parseQueue = gate;
+  return previous.then(() => {
+    try {
+      if (!parser) parser = new Parser();
+      parser.setLanguage(lang);
+      return parser.parse(text);
+    } catch {
+      return null;
+    } finally {
+      release();
+    }
+  });
+}
+async function chunkCode(text, ext) {
+  if (text.includes("\0")) return null;
+  const language = languageForExt(ext);
+  if (!language) return null;
+  const lang = await loadLanguage(ext);
+  if (!lang) return null;
+  const tree = await parseSerialized(lang, text);
+  if (!tree) return null;
+  const lines = sourceLines(text);
+  const chunks = [];
+  const visit = (node) => {
+    if (shouldEmit(node)) {
+      const span = spanNode(node);
+      const start2 = startLine(span);
+      const end = endLine(span);
+      if (start2 >= 1 && end >= start2 && end <= lines.length) {
+        const bodyLines = lines.slice(start2 - 1, end);
+        const signature = bodyLines[0] ?? "(anonymous)";
+        chunks.push({
+          symbol: symbolFor(node),
+          startLine: start2,
+          endLine: end,
+          signature,
+          body: bodyLines.join("\n"),
+          language
+        });
+      }
+    }
+    for (let i = 0; i < node.childCount; i += 1) {
+      const child = node.child(i);
+      if (child) visit(child);
+    }
+  };
+  visit(tree.rootNode);
+  if (!chunks.length) return fileChunk(text, language);
+  return chunks;
+}
+
+// src/search/rrf.ts
+var RRF_K = 60;
+function rrf(rank) {
+  if (rank === void 0) return 0;
+  return 1 / (RRF_K + rank);
+}
+function byPath(a, b) {
+  if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+  if (a.startLine !== b.startLine) return a.startLine - b.startLine;
+  if (a.symbol !== b.symbol) return a.symbol < b.symbol ? -1 : 1;
+  return 0;
+}
+function fuseByRank(entries) {
+  const sorted = [...entries].sort((a, b) => {
+    const delta = rrf(b.keywordRank) + rrf(b.vectorRank) - (rrf(a.keywordRank) + rrf(a.vectorRank));
+    if (delta !== 0) return delta;
+    return byPath(a, b);
+  });
+  return sorted.map((entry) => ({
+    id: entry.id,
+    score: rrf(entry.keywordRank) + rrf(entry.vectorRank)
+  }));
+}
+function hitKey(hit) {
+  return `${hit.path}\0${hit.startLine}\0${hit.symbol}`;
+}
+function comparePath2(a, b) {
+  if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+  if (a.startLine !== b.startLine) return a.startLine - b.startLine;
+  if (a.symbol !== b.symbol) return a.symbol < b.symbol ? -1 : 1;
+  return 0;
+}
+function fuseHits(keyword, vector) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < keyword.length; i++) {
+    const hit = keyword[i];
+    if (!hit) continue;
+    map.set(hitKey(hit), { hit, keywordRank: i + 1 });
+  }
+  for (let i = 0; i < vector.length; i++) {
+    const hit = vector[i];
+    if (!hit) continue;
+    const key = hitKey(hit);
+    const existing = map.get(key);
+    if (existing) existing.vectorRank = i + 1;
+    else map.set(key, { hit, vectorRank: i + 1 });
+  }
+  const fused = [];
+  for (const entry of map.values()) {
+    fused.push({
+      ...entry.hit,
+      score: rrf(entry.keywordRank) + rrf(entry.vectorRank),
+      rankedBy: "rrf"
+    });
+  }
+  fused.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    return comparePath2(a, b);
+  });
+  return fused;
+}
+var SCOPE_ORDER = { specs: 0, memory: 1, code: 2 };
+function compareBm25(a, b, scopeOrder) {
+  if (a.score !== b.score) return a.score - b.score;
+  if (scopeOrder) {
+    const scopeDelta = SCOPE_ORDER[a.scope] - SCOPE_ORDER[b.scope];
+    if (scopeDelta !== 0) return scopeDelta;
+  }
+  return comparePath2(a, b);
+}
+function mergeRankedHits(hits) {
+  if (hits.every((hit) => hit.rankedBy !== "rrf")) {
+    return [...hits].sort((a, b) => compareBm25(a, b, true));
+  }
+  const rrfHits = hits.filter((hit) => hit.rankedBy === "rrf");
+  const bm25Hits = hits.filter((hit) => hit.rankedBy !== "rrf");
+  rrfHits.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    return comparePath2(a, b);
+  });
+  bm25Hits.sort((a, b) => compareBm25(a, b, false));
+  return [...rrfHits, ...bm25Hits];
+}
+
+// src/search/builtin.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import Database2 from "better-sqlite3";
+import { isAbsolute as isAbsolute2, join as join5 } from "pathe";
+
+// src/search/vec.ts
+var TABLES = {
+  code: "chunk_vec_code",
+  specs: "chunk_vec_specs",
+  memory: "chunk_vec_memory"
+};
+var CREATE_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec_code USING vec0(
+  embedding float[384] distance_metric=cosine
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec_specs USING vec0(
+  embedding float[384] distance_metric=cosine
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec_memory USING vec0(
+  embedding float[384] distance_metric=cosine
+);
+`;
+var state = /* @__PURE__ */ new WeakMap();
+function vecTable(scope) {
+  return TABLES[scope];
+}
+function vecTablesPresent(db) {
+  const row = db.prepare(
+    `SELECT 1 AS n FROM sqlite_master
+       WHERE name IN ('chunk_vec_code', 'chunk_vec_specs', 'chunk_vec_memory')
+       LIMIT 1`
+  ).get();
+  return Boolean(row);
+}
+function pickLoad(mod) {
+  if (!mod || typeof mod !== "object") return null;
+  const record = mod;
+  if (typeof record.load === "function") return record.load;
+  if (record.default && typeof record.default.load === "function") {
+    return record.default.load;
+  }
+  return null;
+}
+async function ensureVecLoaded(db) {
+  const known = state.get(db);
+  if (known === "ready") return true;
+  if (known === "failed") return false;
+  try {
+    const mod = await import("sqlite-vec");
+    const load = pickLoad(mod);
+    if (!load) {
+      state.set(db, "failed");
+      return false;
+    }
+    load(db);
+    state.set(db, "ready");
+    return true;
+  } catch {
+    state.set(db, "failed");
+    return false;
+  }
+}
+function vecReady(db) {
+  return state.get(db) === "ready";
+}
+function createVecTables(db) {
+  db.exec(CREATE_SQL);
+}
+function dropVecTables(db) {
+  db.exec(`
+    DROP TABLE IF EXISTS chunk_vec_code;
+    DROP TABLE IF EXISTS chunk_vec_specs;
+    DROP TABLE IF EXISTS chunk_vec_memory;
+  `);
+}
+function insertVector(db, scope, id, value, hash) {
+  const table = TABLES[scope];
+  const rowid = BigInt(id);
+  db.prepare(`DELETE FROM ${table} WHERE rowid = ?`).run(rowid);
+  db.prepare(`INSERT INTO ${table} (rowid, embedding) VALUES (?, ?)`).run(rowid, value);
+  db.prepare(
+    `INSERT INTO vec_meta (chunk_id, chunk_hash, scope) VALUES (?, ?, ?)
+     ON CONFLICT(chunk_id) DO UPDATE SET chunk_hash = excluded.chunk_hash, scope = excluded.scope`
+  ).run(id, hash, scope);
+}
+function asBlob(value) {
+  if (value instanceof Float32Array) return value;
+  if (Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer.from(value);
+  return null;
+}
+function readVectorBlob(db, hash) {
+  if (!vecReady(db)) return null;
+  const row = db.prepare("SELECT chunk_id, scope FROM vec_meta WHERE chunk_hash = ? LIMIT 1").get(hash);
+  if (!row || !TABLES[row.scope]) return null;
+  try {
+    const stored = db.prepare(`SELECT embedding FROM ${TABLES[row.scope]} WHERE rowid = ?`).get(BigInt(row.chunk_id));
+    return stored ? asBlob(stored.embedding) : null;
+  } catch {
+    return null;
+  }
+}
+function queryVectors(db, scope, queryVec, k) {
+  const table = TABLES[scope];
+  return db.prepare(
+    `SELECT c.path, c.scope, c.symbol, c.start_line, c.end_line, c.signature, c.body,
+              f.language AS language, v.distance AS distance
+       FROM ${table} AS v
+       JOIN chunks AS c ON c.id = v.rowid
+       JOIN vec_meta AS m ON m.chunk_id = c.id AND m.chunk_hash = c.chunk_hash
+       JOIN files AS f ON f.path = c.path
+       WHERE v.embedding MATCH ?
+         AND k = ?
+         AND c.scope = ?
+       ORDER BY v.distance ASC, c.path ASC, c.start_line ASC, c.symbol ASC`
+  ).all(queryVec, k, scope);
+}
+
+// src/search/builtin.ts
+var CODE_EXT = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs"
+]);
+var EMPTY_STATS = {
+  provider: "builtin",
+  files: 0,
+  chunks: 0,
+  lastIndexFilesConsidered: 0,
+  lastIndexFilesReindexed: 0,
+  lastIndexChunksReindexed: 0,
+  lastIndexChunksEmbedded: 0,
+  indexedCommit: null
+};
+function extensionOf(rel) {
+  const slash = rel.lastIndexOf("/");
+  const base = slash === -1 ? rel : rel.slice(slash + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return base.slice(dot).toLowerCase();
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function under2(rel, root) {
+  const prefix = stripTrailingSlashes(root);
+  if (!prefix) return false;
+  return rel === prefix || rel.startsWith(`${prefix}/`);
+}
+function scopeForPath(rel, config) {
+  const ext = extensionOf(rel);
+  if (CODE_EXT.has(ext)) return "code";
+  if (ext !== ".md") return null;
+  if (under2(rel, memoryPathRel(config))) return "memory";
+  const archive = stripTrailingSlashes(config.archive_path) || "archive";
+  if (under2(rel, changesPathRel(config)) || under2(rel, archive) || under2(rel, "docs")) {
+    return "specs";
+  }
+  return null;
+}
+function assertRepoRelative(input) {
+  if (isAbsolute2(input)) throw new Error("Index path must be project-relative.");
+  let rel = input.replaceAll("\\", "/");
+  while (rel.startsWith("./")) rel = rel.slice(2);
+  if (!rel || rel.split("/").includes("..")) {
+    throw new Error("Index path must be project-relative.");
+  }
+  return rel;
+}
+function chunkHash(body) {
+  return createHash2("sha256").update(body, "utf8").digest("hex");
+}
+function migrateChunkHash(db) {
+  const columns = db.prepare("PRAGMA table_info(chunks)").all();
+  if (!columns.some((column) => column.name === "chunk_hash")) {
+    db.exec(ADD_CHUNK_HASH_SQL);
+  }
+  const rows = db.prepare("SELECT id, body FROM chunks WHERE chunk_hash = ''").all();
+  const update = db.prepare("UPDATE chunks SET chunk_hash = ? WHERE id = ?");
+  for (const row of rows) update.run(chunkHash(row.body), row.id);
+}
+function openDb(projectRoot) {
+  const db = new Database2(indexDbPath(projectRoot));
+  db.exec(SEARCH_SCHEMA_SQL);
+  migrateChunkHash(db);
+  return db;
+}
+async function ensureDb(projectRoot) {
+  await ensureDir(sddRoot(projectRoot));
+  return openDb(projectRoot);
+}
+function deletePath(db, rel) {
+  forgetPath(db, rel);
+  const had = db.prepare("SELECT 1 AS n FROM files WHERE path = ?").get(rel);
+  if (vecReady(db)) {
+    const ids = db.prepare("SELECT id, scope FROM chunks WHERE path = ?").all(rel);
+    for (const row of ids) {
+      try {
+        db.prepare(`DELETE FROM ${vecTable(row.scope)} WHERE rowid = ?`).run(BigInt(row.id));
+      } catch {
+      }
+    }
+  }
+  db.prepare("DELETE FROM vec_meta WHERE chunk_id IN (SELECT id FROM chunks WHERE path = ?)").run(
+    rel
+  );
+  db.prepare(
+    `DELETE FROM chunks_fts WHERE rowid IN (
+      SELECT m.fts_rowid FROM chunks_fts_map AS m
+      JOIN chunks AS c ON c.id = m.chunk_id
+      WHERE c.path = ?
+    )`
+  ).run(rel);
+  db.prepare("DELETE FROM chunks WHERE path = ?").run(rel);
+  db.prepare("DELETE FROM files WHERE path = ?").run(rel);
+  return Boolean(had);
+}
+function writeChunks(db, rel, hash, scope, language, chunks) {
+  deletePath(db, rel);
+  if (!chunks.length) return [];
+  db.prepare("INSERT INTO files (path, content_hash, scope, language) VALUES (?, ?, ?, ?)").run(
+    rel,
+    hash,
+    scope,
+    language
+  );
+  const insertChunk = db.prepare(
+    `INSERT INTO chunks (path, scope, symbol, start_line, end_line, signature, body, chunk_hash)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertFts = db.prepare("INSERT INTO chunks_fts (symbol, body) VALUES (?, ?)");
+  const insertMap = db.prepare("INSERT INTO chunks_fts_map (chunk_id, fts_rowid) VALUES (?, ?)");
+  const inserted = [];
+  for (const chunk of chunks) {
+    const hashOfBody = chunkHash(chunk.body);
+    const info = insertChunk.run(
+      rel,
+      scope,
+      chunk.symbol,
+      chunk.startLine,
+      chunk.endLine,
+      chunk.signature,
+      chunk.body,
+      hashOfBody
+    );
+    const fts = insertFts.run(chunk.symbol, chunk.body);
+    const id = Number(info.lastInsertRowid);
+    insertMap.run(id, fts.lastInsertRowid);
+    inserted.push({ id, hash: hashOfBody, body: chunk.body, scope });
+  }
+  return inserted;
+}
+function mapHit(row) {
+  return {
+    scope: row.scope,
+    path: row.path,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    symbol: row.symbol,
+    score: row.score,
+    signature: row.signature,
+    body: row.body,
+    language: row.language,
+    rankedBy: "bm25"
+  };
+}
+var HIT_SQL = `c.path, c.scope, c.symbol, c.start_line, c.end_line, c.signature, c.body,
+       f.language AS language`;
+function queryRanked(db, query, scope, k) {
+  const tokens = ftsTokens(query);
+  if (!tokens.length || k < 1) return [];
+  const rows = db.prepare(
+    `SELECT ${HIT_SQL}, bm25(chunks_fts) AS score
+       FROM chunks_fts
+       JOIN chunks_fts_map AS m ON m.fts_rowid = chunks_fts.rowid
+       JOIN chunks AS c ON c.id = m.chunk_id
+       JOIN files AS f ON f.path = c.path
+       WHERE chunks_fts MATCH ? AND c.scope = ?
+       ORDER BY score ASC, c.path ASC, c.start_line ASC, c.symbol ASC
+       LIMIT ?`
+  ).all(tokens.join(" OR "), scope, k);
+  return rows.map(mapHit);
+}
+function queryScope(db, scope) {
+  const rows = db.prepare(
+    `SELECT ${HIT_SQL}, 0 AS score
+       FROM chunks AS c
+       JOIN files AS f ON f.path = c.path
+       WHERE c.scope = ?
+       ORDER BY c.path ASC, c.start_line ASC, c.symbol ASC`
+  ).all(scope);
+  return rows.map(mapHit);
+}
+async function walkFiles(projectRoot) {
+  const out = [];
+  async function walk(dir, rel) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (isPrunedDir(child)) continue;
+        await walk(join5(dir, entry.name), child);
+      } else if (entry.isFile()) {
+        out.push(child);
+      }
+    }
+  }
+  await walk(projectRoot, "");
+  return out;
+}
+async function chunksFor(bytes, rel, scope) {
+  const text = bytes.toString("utf8");
+  if (scope !== "code") {
+    return chunkMarkdown(text).map((chunk) => ({ ...chunk, language: "md" }));
+  }
+  const ext = extensionOf(rel);
+  const language = languageForExt(ext) ?? "js";
+  const parsed = await chunkCode(text, ext);
+  if (!parsed) return null;
+  return parsed.map((chunk) => ({ ...chunk, language: chunk.language || language }));
+}
+function metaNumber(db, key) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+  const n = Number(row?.value ?? "0");
+  return Number.isFinite(n) ? n : 0;
+}
+function metaString(db, key) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function writeMetaValue(db, key, value) {
+  db.prepare(
+    `INSERT INTO meta (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key, value);
+}
+function readStats(db) {
+  const files = db.prepare("SELECT COUNT(*) AS n FROM files").get();
+  const chunks = db.prepare("SELECT COUNT(*) AS n FROM chunks").get();
+  return {
+    provider: "builtin",
+    files: files.n,
+    chunks: chunks.n,
+    lastIndexFilesConsidered: metaNumber(db, "last_files_considered"),
+    lastIndexFilesReindexed: metaNumber(db, "last_files_reindexed"),
+    lastIndexChunksReindexed: metaNumber(db, "last_chunks_reindexed"),
+    lastIndexChunksEmbedded: metaNumber(db, "last_chunks_embedded"),
+    indexedCommit: metaString(db, "indexed_commit")
+  };
+}
+function writeCounts(db, considered, reindexed, chunks, embedded) {
+  writeMetaValue(db, "last_files_considered", String(considered));
+  writeMetaValue(db, "last_files_reindexed", String(reindexed));
+  writeMetaValue(db, "last_chunks_reindexed", String(chunks));
+  writeMetaValue(db, "last_chunks_embedded", String(embedded));
+}
+function isCommitSha(value) {
+  if (!value || value.length !== 40 && value.length !== 64) return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    const hex = code >= 48 && code <= 57 || code >= 97 && code <= 102 || code >= 65 && code <= 70;
+    if (!hex) return false;
+  }
+  return true;
+}
+async function safeHead(projectRoot) {
+  try {
+    return await getHeadSha(projectRoot);
+  } catch {
+    return null;
+  }
+}
+function gitOutput(cwd, args) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    let child;
+    try {
+      child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      finish(null);
+      return;
+    }
+    const parts = [];
+    child.stdout?.on("data", (chunk) => {
+      parts.push(chunk);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? Buffer.concat(parts) : null));
+  });
+}
+function splitNul(buf) {
+  const parts = [];
+  let start2 = 0;
+  for (let i = 0; i <= buf.length; i++) {
+    if (i === buf.length || buf[i] === 0) {
+      if (i > start2) parts.push(buf.subarray(start2, i).toString("utf8"));
+      start2 = i + 1;
+    }
+  }
+  return parts;
+}
+function normalizeGitPath(input) {
+  let rel = input.replaceAll("\\", "/");
+  while (rel.startsWith("./")) rel = rel.slice(2);
+  if (!rel || isAbsolute2(rel)) return null;
+  return rel;
+}
+function parseNameStatus(buf) {
+  const parts = splitNul(buf);
+  const candidates = [];
+  const deletions = [];
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const status = parts[i] ?? "";
+    const path = normalizeGitPath(parts[i + 1] ?? "");
+    if (!status || !path) continue;
+    if (status.charCodeAt(0) === 68) deletions.push(path);
+    else candidates.push(path);
+  }
+  return { candidates, deletions };
+}
+async function readGitDelta(projectRoot, cursor) {
+  const diff = await gitOutput(projectRoot, [
+    "diff",
+    "--name-status",
+    "-z",
+    "--no-renames",
+    cursor
+  ]);
+  const untracked = await gitOutput(projectRoot, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z"
+  ]);
+  if (!diff || !untracked) return null;
+  const parsed = parseNameStatus(diff);
+  for (const path of splitNul(untracked)) {
+    const rel = normalizeGitPath(path);
+    if (rel) parsed.candidates.push(rel);
+  }
+  return parsed;
+}
+async function prepareVectors(db, create) {
+  const present = vecTablesPresent(db);
+  if (!present && !create) return false;
+  const loaded = await ensureVecLoaded(db);
+  if (!loaded) return false;
+  if (create) createVecTables(db);
+  const model = metaString(db, "embedding_model");
+  if (create && model && model !== EMBEDDING_MODEL) {
+    dropVecTables(db);
+    db.prepare("DELETE FROM vec_meta").run();
+    db.prepare("DELETE FROM meta WHERE key = ?").run("embedding_model");
+    createVecTables(db);
+  }
+  return true;
+}
+async function embedBodies(db, embedder, pending, tally) {
+  for (let i = 0; i < pending.length; i += 16) {
+    const batch = pending.slice(i, i + 16);
+    tally.embedded += batch.length;
+    let vectors;
+    try {
+      vectors = await embedder.embedPassages(batch.map((item) => item.body));
+    } catch {
+      return false;
+    }
+    if (vectors.length !== batch.length || vectors.some((vector) => vector.length !== EMBEDDING_DIM)) {
+      return false;
+    }
+    const tx = db.transaction(() => {
+      for (let j = 0; j < batch.length; j++) {
+        const item = batch[j];
+        const vector = vectors[j];
+        if (!item || !vector) continue;
+        for (const id of item.ids) insertVector(db, item.scope, id, vector, item.hash);
+      }
+    });
+    tx();
+    tally.storedVector = true;
+  }
+  return true;
+}
+function queueBody(pending, row) {
+  const found = pending.find((item) => item.hash === row.hash);
+  if (found) found.ids.push(row.id);
+  else pending.push({ hash: row.hash, body: row.body, ids: [row.id], scope: row.scope });
+}
+async function embedInserted(db, embedder, inserted, copies, tally) {
+  const pending = [];
+  const tx = db.transaction(() => {
+    for (const row of inserted) {
+      const blob = copies.get(row.hash);
+      if (blob) {
+        insertVector(db, row.scope, row.id, blob, row.hash);
+        tally.storedVector = true;
+        continue;
+      }
+      queueBody(pending, row);
+    }
+  });
+  tx();
+  await embedBodies(db, embedder, pending, tally);
+}
+async function backfill(db, embedder, tally) {
+  const rows = db.prepare(
+    `SELECT c.id AS id, c.path AS path, c.body AS body, c.chunk_hash AS hash, c.scope AS scope
+       FROM chunks AS c
+       WHERE NOT EXISTS (
+         SELECT 1 FROM vec_meta AS m
+         WHERE m.chunk_id = c.id AND m.chunk_hash = c.chunk_hash
+       )
+       ORDER BY c.path ASC, c.start_line ASC, c.symbol ASC`
+  ).all();
+  let current = "";
+  let group = [];
+  const flush = async () => {
+    if (!group.length) return;
+    const pending = group;
+    group = [];
+    await embedBodies(db, embedder, pending, tally);
+  };
+  for (const row of rows) {
+    if (row.path !== current) {
+      await flush();
+      current = row.path;
+    }
+    const blob = readVectorBlob(db, row.hash);
+    if (blob) {
+      insertVector(db, row.scope, row.id, blob, row.hash);
+      tally.storedVector = true;
+      continue;
+    }
+    queueBody(group, row);
+  }
+  await flush();
+}
+function scopeVectorState(db, scope) {
+  const counts = db.prepare(
+    `SELECT
+         (SELECT COUNT(*) FROM chunks WHERE scope = ?) AS chunks,
+         (SELECT COUNT(*) FROM chunks AS c
+            JOIN vec_meta AS m ON m.chunk_id = c.id AND m.chunk_hash = c.chunk_hash
+            WHERE c.scope = ?) AS ready`
+  ).get(scope, scope);
+  if (counts.chunks === 0) return "empty";
+  const model = metaString(db, "embedding_model");
+  const modelOk = model === null || model === EMBEDDING_MODEL;
+  if (counts.ready === counts.chunks && modelOk) return "ready";
+  return "partial";
+}
+function createBuiltinProvider(projectRoot, config, runtime) {
+  const syncOne = async (db, rel, excluded, embedder, canVec, tally) => {
+    const abs = join5(projectRoot, rel);
+    const previous = db.prepare("SELECT content_hash FROM files WHERE path = ?").get(rel);
+    let bytes = null;
+    if (await pathExists(abs)) {
+      try {
+        bytes = await readFile3(abs);
+      } catch {
+        bytes = null;
+      }
+    }
+    const drop = () => {
+      if (!previous) return "unchanged";
+      deletePath(db, rel);
+      return "deleted";
+    };
+    if (!bytes || excluded(rel)) return drop();
+    const scope = scopeForPath(rel, config);
+    if (!scope) return drop();
+    const hash = createHash2("sha256").update(bytes).digest("hex");
+    if (previous?.content_hash === hash) return "unchanged";
+    const chunks = await chunksFor(bytes, rel, scope);
+    if (!chunks) return drop();
+    if (!chunks.length && !previous) return "unchanged";
+    const language = chunks[0]?.language ?? (scope === "code" ? "js" : "md");
+    const copies = /* @__PURE__ */ new Map();
+    if (canVec && embedder) {
+      const hashes = new Set(chunks.map((chunk) => chunkHash(chunk.body)));
+      for (const bodyHash of hashes) {
+        const blob = readVectorBlob(db, bodyHash);
+        if (blob) copies.set(bodyHash, blob);
+      }
+    }
+    const inserted = db.transaction(() => writeChunks(db, rel, hash, scope, language, chunks))();
+    tally.chunks += inserted.length;
+    if (canVec && embedder && inserted.length) {
+      await embedInserted(db, embedder, inserted, copies, tally);
+    }
+    return "rewritten";
+  };
+  return {
+    id: "builtin",
+    async index(changed) {
+      const rels = changed?.map((entry) => assertRepoRelative(entry));
+      const search = await loadSearchConfig(projectRoot);
+      const embedder = await resolveEmbedder(projectRoot, search.embeddings, runtime);
+      const db = await ensureDb(projectRoot);
+      try {
+        const filter = await loadExcluder(projectRoot, search.exclude);
+        const canVec = await prepareVectors(db, search.embeddings && embedder !== null);
+        const tally = { chunks: 0, embedded: 0, storedVector: false };
+        let considered = 0;
+        let reindexed = 0;
+        const note = (action) => {
+          considered += 1;
+          if (action !== "unchanged") reindexed += 1;
+        };
+        const runSync = (rel) => syncOne(db, rel, filter, embedder, canVec, tally);
+        if (rels) {
+          for (const rel of rels) note(await runSync(rel));
+        } else {
+          const head = await safeHead(projectRoot);
+          const cursor = metaString(db, "indexed_commit");
+          const delta = head && isCommitSha(cursor) ? await readGitDelta(projectRoot, cursor.toLowerCase()) : null;
+          if (delta) {
+            const deletions = new Set(delta.deletions);
+            const seen = /* @__PURE__ */ new Set();
+            for (const rel of delta.candidates) {
+              if (deletions.has(rel) || seen.has(rel)) continue;
+              seen.add(rel);
+              note(await runSync(rel));
+            }
+            for (const rel of deletions) {
+              if (deletePath(db, rel)) reindexed += 1;
+            }
+            const stored = db.prepare("SELECT path FROM files").all();
+            for (const row of stored) {
+              const exists = await pathExists(join5(projectRoot, row.path));
+              if (exists && !filter(row.path) && scopeForPath(row.path, config)) continue;
+              deletePath(db, row.path);
+              considered += 1;
+              reindexed += 1;
+            }
+          } else {
+            const desired = /* @__PURE__ */ new Set();
+            for (const rel of await walkFiles(projectRoot)) {
+              if (filter(rel) || !scopeForPath(rel, config)) continue;
+              desired.add(rel);
+              note(await runSync(rel));
+            }
+            const stored = db.prepare("SELECT path FROM files").all();
+            const tx = db.transaction(() => {
+              for (const row of stored) {
+                if (desired.has(row.path)) continue;
+                deletePath(db, row.path);
+                reindexed += 1;
+              }
+            });
+            tx();
+          }
+          if (search.embeddings && embedder && canVec) await backfill(db, embedder, tally);
+          if (head) writeMetaValue(db, "indexed_commit", head);
+        }
+        writeCounts(db, considered, reindexed, tally.chunks, tally.embedded);
+        if (tally.storedVector) writeMetaValue(db, "embedding_model", EMBEDDING_MODEL);
+        return readStats(db);
+      } finally {
+        db.close();
+      }
+    },
+    async search(query, options) {
+      return searchProject(projectRoot, query, options, runtime);
+    },
+    async stats() {
+      if (!await pathExists(indexDbPath(projectRoot))) return { ...EMPTY_STATS };
+      const db = openDb(projectRoot);
+      try {
+        return readStats(db);
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+async function keywordHits(projectRoot, query, scope, k) {
+  if (!await pathExists(indexDbPath(projectRoot))) return [];
+  const db = openDb(projectRoot);
+  try {
+    return queryRanked(db, query, scope, k);
+  } finally {
+    db.close();
+  }
+}
+async function listScopeHits(projectRoot, scope) {
+  if (!await pathExists(indexDbPath(projectRoot))) return [];
+  const db = openDb(projectRoot);
+  try {
+    return queryScope(db, scope);
+  } finally {
+    db.close();
+  }
+}
+async function rankScope(projectRoot, query, scope, k, session) {
+  const keyword = async () => keywordHits(projectRoot, query, scope, k);
+  if (!session.embeddings) return { hits: await keyword(), warning: false, hybrid: false };
+  if (!await pathExists(indexDbPath(projectRoot))) {
+    return { hits: [], warning: session.failure === "query", hybrid: false };
+  }
+  const db = openDb(projectRoot);
+  try {
+    const state2 = scopeVectorState(db, scope);
+    const warn = session.failure === "query" || state2 !== "empty" && (session.failure === "load" || state2 === "partial" || !session.queryVec);
+    if (session.failure !== "none" || state2 !== "ready" || !session.queryVec) {
+      return { hits: queryRanked(db, query, scope, k), warning: warn, hybrid: false };
+    }
+    const loaded = await ensureVecLoaded(db);
+    if (!loaded) return { hits: queryRanked(db, query, scope, k), warning: true, hybrid: false };
+    try {
+      const keywordRows = queryRanked(db, query, scope, k);
+      const vectorRows = queryVectors(db, scope, session.queryVec, k).map(
+        (row) => mapHit({ ...row, score: row.distance })
+      );
+      return { hits: fuseHits(keywordRows, vectorRows), warning: false, hybrid: true };
+    } catch {
+      return { hits: queryRanked(db, query, scope, k), warning: true, hybrid: false };
+    }
+  } finally {
+    db.close();
+  }
+}
+async function searchProject(projectRoot, query, options, runtime) {
+  const search = await loadSearchConfig(projectRoot);
+  const config = await loadConfig(projectRoot);
+  const activeChange = await resolveActiveDirectory(projectRoot, config);
+  const request = {
+    projectRoot,
+    query,
+    channel: "search",
+    scope: options.scope,
+    k: options.k,
+    budget: options.budget,
+    embeddings: search.embeddings,
+    activeChange,
+    scopes: [options.scope]
+  };
+  try {
+    const cached = readPackedCache(request);
+    if (cached) {
+      return {
+        provider: "builtin",
+        warning: cached.warning,
+        query,
+        scope: options.scope,
+        budget: options.budget,
+        usedTokens: countTokens(cached.text),
+        hits: cached.hits,
+        text: cached.text
+      };
+    }
+  } catch {
+  }
+  const embedder = await resolveEmbedder(projectRoot, search.embeddings, runtime);
+  const embedded = await embedSearchQuery(embedder, search.embeddings, query);
+  const ranked = await rankScope(projectRoot, query, options.scope, options.k, {
+    embeddings: search.embeddings,
+    queryVec: embedded.queryVec,
+    failure: embedded.failure
+  });
+  const preamble = options.preamble ?? searchPreamble(query, options.scope, options.budget, ranked.hybrid);
+  let hits = ranked.hits;
+  try {
+    hits = attachSummaries(projectRoot, ranked.hits, activeChange);
+  } catch {
+    hits = ranked.hits;
+  }
+  const packed = packHits({ preamble, hits, budget: options.budget });
+  const mode = ranked.hits.some((hit) => hit.rankedBy === "rrf") ? "rrf" : "bm25";
+  try {
+    writePackedCache(request, packed, ranked.hits, mode, ranked.hybrid ? options.scope : "");
+  } catch {
+  }
+  return {
+    provider: "builtin",
+    warning: ranked.warning ? EMBEDDINGS_UNAVAILABLE : void 0,
+    query,
+    scope: options.scope,
+    budget: options.budget,
+    usedTokens: packed.usedTokens,
+    hits: packed.hits,
+    text: packed.text
+  };
+}
+
+// src/search/registry.ts
+var extra = /* @__PURE__ */ new Map();
+function registerSearchProvider(provider) {
+  extra.set(provider.id, provider);
+}
+function clearRegisteredSearchProviders() {
+  extra.clear();
+}
+function fallbackWarning(name) {
+  return `Search provider "${name}" is unavailable. Using built-in keyword search.`;
+}
+function joinWarning(left, right) {
+  if (left && right) return `${left}
+${right}`;
+  return left || right;
+}
+function resolveSearchProvider(projectRoot, config, search, runtime) {
+  const builtin = createBuiltinProvider(projectRoot, config, runtime);
+  const name = search.provider || "builtin";
+  if (name === "builtin") return builtin;
+  const registered = extra.get(name);
+  let active = registered ?? builtin;
+  let warning = registered ? void 0 : fallbackWarning(name);
+  const mark = () => {
+    warning = fallbackWarning(name);
+    active = builtin;
+  };
+  return {
+    id: active.id,
+    async index(changed) {
+      try {
+        return await active.index(changed);
+      } catch (err) {
+        if (active.id === "builtin") throw err;
+        mark();
+        return builtin.index(changed);
+      }
+    },
+    async search(query, options) {
+      try {
+        const result = await active.search(query, options);
+        result.warning = joinWarning(warning, result.warning);
+        result.provider = "builtin";
+        return result;
+      } catch (err) {
+        if (active.id === "builtin") throw err;
+        mark();
+        await builtin.index();
+        const result = await builtin.search(query, options);
+        result.warning = joinWarning(warning, result.warning);
+        result.provider = "builtin";
+        return result;
+      }
+    },
+    stats() {
+      return active.stats();
+    }
+  };
+}
+function safeMessage(err, projectRoot) {
+  const raw = err instanceof Error ? err.message : "Search failed.";
+  if (!raw) return "Search failed.";
+  if (!projectRoot || !raw.includes(projectRoot)) return raw;
+  return raw.split(projectRoot).join("") || "Search failed.";
+}
+async function buildRetrievedInner(projectRoot, config, title, stage, budget, runtime, activeChange = "") {
+  let search;
+  try {
+    search = await loadSearchConfig(projectRoot);
+  } catch (err) {
+    return `Retrieved context skipped: ${safeMessage(err, projectRoot)}.`;
+  }
+  const limit = budget ?? budgetForStage(search, stage);
+  const provider = resolveSearchProvider(projectRoot, config, search, runtime);
+  try {
+    await provider.index();
+  } catch (err) {
+    const message = provider.id === "builtin" ? safeMessage(err, projectRoot) : fallbackWarning(search.provider);
+    return `Retrieved context skipped: ${message}.`;
+  }
+  const request = {
+    projectRoot,
+    query: title,
+    channel: "handoff",
+    scope: "merged",
+    k: search.k,
+    budget: limit,
+    embeddings: search.embeddings,
+    activeChange,
+    scopes: ["specs", "memory", "code"]
+  };
+  try {
+    const cached = readPackedCache(request);
+    if (cached) return cached.text;
+  } catch {
+  }
+  try {
+    const embedder = await resolveEmbedder(projectRoot, search.embeddings, runtime);
+    const embedded = await embedSearchQuery(embedder, search.embeddings, title);
+    const hits = [];
+    const hybridScopes = [];
+    for (const scope of ["specs", "memory", "code"]) {
+      const ranked = await rankScope(projectRoot, title, scope, search.k, {
+        embeddings: search.embeddings,
+        queryVec: embedded.queryVec,
+        failure: embedded.failure
+      });
+      if (ranked.hybrid) hybridScopes.push(scope);
+      hits.push(...ranked.hits);
+    }
+    const merged = mergeRankedHits(hits);
+    let prepared = merged;
+    try {
+      prepared = attachSummaries(projectRoot, merged, activeChange);
+    } catch {
+      prepared = merged;
+    }
+    const packed = packHits({ preamble: "", hits: prepared, budget: limit });
+    const mode = merged.some((hit) => hit.rankedBy === "rrf") ? "rrf" : "bm25";
+    try {
+      writePackedCache(request, packed, merged, mode, hybridScopes.join(","));
+    } catch {
+    }
+    return packed.text;
+  } catch (err) {
+    const message = search.provider === "builtin" ? safeMessage(err, projectRoot) : fallbackWarning(search.provider);
+    return `Retrieved context skipped: ${message}.`;
+  }
+}
+async function executeSearch(projectRoot, config, query, scope, budget) {
+  const search = await loadSearchConfig(projectRoot);
+  const provider = resolveSearchProvider(projectRoot, config, search);
+  await provider.index();
+  const options = {
+    scope,
+    k: search.k,
+    budget: budget ?? search.budgets.default
+  };
+  return provider.search(query, options);
+}
+
+// src/role/models/schema.ts
+import { join as join6 } from "pathe";
+import { parse as parseYaml } from "yaml";
+import { z as z2 } from "zod";
+var idSchema = z2.string().trim().min(1);
+var envName = z2.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var confidence = z2.number().gte(0).lte(1);
+var WorkTypeSchema = z2.enum(WORK_TYPES);
+var workSlots = z2.record(WorkTypeSchema, idSchema);
+var ModelEntrySchema = z2.discriminatedUnion("provider", [
+  z2.object({
+    kind: z2.literal("decide"),
+    provider: z2.literal("rules")
+  }).strict(),
+  z2.object({
+    kind: z2.enum(["decide", "reason"]),
+    provider: z2.literal("command"),
+    command_env: envName,
+    min_confidence: confidence.optional()
+  }).strict(),
+  z2.object({
+    kind: z2.literal("decide"),
+    provider: z2.literal("ollama"),
+    model: z2.string().trim().min(1),
+    base_url_env: envName,
+    min_confidence: confidence.optional()
+  }).strict()
+]);
+var ModelsConfigSchema = z2.object({
+  version: z2.literal(1),
+  models: z2.record(idSchema, ModelEntrySchema),
+  defaults: z2.object({
+    by_work_type: workSlots,
+    fallback_reason: idSchema,
+    fallback_decide: idSchema
+  }).strict(),
+  overrides: z2.object({
+    bots: z2.record(idSchema, workSlots).optional(),
+    stages: z2.record(idSchema, workSlots).optional(),
+    roles: z2.record(idSchema, workSlots).optional()
+  }).strict().optional()
+}).strict().superRefine((config, ctx) => {
+  if (Object.keys(config.models).length === 0) {
+    ctx.addIssue({ code: "custom", path: ["models"], message: "needs a model" });
+  }
+  expectSlot(ctx, config.models, config.defaults.fallback_reason, "reason", [
+    "defaults",
+    "fallback_reason"
+  ]);
+  expectSlot(ctx, config.models, config.defaults.fallback_decide, "decide", [
+    "defaults",
+    "fallback_decide"
+  ]);
+  expectMap(ctx, config.models, config.defaults.by_work_type, ["defaults", "by_work_type"]);
+  expectNamed(ctx, config.models, config.overrides?.bots, ["overrides", "bots"]);
+  expectNamed(ctx, config.models, config.overrides?.stages, ["overrides", "stages"]);
+  expectNamed(ctx, config.models, config.overrides?.roles, ["overrides", "roles"]);
+});
+var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S+$/;
+function expectSlot(ctx, models, id, kind, path) {
+  if (!id) return;
+  const model = models[id];
+  if (!model) {
+    ctx.addIssue({ code: "custom", path, message: "unknown model" });
+    return;
+  }
+  if (model.kind !== kind) {
+    ctx.addIssue({ code: "custom", path, message: `kind must be ${kind}` });
+  }
+}
+function expectMap(ctx, models, map, path) {
+  if (!map) return;
+  for (const [work, id] of Object.entries(map)) {
+    if (!isWorkType(work)) continue;
+    expectSlot(ctx, models, id, workKind(work), [...path, work]);
+  }
+}
+function expectNamed(ctx, models, named, path) {
+  if (!named) return;
+  for (const [name, map] of Object.entries(named)) {
+    expectMap(ctx, models, map, [...path, name]);
+  }
+}
+function formatModelsError(error) {
+  const issue = error.issues[0];
+  const path = issue?.path.join(".") || "models";
+  const message = issue?.message ?? "invalid";
+  return `models.yaml is invalid: ${path} ${message}`;
+}
+function looksSecret(value) {
+  if (value.includes("-----BEGIN")) return true;
+  if (!/\s/.test(value) && ASSIGNMENT.test(value)) return true;
+  if (!/\s/.test(value) && value.length >= 32 && !ENV_NAME.test(value)) return true;
+  return false;
+}
+function containsSecret(value) {
+  if (typeof value === "string") return looksSecret(value);
+  if (Array.isArray(value)) return value.some(containsSecret);
+  if (value && typeof value === "object") {
+    return Object.entries(value).some(([key, entry]) => {
+      if (key === "model" && typeof entry === "string") {
+        if (entry.includes("-----BEGIN")) return true;
+        if (!/\s/.test(entry) && ASSIGNMENT.test(entry)) return true;
+        return false;
+      }
+      return containsSecret(entry);
+    });
+  }
+  return false;
+}
+function modelsPath(root) {
+  return join6(root, ".sdd", "models.yaml");
+}
+async function loadModels(root) {
+  const path = modelsPath(root);
+  if (!await pathExists(path)) return null;
+  let raw;
+  try {
+    raw = parseYaml(await readText(path));
+  } catch {
+    return { error: "models.yaml is invalid: models could not be parsed" };
+  }
+  if (containsSecret(raw)) return { error: "models.yaml has a secret value." };
+  const parsed = ModelsConfigSchema.safeParse(raw);
+  if (!parsed.success) return { error: formatModelsError(parsed.error) };
+  return { config: parsed.data };
+}
+async function checkModels(root) {
+  const loaded = await loadModels(root);
+  if (loaded === null) return { ok: true };
+  if ("error" in loaded) return { ok: false, message: loaded.error };
+  return { ok: true };
+}
+
+// src/role/profile.ts
+import { readFile as readFile4, writeFile } from "fs/promises";
+import { join as join7 } from "pathe";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+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 join7(root, ".sdd", "roles", `${name}.md`);
+}
+function conversationDir(root, name) {
+  return join7(root, ".sdd", "role-runs", "conversation", name);
+}
+function memoryDir(root, name, team = false) {
+  if (team) return join7(root, ".sdd", "agents", name);
+  return join7(root, ".sdd", "role-runs", "memory", name);
+}
+function allowFilePath(root) {
+  return join7(root, ".sdd", "role-runs", "allow.json");
+}
+function ok(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail(stdout) {
+  return { exitCode: 1, stdout };
+}
+function asText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+var LIST_FIELDS = [
+  ["owns", "owns"],
+  ["inputs", "inputs"],
+  ["outputs", "outputs"],
+  ["collaborates", "collaborates"],
+  ["reviews", "reviews"],
+  ["approvers", "approvers"],
+  ["never", "never"],
+  ["askHumanWhen", "ask_human_when"],
+  ["skills", "skills"],
+  ["rules", "rules"],
+  ["goals", "goals"]
+];
+function stringList(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !item.trim()) return null;
+    out.push(item.trim());
+  }
+  return out;
+}
+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;
+  try {
+    data = parseYaml2(rest.slice(0, close.index));
+  } catch {
+    return null;
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  const rec = data;
+  const lists = emptyRoleLists();
+  for (const [field2, key] of LIST_FIELDS) {
+    const parsed = stringList(rec[key]);
+    if (!parsed) return null;
+    lists[field2] = parsed;
+  }
+  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,
+    ...lists
+  };
+}
+function renderRole(role) {
+  const record = {
+    name: role.name,
+    label: role.label,
+    job: role.job,
+    ask_first: role.askFirst,
+    pinned: role.pinned,
+    hidden: role.hidden
+  };
+  for (const [field2, key] of LIST_FIELDS) {
+    if (role[field2].length > 0) record[key] = role[field2];
+  }
+  const front = stringifyYaml(record, { 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;
+  try {
+    return parseRoleDocument(canonical, await readText(path));
+  } catch {
+    return null;
+  }
+}
+async function writeRole(root, role) {
+  await writeText(roleFilePath(root, role.name), renderRole(role));
+}
+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);
+  const lists = emptyRoleLists();
+  for (const [field2] of LIST_FIELDS) {
+    lists[field2] = input[field2] ?? [];
+  }
+  await writeRole(root, {
+    name,
+    label: input.label.trim(),
+    job,
+    description: (input.description ?? "").trim(),
+    askFirst: input.askFirst === true,
+    pinned: false,
+    hidden: false,
+    ...lists
+  });
+  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 = join7(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 removeBotBrain(root, name);
+  await removePath(memoryDir(root, name));
+  await removeAllowKey(root, name);
+  return ok();
+}
+async function removeBotBrain(root, roleName) {
+  const teamPath = join7(root, ".sdd", "team.yaml");
+  if (!await pathExists(teamPath)) return;
+  let raw;
+  try {
+    raw = parseYaml2(await readText(teamPath));
+  } catch {
+    return;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+  const bots = raw.bots;
+  if (!Array.isArray(bots)) return;
+  for (const bot of bots) {
+    if (!bot || typeof bot !== "object" || Array.isArray(bot)) continue;
+    const rec = bot;
+    const botName = typeof rec.name === "string" ? rec.name : "";
+    const botRole = typeof rec.role === "string" ? rec.role : "";
+    if (botName !== roleName && botRole !== roleName) continue;
+    if (!canonicalRoleName(botName)) continue;
+    const dir = memoryDir(root, botName, true);
+    await removePath(join7(dir, "memory.md"));
+    await removePath(join7(dir, "lessons.jsonl"));
+  }
+}
+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;
+  }
+  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");
+}
+async function listConversationRoles(root) {
+  return listDirs(join7(root, ".sdd", "role-runs", "conversation"));
+}
+async function readAllowFile(root) {
+  const path = allowFilePath(root);
+  if (!await pathExists(path)) return null;
+  try {
+    const data = JSON.parse(await readFile4(path, "utf8"));
+    if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+// src/role/schema.ts
+import { z as z3 } from "zod";
+var nameSchema = z3.string().trim().min(1);
+var botSchema = z3.object({
+  name: nameSchema,
+  role: nameSchema,
+  wip: z3.number().int().positive()
+}).strict();
+var humanSchema = z3.object({
+  name: nameSchema
+}).strict();
+var TeamSchema = z3.object({
+  template: nameSchema.optional(),
+  branch: z3.string().trim().min(1),
+  rooms: z3.object({
+    commit: z3.boolean()
+  }).strict(),
+  bots: z3.array(botSchema).min(1),
+  humans: z3.array(humanSchema).default([]),
+  role_wip: z3.record(z3.string().trim().min(1), z3.number().int().positive()).optional(),
+  limits: z3.object({
+    loop_max_steps: z3.number().int().positive().optional(),
+    room_rounds: z3.number().int().positive().optional()
+  }).strict().refine((limits) => limits.loop_max_steps !== void 0 || limits.room_rounds !== void 0, {
+    message: "needs a limit"
+  }).optional()
+}).strict().superRefine((team, ctx) => {
+  if (!team.branch.includes("{bot}")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["branch"],
+      message: "must include {bot}"
+    });
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const [index, bot] of team.bots.entries()) {
+    if (names.has(bot.name)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["bots", index, "name"],
+        message: "bot name is repeated"
+      });
+    }
+    names.add(bot.name);
+  }
+});
+function formatTeamError(error) {
+  const issue = error.issues[0];
+  const path = issue?.path.join(".") || "team";
+  const message = issue?.message ?? "invalid";
+  return `team.yaml is invalid: ${path} ${message}`;
+}
+
+// src/role/team.ts
+import { spawnSync } from "child_process";
+import { join as join8 } from "pathe";
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+function ok2(stdout = "") {
+  return { exitCode: 0, stdout };
+}
+function fail2(stdout) {
+  return { exitCode: 1, stdout };
+}
+function gitUserName(root) {
+  const result = spawnSync("git", ["-C", root, "config", "user.name"], { encoding: "utf8" });
+  if (result.status !== 0) return null;
+  const name = result.stdout.trim();
+  return name || null;
+}
+async function listTeamTemplates() {
+  return (await listDirs(defaultTeamsDir())).sort();
+}
+async function templateRoleFiles(template) {
+  const dir = join8(defaultTeamsDir(), template, "roles");
+  if (!await pathExists(dir)) return null;
+  const files = (await listFiles(dir)).filter((file) => file.endsWith(".md")).sort();
+  const roles = [];
+  for (const file of files) {
+    roles.push({ name: file.slice(0, -".md".length), raw: await readText(join8(dir, file)) });
+  }
+  return roles;
+}
+async function listRoleTemplates() {
+  const ids = [];
+  for (const template of await listTeamTemplates()) {
+    const roles = await templateRoleFiles(template);
+    if (!roles) continue;
+    for (const role of roles) ids.push(`${template}/${role.name}`);
+  }
+  return ids;
+}
+async function loadTemplateTeam(template) {
+  const path = join8(defaultTeamsDir(), template, "team.yaml");
+  if (!await pathExists(path)) return `Team template "${template}" was not found.`;
+  let raw;
+  try {
+    raw = parseYaml3(await readText(path));
+  } catch {
+    return `Team template "${template}" is invalid.`;
+  }
+  const parsed = TeamSchema.safeParse(raw);
+  if (!parsed.success) return `Team template "${template}" is invalid.`;
+  return parsed.data;
+}
+function availableTeams(names) {
+  return names.join(", ") || "(none)";
+}
+async function initTeam(root, template, gitUser) {
+  const templates = await listTeamTemplates();
+  if (!template.trim()) {
+    return fail2(`Pass --template. Available: ${availableTeams(templates)}.`);
+  }
+  if (!templates.includes(template)) {
+    return fail2(
+      `Team template "${template}" was not found. Available: ${availableTeams(templates)}.`
+    );
+  }
+  const loaded = await loadTemplateTeam(template);
+  if (typeof loaded === "string") return fail2(loaded);
+  const roles = await templateRoleFiles(template);
+  if (!roles || roles.length === 0) return fail2(`Team template "${template}" is invalid.`);
+  for (const role of roles) {
+    const parsed = parseRoleDocument(role.name, role.raw);
+    if (!parsed || !parsed.job) return fail2(`Team template "${template}" is invalid.`);
+  }
+  const botRoles = new Set(loaded.bots.map((bot) => bot.role));
+  for (const roleName of botRoles) {
+    if (!roles.some((role) => role.name === roleName)) {
+      return fail2(`Team template "${template}" is invalid.`);
+    }
+  }
+  const teamPath = join8(root, ".sdd", "team.yaml");
+  if (await pathExists(teamPath)) {
+    return fail2("Team config already exists at .sdd/team.yaml. Nothing was written.");
+  }
+  const routingSrc = join8(defaultTeamsDir(), template, "routing.yaml");
+  const routingDest = join8(root, ".sdd", "routing.yaml");
+  const copyRouting = await pathExists(routingSrc);
+  if (copyRouting && await pathExists(routingDest)) {
+    return fail2("Routing config already exists at .sdd/routing.yaml. Nothing was written.");
+  }
+  const existing = [];
+  for (const role of roles) {
+    if (await pathExists(roleFilePath(root, role.name))) existing.push(role.name);
+  }
+  if (existing.length > 0) {
+    return fail2(`Role already exists: ${existing.join(", ")}. Nothing was written.`);
+  }
+  const humans = loaded.humans.length > 0 ? loaded.humans : gitUser ? [{ name: gitUser }] : [];
+  const team = { ...loaded, template, humans };
+  const checked = TeamSchema.safeParse(team);
+  if (!checked.success) return fail2(formatTeamError(checked.error));
+  for (const role of roles) {
+    await writeText(join8(root, ".sdd", "roles", `${role.name}.md`), role.raw);
+  }
+  await writeText(teamPath, stringifyYaml2(checked.data, { lineWidth: 100 }));
+  if (copyRouting) await writeText(routingDest, await readText(routingSrc));
+  await syncRoomIgnore(root, checked.data);
+  return ok2(`Wrote .sdd/team.yaml from ${template}.`);
+}
+async function readTeamConfig(root) {
+  const path = join8(root, ".sdd", "team.yaml");
+  if (!await pathExists(path)) {
+    return { error: "No team config. Run sdd team init --template software." };
+  }
+  let raw;
+  try {
+    raw = parseYaml3(await readText(path));
+  } catch {
+    return { error: "team.yaml is invalid: team could not be parsed" };
+  }
+  const parsed = TeamSchema.safeParse(raw);
+  if (!parsed.success) return { error: formatTeamError(parsed.error) };
+  await syncRoomIgnore(root, parsed.data);
+  return { team: parsed.data };
+}
+function formatTeam(team, gitUser) {
+  const lines = [
+    `template: ${team.template ?? ""}`,
+    `branch: ${team.branch}`,
+    `rooms.commit: ${team.rooms.commit}`,
+    "bots:"
+  ];
+  for (const bot of team.bots) {
+    lines.push(`- ${bot.name} role ${bot.role} wip ${bot.wip}`);
+  }
+  lines.push("humans:");
+  if (team.humans.length === 0) lines.push("- (none)");
+  for (const human of team.humans) {
+    const you = gitUser !== null && human.name === gitUser ? " (you)" : "";
+    lines.push(`- ${human.name}${you}`);
+  }
+  if (team.role_wip && Object.keys(team.role_wip).length > 0) {
+    lines.push("role_wip:");
+    for (const name of Object.keys(team.role_wip).sort()) {
+      lines.push(`- ${name} ${team.role_wip[name]}`);
+    }
+  }
+  if (team.limits?.loop_max_steps) {
+    lines.push(`limits.loop_max_steps: ${team.limits.loop_max_steps}`);
+  }
+  if (team.limits?.room_rounds) {
+    lines.push(`limits.room_rounds: ${team.limits.room_rounds}`);
+  }
+  return lines.join("\n");
+}
+async function syncRoomIgnore(root, team) {
+  const file = join8(root, ".sdd", ".gitignore");
+  const existed = await pathExists(file);
+  const original = existed ? await readText(file) : "";
+  const lines = original.split(/\r?\n/);
+  if (!team.rooms.commit) {
+    if (lines.some((line) => line.trim() === "rooms/")) return;
+    const next = original.length > 0 && !original.endsWith("\n") ? `${original}
+` : original;
+    await writeText(file, `${next}rooms/
+`);
+    return;
+  }
+  if (!existed) return;
+  const kept = lines.filter((line) => line.trim() !== "rooms/");
+  if (kept.length === lines.length) return;
+  const body = kept.join("\n");
+  await writeText(file, body.length > 0 && !body.endsWith("\n") ? `${body}
+` : body);
+}
+function resolveBot(team, name) {
+  const byName = team.bots.find((bot) => bot.name === name);
+  if (byName) return byName;
+  const byRole = team.bots.filter((bot) => bot.role === name);
+  if (byRole.length === 1) return byRole[0];
+  if (byRole.length > 1) return { error: "Name the bot." };
+  return { error: "Bot not found." };
+}
+async function showTeam(root, gitUser) {
+  const loaded = await readTeamConfig(root);
+  if ("error" in loaded) return fail2(loaded.error);
+  return ok2(formatTeam(loaded.team, gitUser));
+}
+async function checkTeam(root) {
+  const loaded = await readTeamConfig(root);
+  if ("error" in loaded) return fail2(loaded.error);
+  const models = await checkModels(root);
+  if (!models.ok) return fail2(models.message);
+  return ok2("Team config is valid.");
+}
+async function resolveRoleTemplate(template) {
+  const ids = await listRoleTemplates();
+  const trimmed = template.trim();
+  if (!trimmed) {
+    return { error: `Pass --template. Available: ${ids.join(", ") || "(none)"}.` };
+  }
+  if (ids.includes(trimmed)) {
+    const [team, role] = trimmed.split("/");
+    const roles = await templateRoleFiles(team);
+    const found = roles?.find((item) => item.name === role);
+    if (!found) return { error: `Role template "${trimmed}" was not found.` };
+    return { id: trimmed, raw: found.raw };
+  }
+  const matches = ids.filter((id) => id.endsWith(`/${trimmed}`));
+  if (matches.length === 1) {
+    const resolved = await resolveRoleTemplate(matches[0]);
+    return resolved;
+  }
+  if (matches.length > 1) {
+    return {
+      error: `Role template "${trimmed}" matches ${matches.join(" and ")}. Pass one of those.`
+    };
+  }
+  return { error: `Role template "${trimmed}" was not found. Available: ${ids.join(", ")}.` };
+}
+async function createRoleFromTemplate(root, input) {
+  const resolved = await resolveRoleTemplate(input.template);
+  if ("error" in resolved) return fail2(resolved.error);
+  const parsed = parseRoleDocument(input.name, resolved.raw);
+  if (!parsed || !parsed.job) return fail2(`Role template "${resolved.id}" is invalid.`);
+  return createRole(root, {
+    name: input.name,
+    label: input.label?.trim() || parsed.label,
+    job: input.job?.trim() || parsed.job,
+    description: input.description?.trim() || parsed.description,
+    askFirst: parsed.askFirst,
+    owns: parsed.owns,
+    inputs: parsed.inputs,
+    outputs: parsed.outputs,
+    collaborates: parsed.collaborates,
+    reviews: parsed.reviews,
+    approvers: parsed.approvers,
+    never: parsed.never,
+    askHumanWhen: parsed.askHumanWhen,
+    skills: parsed.skills,
+    rules: parsed.rules,
+    goals: parsed.goals
+  });
+}
+
+// src/agent-handoff.ts
+function formatStatus(ctx) {
+  const lines = [];
+  lines.push(`Change: ${ctx.meta.title}`);
+  lines.push(`ID:     ${ctx.id}`);
+  lines.push(`Status: ${ctx.meta.status}`);
+  lines.push(`Workflow: ${ctx.meta.workflow}`);
+  lines.push(`Path: ${ctx.displayPath}`);
+  if (ctx.meta.epic) lines.push(`Epic: ${ctx.meta.epic}`);
+  if (ctx.meta.story) {
+    const depends = ctx.meta.depends?.length ? ctx.meta.depends.join(", ") : "none";
+    lines.push(`Story: ${ctx.meta.story}`);
+    lines.push(`Depends: ${depends}`);
+  }
+  lines.push("");
+  lines.push("Stages:");
+  for (const stage of ctx.stages) {
+    const skipped = isStageSkipped(ctx.meta, stage.id) || shouldAutoSkip(stage, ctx.meta);
+    let mark = " ";
+    if (skipped) mark = "\xB7";
+    else if (stage.id === ctx.meta.stage) mark = "\u25CF";
+    else {
+      const order = ctx.active.map((s) => s.id);
+      const cur = order.indexOf(ctx.meta.stage);
+      const idx = order.indexOf(stage.id);
+      if (idx >= 0 && cur >= 0 && idx < cur) mark = "\u2713";
+    }
+    const gate = ctx.meta.gates?.[stage.id];
+    const gateInfo = gate ? ` [${gate.status}]` : "";
+    const skipInfo = skipped ? " (skipped)" : "";
+    lines.push(
+      `  [${mark}] ${stage.id}${stage.title ? ` \u2014 ${stage.title}` : ""}${gateInfo}${skipInfo}`
+    );
+  }
+  if (ctx.meta.overrides?.skip_stages?.length) {
+    lines.push("");
+    lines.push(`Overrides: skip=${ctx.meta.overrides.skip_stages.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+async function buildAgentPrompt(ctx, config, projectRoot, budget, runtime) {
+  const stage = getStage(ctx.workflow, ctx.meta, ctx.meta.stage);
+  const parts = [];
+  parts.push(`# SDD Agent Handoff`);
+  parts.push("");
+  parts.push(`You are implementing a change under Structured Vibe Coding (local SDD).`);
+  parts.push("");
+  parts.push(`## Change`);
+  parts.push(`- Title: ${ctx.meta.title}`);
+  parts.push(`- ID: ${ctx.id}`);
+  if (ctx.meta.epic && ctx.meta.story) {
+    const depends = ctx.meta.depends?.length ? ctx.meta.depends.join(", ") : "none";
+    parts.push(`Epic ${ctx.meta.epic} story ${ctx.meta.story}. Depends: ${depends}.`);
+  }
+  parts.push(`- Workflow: ${ctx.meta.workflow}`);
+  parts.push(`- Change path: ${ctx.displayPath}`);
+  if (stage?.owner) parts.push(`- Owner: ${stage.owner}`);
+  if (stage?.collaborates?.length) parts.push(`- Works with: ${stage.collaborates.join(", ")}`);
+  if (stage?.gate?.approvers?.length) {
+    parts.push(`- Approvers: ${stage.gate.approvers.join(", ")}`);
+  }
+  parts.push("");
+  const paths = guidancePaths(config);
+  parts.push(`## Constraints`);
+  parts.push(`- Follow artifacts in the change directory as source of truth.`);
+  parts.push(`- Honor \`${paths.constitution}\` when present (non-negotiables).`);
+  parts.push(`- Do not skip ARB/decision constraints if present.`);
+  parts.push(`- Local development only \u2014 verify on this machine.`);
+  parts.push(`- Prefer small, reviewable commits.`);
+  parts.push("");
+  parts.push(`## Artifacts to read`);
+  parts.push(`- Documentation map (if present): \`${paths.memoryIndex}\``);
+  parts.push(`- Memory: \`${paths.memory}/\``);
+  for (const s of ctx.stages) {
+    for (const a of s.artifacts) {
+      parts.push(`- ${ctx.displayPath}/${a.path}`);
+    }
+  }
+  parts.push("");
+  parts.push(`## Stage`);
+  parts.push(`- Current stage: ${ctx.meta.stage}${stage?.title ? ` (${stage.title})` : ""}`);
+  parts.push("");
+  if (stage?.summary) {
+    parts.push(`## Stage goal`);
+    parts.push(stage.summary);
+    parts.push("");
+  }
+  if (stage?.agent_context?.instructions) {
+    parts.push(`## Instructions`);
+    parts.push(stage.agent_context.instructions);
+    parts.push("");
+  }
+  parts.push(`## Current stage artifacts`);
+  if (stage) {
+    for (const a of stage.artifacts) {
+      parts.push(`- ${a.path}${a.required ? " (required)" : ""}`);
+    }
+  }
+  parts.push("");
+  const stageId = ctx.meta.stage;
+  if (stageId === "implement" || stageId === "local_verify") {
+    parts.push(`## Code context (product code)`);
+    parts.push("");
+    parts.push(`Process context above is not enough for product code structure.`);
+    parts.push(`When you need symbols, callers, or package-boundary context:`);
+    parts.push(
+      `1. Run: \`sdd context\` (optional: \`--path \u2026\`, \`--symbol \u2026\`, \`--out change\`)`
+    );
+    parts.push(
+      `2. If present, read: \`${changesPathRel(config)}/${ctx.id}/code-context.md\` (regenerate if stale)`
+    );
+    parts.push(
+      `3. Org libraries / remote AST: \`.sdd/mcp.yaml\` sources via \`sdd mcp sources\` / \`sdd mcp fetch\``
+    );
+    parts.push(`Do not dump unbounded source into the prompt; prefer sliced / MCP output.`);
+    parts.push("");
+  }
+  try {
+    const { loadMcpConfig } = await import("./sources-3TXUPU6V.js");
+    const { gatherMcpContextForChange, formatMcpContextForHandoff } = await import("./gather-7TSVKQO2.js");
+    const mcpCfg = await loadMcpConfig(projectRoot);
+    if (mcpCfg.auto_fetch_on_handoff && mcpCfg.sources.length) {
+      const fetched = await gatherMcpContextForChange(projectRoot, ctx);
+      const block = formatMcpContextForHandoff(fetched.filter((r) => r.ok || r.error));
+      if (block) {
+        parts.push(block);
+      }
+    } else if (mcpCfg.sources.length === 0) {
+      parts.push(`## External MCP sources`);
+      parts.push("");
+      parts.push(`No sources in \`.sdd/mcp.yaml\` yet. To attach org libraries / AST engines:`);
+      parts.push(`\`sdd mcp sources add --help\` \xB7 docs: Configure MCP sources`);
+      parts.push("");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    parts.push(`## External MCP sources`);
+    parts.push("");
+    parts.push(`_MCP auto-fetch skipped (non-fatal): ${msg}_`);
+    parts.push("");
+  }
+  const inner = await buildRetrievedInner(
+    projectRoot,
+    config,
+    ctx.meta.title,
+    ctx.meta.stage,
+    budget,
+    runtime,
+    ctx.displayPath
+  );
+  parts.push("## Retrieved context");
+  parts.push("");
+  parts.push("<!-- retrieved-context:start -->");
+  parts.push(inner);
+  parts.push("<!-- retrieved-context:end -->");
+  parts.push("");
+  parts.push(
+    `When done with this stage, the human will run \`sdd next\` or \`sdd verify\` / \`sdd complete\`.`
+  );
+  return parts.join("\n");
+}
+
+export {
+  isInitialized,
+  loadConfig,
+  saveConfig,
+  defaultConfig,
+  mergeConfigDefaults,
+  getHeadSha,
+  WORK_TYPES,
+  isWorkType,
+  workKind,
+  ROLE_TEXT,
+  countTokens,
+  ftsTokens,
+  SearchConfigError,
+  budgetForStage,
+  loadSearchConfig,
+  searchPreamble,
+  renderBlock,
+  packHits,
+  isSecretPath,
+  isIgnoredPath,
+  classifyPath,
+  isHardDenied,
+  isPrunedDir,
+  loadExcluder,
+  chunkMarkdown,
+  SUMMARY_TOKEN_CAP,
+  extractiveSummary,
+  EMBEDDING_MODEL,
+  EMBEDDINGS_UNAVAILABLE,
+  fastembedImportCount,
+  createFastembedEmbedder,
+  resolveEmbedder,
+  embedSearchQuery,
+  resolveActiveDirectory,
+  readPackedCache,
+  writePackedCache,
+  chunkCode,
+  RRF_K,
+  rrf,
+  fuseByRank,
+  fuseHits,
+  mergeRankedHits,
+  scopeForPath,
+  createBuiltinProvider,
+  keywordHits,
+  listScopeHits,
+  rankScope,
+  searchProject,
+  registerSearchProvider,
+  clearRegisteredSearchProviders,
+  fallbackWarning,
+  resolveSearchProvider,
+  buildRetrievedInner,
+  executeSearch,
+  ModelsConfigSchema,
+  loadModels,
+  checkModels,
+  canonicalRoleName,
+  roleFilePath,
+  conversationDir,
+  memoryDir,
+  allowFilePath,
+  parseRoleDocument,
+  readRole,
+  createRole,
+  editRole,
+  pinRole,
+  hideRole,
+  showRoles,
+  duplicateRole,
+  deleteRole,
+  listConversationRoles,
+  readAllowFile,
+  TeamSchema,
+  gitUserName,
+  listTeamTemplates,
+  listRoleTemplates,
+  initTeam,
+  readTeamConfig,
+  formatTeam,
+  resolveBot,
+  showTeam,
+  checkTeam,
+  createRoleFromTemplate,
+  formatStatus,
+  buildAgentPrompt
+};