@jmanuelcorral/openteam 0.9.1 → 0.9.2

package/dist/index.js

@@ -199,7 +199,7 @@ var LEGACY_TEAM_ROLE_ALIASES = {
   basher: "routing-cost",
   linus: "tester"
 };
-var KNOWN_NON_WORKER_ROLE_IDS = ["openteam"];
+var KNOWN_NON_WORKER_ROLE_IDS = ["orchestrator", "openteam"];
 function isKnownNonWorkerRole(roleID) {
   return KNOWN_NON_WORKER_ROLE_IDS.includes(roleID);
 }
@@ -3661,22 +3661,70 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "1. When you create the team for the first time, **choose a thematic universe**",
     "   (e.g. a film, series, comic or mythology). If the user has a preference,",
     "   ask them for it; if not, propose one and move forward without blocking work.",
-    "2. Give each subagent the **name of a character** from that universe; the",
-    "   file name (`.opencode/agent/<name>.md`) is its alias for",
+    "2. Give each subagent an `agentName`: the **name of a character** from that universe;",
+    "   the file name (`.opencode/agent/<agentName>.md`) is its alias for",
     "   `@mention`, and its role is clear from the `description`.",
-    `3. **Register the cast** in \`${OPENTEAM_ROSTER_PATH}\` (universe + table`,
-    "   name → role → model) so that the names **persist** across sessions.",
-    "   This file goes **outside** `.opencode/agent/` (otherwise opencode would load it",
-    "   as a phantom agent). Always reuse the same cast; do not re-cast",
-    "   without reason.",
+    "3. Give each entry a `roleID`: the stable functional routing key. `roleID` is",
+    "   **not** the themed name. Worked example: C-3PO as the scribe is",
+    '   `{ "roleID": "scribe", "agentName": "c3po" }`, never',
+    '   `{ "roleID": "c3po", "agentName": "c3po" }`.',
+    "4. Prefer existing curated `roleID` keys when they fit:",
+    "   `architect`, `integration`, `tester`, `reviewer`, `local-runtime`,",
+    "   `routing-cost` (plus the guaranteed `orchestrator`, `guardian`,",
+    "   `scribe`, `ralph`). The roleID space is open: use free-form project",
+    "   roleIDs only when no curated role fits.",
+    `5. **Register the cast** in \`${OPENTEAM_ROSTER_PATH}\` so the names persist`,
+    "   across sessions. This file goes **outside** `.opencode/agent/` (otherwise",
+    "   opencode would load it as a phantom agent). Always reuse the same cast;",
+    "   do not re-cast without reason.",
+    "",
+    "## Roster file format",
+    "",
+    "Write the roster as Markdown with exactly one fenced `json` block matching",
+    "`{ universe, entries: [{ roleID, agentName }] }`. Do not write a table.",
+    "Minimal parseable example:",
+    "",
+    "# openteam roster",
+    "",
+    "Universe: star-wars",
+    "",
+    "```json",
+    "{",
+    '  "universe": "star-wars",',
+    '  "entries": [',
+    "    {",
+    '      "roleID": "orchestrator",',
+    '      "agentName": "openteam"',
+    "    },",
+    "    {",
+    '      "roleID": "guardian",',
+    '      "agentName": "leia"',
+    "    },",
+    "    {",
+    '      "roleID": "scribe",',
+    '      "agentName": "c3po"',
+    "    },",
+    "    {",
+    '      "roleID": "ralph",',
+    '      "agentName": "r2d2"',
+    "    },",
+    "    {",
+    '      "roleID": "tester",',
+    '      "agentName": "rex"',
+    "    }",
+    "  ]",
+    "}",
+    "```",
     "",
     "## How to create the team when it does not exist",
     "",
     "1. Analyze the goal and explore the repository (`read`/`glob`/`grep`).",
     "2. Break the request into tasks and design the **minimal team** needed:",
-    "   define only the roles the work requires (e.g. architect, backend,",
-    "   frontend, reviewer, tester, docs). Do not invent roles you will not use.",
-    "3. Create each subagent **on demand** by writing `.opencode/agent/<name>.md`:",
+    "   define only the roles the work requires. Reuse curated roleIDs such as",
+    "   `architect`, `integration`, `reviewer`, `tester`, `local-runtime` and",
+    "   `routing-cost`; use custom roleIDs for uncovered project specialties.",
+    "   Do not invent roles you will not use.",
+    "3. Create each subagent **on demand** by writing `.opencode/agent/<agentName>.md`:",
     "   - Frontmatter: `description` (required, include role and universe),",
     "     `mode: subagent`, `temperature`, `permission` with the minimum needed,",
     "     and `model` **optional**.",
