@structured-vibe-coding/core 0.18.0 → 0.19.0

package/dist/{chunk-44LQ5BKZ.js → chunk-TGRV6WGS.js}

@@ -1,9 +1,10 @@
 import {
   ConfigSchema,
+  defaultTeamsDir,
   getStage,
   isStageSkipped,
   shouldAutoSkip
-} from "./chunk-QHV5KZKX.js";
+} from "./chunk-HG7TPW5V.js";
 import {
   SddError
 } from "./chunk-MHODNFIL.js";
@@ -15,11 +16,16 @@ import {
   ensureDir,
   guidancePaths,
   indexDbPath,
+  listDirs,
+  listFiles,
   memoryPathRel,
   pathExists,
+  readText,
   readYaml,
+  removePath,
   sddRoot,
   searchConfigPath,
+  writeText,
   writeYaml
 } from "./chunk-O5SP6X5R.js";
 
@@ -101,6 +107,55 @@ async function getHeadSha(projectRoot, runGit = runGitHead) {
   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) {
@@ -111,8 +166,8 @@ function ftsTokens(query) {
   let current = "";
   for (const ch of query) {
     const code = ch.codePointAt(0) ?? 0;
-    const ok = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code > 127;
-    if (ok) {
+    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);
@@ -2416,6 +2471,719 @@ async function executeSearch(projectRoot, config, query, scope, budget) {
   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 = [];
@@ -2472,6 +3240,11 @@ async function buildAgentPrompt(ctx, config, projectRoot, budget, runtime) {
   }
   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`);
@@ -2530,7 +3303,7 @@ async function buildAgentPrompt(ctx, config, projectRoot, budget, runtime) {
   }
   try {
     const { loadMcpConfig } = await import("./sources-3TXUPU6V.js");
-    const { gatherMcpContextForChange, formatMcpContextForHandoff } = await import("./gather-ZNV2NAUN.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);
@@ -2580,6 +3353,10 @@ export {
   defaultConfig,
   mergeConfigDefaults,
   getHeadSha,
+  WORK_TYPES,
+  isWorkType,
+  workKind,
+  ROLE_TEXT,
   countTokens,
   ftsTokens,
   SearchConfigError,
@@ -2617,12 +3394,43 @@ export {
   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
 };