@@ -3697,8 +3745,10 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "",
     "## Standard team roles",
     "",
-    "Besides the project-specific roles, include these standard roles",
-    "(create them on demand, with their universe name) when they add value:",
+    "Every roster MUST include these guaranteed canonical roleIDs exactly:",
+    "`orchestrator`, `guardian`, `scribe`, and `ralph`. Map `orchestrator` to",
+    "agentName `openteam` (the primary agent). Create the `guardian`, `scribe`,",
+    "and `ralph` subagent files on demand with their themed `agentName` values:",
     "",
     "- **scribe** — the team's silent memory. Records decisions and",
     "  learnings in a shared log (`.opencode/openteam/decisions.md`) without",
@@ -6608,12 +6658,67 @@ var RosterSchema = z18.object({
   universe: z18.string().min(1),
   entries: z18.array(RosterEntrySchema)
 }).strict();
+var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
+
+class RosterParseError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RosterParseError";
+    this.code = code;
+  }
+}
+function parseRoster(text) {
+  const result = parseRosterResult(text);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.roster;
+}
+function parseRosterResult(text) {
+  const match = ROSTER_JSON_FENCE.exec(text);
+  if (match === null || match[1] === undefined) {
+    return {
+      ok: false,
+      error: new RosterParseError("missing-json-block", "openteam roster: no JSON block found in roster file")
+    };
+  }
+  let data;
+  try {
+    data = JSON.parse(match[1]);
+  } catch (error) {
+    return {
+      ok: false,
+      error: new RosterParseError("malformed-json", `openteam roster: malformed JSON in roster file: ${String(error)}`)
+    };
+  }
+  const parsed = RosterSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: new RosterParseError("invalid-roster-schema", `openteam roster: invalid roster schema: ${parsed.error.message}`)
+    };
+  }
+  return { ok: true, roster: parsed.data };
+}
 var GUARANTEED_ROLE_IDS = [
   "orchestrator",
   "guardian",
   "scribe",
   "ralph"
 ];
+var GUARANTEED_ROLE_DEFAULT_AGENT_NAMES = {
+  orchestrator: "openteam",
+  guardian: "guardian",
+  scribe: "scribe",
+  ralph: "ralph"
+};
+function defaultAgentNameForGuaranteedRole(roleID) {
+  return GUARANTEED_ROLE_DEFAULT_AGENT_NAMES[roleID];
+}
+function isGuaranteedRoleID(roleID) {
+  return GUARANTEED_ROLE_IDS.includes(roleID);
+}
 function missingGuaranteedRoles(roster) {
   const present = new Set(roster.entries.map((entry) => entry.roleID));
   return GUARANTEED_ROLE_IDS.filter((roleID) => !present.has(roleID));
@@ -6621,6 +6726,100 @@ function missingGuaranteedRoles(roster) {
 function hasAllGuaranteedRoles(roster) {
   return missingGuaranteedRoles(roster).length === 0;
 }
+function isRoleProfileLike(value) {
+  return typeof value === "object" && value !== null && "roleID" in value && "defaultTier" in value;
+}
+function configuredRolesFromAuditInput(input) {
+  if ("configuredRoles" in input && !isRoleProfileLike(input.configuredRoles)) {
+    return input.configuredRoles;
+  }
+  return input;
+}
+function auditRoster(rosterOrText, configuredRolesOrOptions = {}) {
+  const configuredRoles = configuredRolesFromAuditInput(configuredRolesOrOptions);
+  if (typeof rosterOrText === "string") {
+    const parsed = parseRosterResult(rosterOrText);
+    if (!parsed.ok) {
+      return {
+        findings: [
+          {
+            kind: "unparseable-roster",
+            roleID: "roster",
+            code: parsed.error.code,
+            message: parsed.error.message
+          }
+        ],
+        hasAllGuaranteedRoles: false,
+        missingGuaranteedRoleIDs: [],
+        unprofiledRoleEntries: [],
+        misassignedGuaranteedRoleEntries: []
+      };
+    }
+    return auditParsedRoster(parsed.roster, configuredRoles);
+  }
+  return auditParsedRoster(rosterOrText, configuredRoles);
+}
+function auditParsedRoster(roster, configuredRoles) {
+  const missingGuaranteedRoleIDs = missingGuaranteedRoles(roster);
+  const missing = new Set(missingGuaranteedRoleIDs);
+  const findings = missingGuaranteedRoleIDs.map((roleID) => ({
+    kind: "missing-guaranteed-role",
+    roleID
+  }));
+  const unprofiledRoleEntries = [];
+  const misassignedGuaranteedRoleEntries = [];
+  roster.entries.forEach((entry) => {
+    const profile = getRoleProfile(entry.roleID, configuredRoles);
+    if (profile === undefined && !isKnownNonWorkerRole(entry.roleID)) {
+      unprofiledRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        severity: "info"
+      });
+      findings.push({
+        kind: "unresolved-role-profile",
+        roleID: entry.roleID,
+        agentName: entry.agentName
+      });
+    }
+    if (isGuaranteedRoleID(entry.agentName) && entry.roleID !== entry.agentName && missing.has(entry.agentName)) {
+      misassignedGuaranteedRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        missingRoleID: entry.agentName,
+        reason: "agentNameMatchesMissingGuaranteedRole"
+      });
+      findings.push({
+        kind: "non-canonical-role-id",
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        canonicalRoleID: entry.agentName
+      });
+      return;
+    }
+    if (profile !== undefined && isGuaranteedRoleID(profile.roleID) && profile.roleID !== entry.roleID && missing.has(profile.roleID)) {
+      misassignedGuaranteedRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        missingRoleID: profile.roleID,
+        reason: "roleIDResolvesToMissingGuaranteedRole"
+      });
+      findings.push({
+        kind: "non-canonical-role-id",
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        canonicalRoleID: profile.roleID
+      });
+    }
+  });
+  return {
+    findings,
+    hasAllGuaranteedRoles: missingGuaranteedRoleIDs.length === 0,
+    missingGuaranteedRoleIDs,
+    unprofiledRoleEntries,
+    misassignedGuaranteedRoleEntries
+  };
+}
 function enforceGuaranteedRoles(roster) {
   const missing = missingGuaranteedRoles(roster);
   if (missing.length === 0) {
@@ -6628,7 +6827,7 @@ function enforceGuaranteedRoles(roster) {
   }
   const added = missing.map((roleID) => ({
     roleID,
-    agentName: roleID
+    agentName: defaultAgentNameForGuaranteedRole(roleID)
   }));
   return { universe: roster.universe, entries: [...roster.entries, ...added] };
 }
@@ -6660,7 +6859,6 @@ async function dispatchGuaranteedRole(agentName, agentFileExists, dispatch) {
 }
 
 // src/orchestrator/rosterPersistence.ts
-var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 function serializeRoster(roster) {
   const data = { universe: roster.universe, entries: roster.entries };
   const json = JSON.stringify(data, null, 2);
@@ -6673,38 +6871,41 @@ ${json}
 \`\`\`
 `;
 }
-function parseRoster(text) {
-  const match = ROSTER_JSON_FENCE.exec(text);
-  if (match === null || match[1] === undefined) {
-    throw new Error("openteam roster: no JSON block found in roster file");
-  }
-  let data;
-  try {
-    data = JSON.parse(match[1]);
-  } catch (error) {
-    throw new Error(`openteam roster: malformed JSON in roster file: ${String(error)}`);
-  }
-  return RosterSchema.parse(data);
-}
 async function persistRoster(storage, roster, path2 = OPENTEAM_ROSTER_PATH) {
   await storage.write(path2, serializeRoster(roster));
   return path2;
 }
-async function loadRoster(storage, path2 = OPENTEAM_ROSTER_PATH) {
+async function loadRosterFile(storage, path2 = OPENTEAM_ROSTER_PATH) {
   const content = await storage.read(path2);
   if (content === undefined) {
-    return;
+    return { status: "absent", path: path2 };
+  }
+  const parsed = parseRosterResult(content);
+  if (!parsed.ok) {
+    return { status: "invalid", path: path2, error: parsed.error };
   }
-  return parseRoster(content);
+  return {
+    status: "loaded",
+    path: path2,
+    roster: enforceGuaranteedRoles(parsed.roster)
+  };
 }
 async function loadOrGenerateRoster(storage, generate, path2 = OPENTEAM_ROSTER_PATH) {
-  const existing = await loadRoster(storage, path2);
-  if (existing !== undefined) {
-    return { roster: existing, regenerated: false };
+  const existing = await loadRosterFile(storage, path2);
+  if (existing.status === "loaded") {
+    return { roster: existing.roster, regenerated: false };
+  }
+  const roster = enforceGuaranteedRoles(await generate());
+  if (existing.status === "absent") {
+    await persistRoster(storage, roster, path2);
+    return { roster, regenerated: true };
   }
-  const roster = await generate();
-  await persistRoster(storage, roster, path2);
-  return { roster, regenerated: true };
+  return {
+    roster,
+    regenerated: true,
+    recoveredFromInvalidPersisted: true,
+    invalidPersistedRosterError: existing.error.message
+  };
 }
 
 // src/plugin/availability.ts
@@ -7760,6 +7961,77 @@ function diagnosticsSection(diagnostics) {
   lines.push("    note: plugin diagnostics are bounded classes recorded instead of writing to the opencode TUI console.");
   return lines;
 }
+function rosterEntryText(entry) {
+  return entry.agentName === undefined ? `"${entry.roleID}"` : `"${entry.roleID}" (agentName "${entry.agentName}")`;
+}
+function canonicalRoleID(entry) {
+  return entry.canonicalRoleID ?? entry.missingRoleID;
+}
+function legacyRosterFindings(audit) {
+  const findings = [];
+  for (const roleID of audit.missingGuaranteedRoleIDs ?? []) {
+    findings.push({ kind: "missing-guaranteed-role", roleID });
+  }
+  for (const entry of audit.misassignedGuaranteedRoleEntries ?? []) {
+    const canonical2 = canonicalRoleID(entry);
+    findings.push({
+      kind: "non-canonical-role-id",
+      roleID: entry.roleID,
+      ...entry.agentName !== undefined ? { agentName: entry.agentName } : {},
+      ...canonical2 !== undefined ? { canonicalRoleID: canonical2 } : {}
+    });
+  }
+  for (const entry of audit.unprofiledRoleEntries ?? []) {
+    findings.push({
+      kind: "unresolved-role-profile",
+      roleID: entry.roleID,
+      ...entry.agentName !== undefined ? { agentName: entry.agentName } : {}
+    });
+  }
+  return findings;
+}
+function rosterHealthSection(audit, loadError, rosterRoleCount) {
+  const auditFindings = audit?.findings ?? legacyRosterFindings(audit ?? {});
+  const unparseable = auditFindings.find((finding) => finding.kind === "unparseable-roster");
+  const unparseableMessage = loadError ?? unparseable?.message;
+  if (unparseableMessage !== undefined) {
+    return [
+      "  roster health:",
+      `    ✗ unparseable roster: ${OPENTEAM_ROSTER_PATH} — ${unparseableMessage}`,
+      "      problem: the roster is present but is not machine-readable by openteam.",
+      "      remedy: keep any human notes outside the JSON fence, add one fenced `json` block containing `{ universe, entries: [{ roleID, agentName }] }`, then re-run `openteam doctor`."
+    ];
+  }
+  if (audit === undefined) {
+    return [];
+  }
+  const missing = auditFindings.filter((finding) => finding.kind === "missing-guaranteed-role").map((finding) => finding.roleID);
+  const misassigned = auditFindings.filter((finding) => finding.kind === "non-canonical-role-id");
+  const unprofiled = auditFindings.filter((finding) => finding.kind === "unresolved-role-profile");
+  if (missing.length === 0 && misassigned.length === 0 && unprofiled.length === 0) {
+    return rosterRoleCount === undefined ? [] : [
+      "  roster health:",
+      `    ✓ ${OPENTEAM_ROSTER_PATH} read (${rosterRoleCount} roles); guaranteed roles present.`
+    ];
+  }
+  const lines = ["  roster health:"];
+  if (missing.length > 0) {
+    lines.push(`    ✗ missing guaranteed roleID(s): ${missing.join(", ")}`);
+    lines.push(`      remedy: edit ${OPENTEAM_ROSTER_PATH}'s JSON block to add these canonical roleIDs with their themed agentName values; keep roleID canonical, e.g. { "roleID": "scribe", "agentName": "c3po" }.`);
+  }
+  for (const entry of misassigned) {
+    const canonical2 = canonicalRoleID(entry);
+    const target = canonical2 === undefined ? "the canonical functional roleID" : `"${canonical2}"`;
+    lines.push(`    ⚠ non-canonical roleID ${rosterEntryText(entry)}`);
+    lines.push(`      remedy: change roleID to ${target} and keep the themed name in agentName.`);
+  }
+  if (unprofiled.length > 0) {
+    const roleIDs = unprofiled.map((entry) => entry.roleID).join(", ");
+    lines.push(`    · unprofiled roleID(s): ${roleIDs}`);
+    lines.push("      remedy: if intentional project roles, no action is required; for curated routing, change roleID to a TEAM_ROLES key or add a profile under orchestrator.roles in .opencode/openteam.json.");
+  }
+  return lines;
+}
 function agentModelsSection(diagnostics, searchedPaths) {
   const lines = ["  agent models:"];
   if (diagnostics.length === 0) {
@@ -7798,6 +8070,7 @@ function renderDoctor(input) {
   if (input.diagnostics !== undefined) {
     lines.push(...diagnosticsSection(input.diagnostics));
   }
+  lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount));
   if (input.otelBackend !== undefined) {
     const otel = input.otelBackend;
     lines.push("  opentelemetry:");
@@ -9442,13 +9715,23 @@ async function guaranteedAgentStatuses(runtime) {
   }
   return statuses;
 }
+function rosterPlanSummary(rosterFile) {
+  switch (rosterFile.status) {
+    case "loaded":
+      return `${rosterFile.roster.universe} (${rosterFile.roster.entries.length} roles)`;
+    case "absent":
+      return "none yet — one would be generated on the first real run";
+    case "invalid":
+      return `${rosterFile.path} is present but unparseable — run 'openteam doctor'`;
+  }
+}
 function renderLoopPlan(plan2) {
   const { flags } = plan2;
   const budget = flags.budgetUsd !== undefined ? `$${flags.budgetUsd}` : "unbounded";
   const freshContext = flags.freshContext ? "on (pure Ralph pattern)" : "off";
   const budgetStop = flags.budgetUsd !== undefined ? ", budget" : "";
   const redTestsStop = flags.stopOnRedTests ? ", red tests" : "";
-  const rosterSummary = plan2.roster !== undefined ? `${plan2.roster.universe} (${plan2.roster.entries.length} roles)` : "none yet — one would be generated on the first real run";
+  const rosterSummary = rosterPlanSummary(plan2.rosterFile);
   const lines = [
     "openteam loop — plan (dry run, nothing dispatched):",
     `  backlog:       ${flags.backlogPath} (${plan2.uncheckedCount} unchecked item(s))`,
@@ -9492,14 +9775,14 @@ ${LOOP_HELP}` };
   const backlogText = await runtime.readBacklog(flags.backlogPath) ?? "";
   const items = parseBacklog(backlogText);
   const unchecked = uncheckedBacklogItems(items);
-  const roster = await runtime.loadRoster();
+  const rosterFile = await runtime.loadRosterFile();
   const guaranteed = await guaranteedAgentStatuses(runtime);
   const plannedIterations = Math.max(0, Math.min(flags.maxIterations, unchecked.length));
   const plan2 = {
     flags,
     uncheckedCount: unchecked.length,
     plannedIterations,
-    roster,
+    rosterFile,
     guaranteed
   };
   if (flags.dryRun) {
@@ -9577,13 +9860,15 @@ async function runCli(argv, deps) {
     if (command === "doctor") {
       const config = await deps.loadConfig(configPath, configResolution);
       let opencodeConfigError;
+      let rosterLoadError;
       const [
         snapshots,
         records,
         diagnostics,
         cacheEntries,
         agentFiles,
-        opencodeConfig
+        opencodeConfig,
+        roster
       ] = await Promise.all([
         deps.probe(config),
         deps.readTelemetry(telemetryPath),
@@ -9595,7 +9880,11 @@ async function runCli(argv, deps) {
         deps.readOpencodeConfig(opencodeConfigPaths).catch((err) => {
           opencodeConfigError = err instanceof Error ? err.message : String(err);
           return;
-        })
+        }),
+        deps.loadRosterForDoctor !== undefined ? deps.loadRosterForDoctor().catch((err) => {
+          rosterLoadError = err instanceof Error ? err.message : String(err);
+          return;
+        }) : Promise.resolve(undefined)
       ]);
       const defaultModel = defaultModelFromOpencode(opencodeConfig);
       const agentModels = diagnoseAgentModels(agentFiles, {
@@ -9610,6 +9899,18 @@ async function runCli(argv, deps) {
         backend: "opentelemetry",
         connectionEnv: "APPLICATIONINSIGHTS_CONNECTION_STRING"
       }, (name) => process.env[name]);
+      let rosterAudit;
+      let rosterRoleCount;
+      if (roster !== undefined && deps.auditRoster !== undefined) {
+        if (typeof roster !== "string") {
+          rosterRoleCount = roster.entries.length;
+        }
+        try {
+          rosterAudit = deps.auditRoster(roster, config.orchestrator?.roles);
+        } catch (err) {
+          rosterLoadError = err instanceof Error ? err.message : String(err);
+        }
+      }
       return {
         exitCode: 0,
         stdout: renderDoctor({
@@ -9619,6 +9920,9 @@ async function runCli(argv, deps) {
           telemetryRecords: records.length,
           agentModels,
           opencodeConfigPaths,
+          ...rosterAudit !== undefined ? { rosterAudit } : {},
+          ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
+          ...rosterLoadError !== undefined ? { rosterLoadError } : {},
           ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
           ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
           ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
@@ -12504,7 +12808,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.9.1",
+  version: "0.9.2",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -12944,6 +13248,18 @@ async function readCliConfigFromStorage(storage, path4, resolution) {
   }
   return content;
 }
+async function readStoredRosterForDoctor(storage) {
+  const content = await storage.read(OPENTEAM_ROSTER_PATH);
+  if (content === undefined) {
+    return;
+  }
+  try {
+    return parseRoster(content);
+  } catch {
+    return content;
+  }
+}
+var auditStoredRosterForDoctor = (roster, configuredRoles) => typeof roster === "string" ? auditRoster(roster, configuredRoles) : auditRoster(roster, configuredRoles);
 function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SESSIONS_DIR, storage = createFsStorageProvider(process.cwd()), fallbackSource = "options", rawOptions) {
   return {
     loadConfig: async (path4, resolution = { explicit: false }) => {
@@ -13027,6 +13343,8 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     agentDir: dirname4(ORCHESTRATOR_AGENT_PATH),
     cachePort: realCacheAdapter,
     purge: createPluginPurgeRuntime(sessionsDir),
+    loadRosterForDoctor: () => readStoredRosterForDoctor(storage),
+    auditRoster: auditStoredRosterForDoctor,
     version: PACKAGE_VERSION
   };
 }

package/dist/opencodeArtifacts/orchestratorAgent.d.ts

@@ -5,7 +5,7 @@ import type { FrontierChoice } from "../commands/setup";
  */
 export declare const ORCHESTRATOR_AGENT_PATH = ".opencode/agent/openteam.md";
 /**
- * Path to the casting registry (universe + name→role→model table). Lives
+ * Path to the casting registry (universe + roleID→agentName JSON roster). Lives
  * **outside** `.opencode/agent/` intentionally: opencode loads as an agent every
  * `.md` in that folder, so a stray roster markdown file inside would appear as a
  * phantom agent in the Tab-switcher. It is portable team-state (P15b), so it lives

package/dist/opencodeArtifacts/orchestratorAgent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestratorAgent.d.ts","sourceRoot":"","sources":["../../src/opencodeArtifacts/orchestratorAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,iCAAiC,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,cAAc,EACxB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/B,MAAM,CAiOR"}
+{"version":3,"file":"orchestratorAgent.d.ts","sourceRoot":"","sources":["../../src/opencodeArtifacts/orchestratorAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,iCAAiC,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,cAAc,EACxB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/B,MAAM,CAmRR"}

package/dist/orchestrator/roles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;CAClC,CAAC;AAiBF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;kBAkBxB,CAAC;AAGZ,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA8FvD,CAAC;AAYF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI5D;AA6BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,GAC3D,gBAAgB,GAAG,SAAS,CAO9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAW1E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;CAClC,CAAC;AAiBF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;kBAkBxB,CAAC;AAGZ,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA8FvD,CAAC;AAcF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI5D;AA6BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,GAC3D,gBAAgB,GAAG,SAAS,CAO9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAW1E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}