@jmanuelcorral/openteam 0.9.0 → 0.9.2

package/dist/cli.js

@@ -104,8 +104,8 @@ var AgentRoleProfileSchema = z.object({
   localRuntimes: z.array(z.enum(["ollama", "lmstudio", "foundry-local", "lemonade"])).optional()
 }).strict();
 var TEAM_ROLES = {
-  rusty: {
-    roleID: "rusty",
+  architect: {
+    roleID: "architect",
     opencodeAgent: "architect",
     defaultTier: "hard",
     minReasoningTier: 5,
@@ -114,8 +114,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: false
   },
-  livingston: {
-    roleID: "livingston",
+  integration: {
+    roleID: "integration",
     opencodeAgent: "integration",
     defaultTier: "moderate",
     minReasoningTier: 4,
@@ -124,8 +124,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: false
   },
-  yen: {
-    roleID: "yen",
+  "local-runtime": {
+    roleID: "local-runtime",
     opencodeAgent: "local-runtime",
     defaultTier: "moderate",
     minReasoningTier: 3,
@@ -134,8 +134,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: true
   },
-  basher: {
-    roleID: "basher",
+  "routing-cost": {
+    roleID: "routing-cost",
     opencodeAgent: "routing-cost",
     defaultTier: "moderate",
     minReasoningTier: 3,
@@ -177,8 +177,8 @@ var TEAM_ROLES = {
     localFirst: true,
     requiresLocalRuntime: true
   },
-  linus: {
-    roleID: "linus",
+  tester: {
+    roleID: "tester",
     opencodeAgent: "tester",
     defaultTier: "simple",
     minReasoningTier: 2,
@@ -198,8 +198,35 @@ var TEAM_ROLES = {
     localFirst: true
   }
 };
+var LEGACY_TEAM_ROLE_ALIASES = {
+  rusty: "architect",
+  livingston: "integration",
+  yen: "local-runtime",
+  basher: "routing-cost",
+  linus: "tester"
+};
+var KNOWN_NON_WORKER_ROLE_IDS = ["orchestrator", "openteam"];
+function isKnownNonWorkerRole(roleID) {
+  return KNOWN_NON_WORKER_ROLE_IDS.includes(roleID);
+}
+function getConfiguredRoleProfileByAlias(roleID, roles) {
+  if (roles === undefined) {
+    return;
+  }
+  for (const key of Object.keys(roles).sort()) {
+    const profile = roles[key];
+    if (profile?.opencodeAgent === roleID) {
+      return profile;
+    }
+  }
+  return;
+}
+function getLegacyTeamRoleProfile(roleID) {
+  const canonicalRoleID = LEGACY_TEAM_ROLE_ALIASES[roleID];
+  return canonicalRoleID === undefined ? undefined : TEAM_ROLES[canonicalRoleID];
+}
 function getRoleProfile(roleID, configuredRoles) {
-  return configuredRoles?.[roleID] ?? TEAM_ROLES[roleID];
+  return configuredRoles?.[roleID] ?? TEAM_ROLES[roleID] ?? getConfiguredRoleProfileByAlias(roleID, configuredRoles) ?? getLegacyTeamRoleProfile(roleID);
 }
 function synthesiseFallbackProfile(roleID) {
   return {
@@ -967,6 +994,50 @@ var ModelCapabilityProfileSchema = z3.object({
   availability: z3.enum(["available", "degraded", "unavailable"])
 }).strict();
 
+// src/telemetry/diagnostics.ts
+var DIAGNOSTIC_CODES = [
+  "availability-refresh-failed",
+  "config-missing",
+  "graph-gate-denied",
+  "memory-extraction-warning",
+  "memory-runtime-warning",
+  "opencode-server-url",
+  "opencode-version-read-failed",
+  "privacy-inert",
+  "soak-evidence-rejected",
+  "telemetry-warning",
+  "telemetry-write-failed",
+  "unknown-role"
+];
+function diagnosticDescription(code) {
+  switch (code) {
+    case "availability-refresh-failed":
+      return "Local runtime availability refresh failed; routing will continue with the previous or empty availability snapshot.";
+    case "config-missing":
+      return "openteam did not find its runtime config file; defaults or plugin options were used.";
+    case "graph-gate-denied":
+      return "The graph cutover gate denied active mode and openteam degraded graph mode to off.";
+    case "memory-extraction-warning":
+      return "Semantic memory extraction reported a non-fatal local-runtime warning; no raw conversation content was recorded.";
+    case "memory-runtime-warning":
+      return "Semantic memory runtime setup reported a non-fatal warning; memory recall may be incomplete.";
+    case "opencode-server-url":
+      return "openteam observed the opencode server URL during plugin initialization.";
+    case "opencode-version-read-failed":
+      return "openteam could not read the live opencode version; graph gates fail closed when this happens.";
+    case "privacy-inert":
+      return "forceLocalOnSensitive is configured but no local runtime is configured, so the setting cannot keep sensitive prompts local.";
+    case "soak-evidence-rejected":
+      return "Graph soak evidence contained rejected observation lines; cutover gate evidence may be incomplete.";
+    case "telemetry-warning":
+      return "An optional telemetry backend warning occurred; local JSONL telemetry remains the fallback when enabled.";
+    case "telemetry-write-failed":
+      return "Writing an openteam telemetry event failed; plugin execution continued.";
+    case "unknown-role":
+      return "An unknown role ID was encountered; openteam used a neutral frontier-eligible fallback. If intentional, define the role in orchestrator.roles.";
+  }
+}
+
 // src/telemetry/events.ts
 var EVENT_SCHEMA_VERSION = 1;
 var EventBaseSchema = z4.object({
@@ -1060,6 +1131,13 @@ var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
     "unknown"
   ])
 });
+var DiagnosticLevelSchema = z4.enum(["debug", "info", "warn", "error"]);
+var DiagnosticCodeSchema = z4.enum(DIAGNOSTIC_CODES);
+var DiagnosticEventSchema = EventBaseSchema.extend({
+  type: z4.literal("diagnostic"),
+  level: DiagnosticLevelSchema,
+  code: DiagnosticCodeSchema
+});
 var OpenTeamEventSchema = z4.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
@@ -1068,7 +1146,8 @@ var OpenTeamEventSchema = z4.discriminatedUnion("type", [
   DecisionEventSchema,
   ActivityEventSchema,
   SessionEndpointEventSchema,
-  ShadowDiagnosticEventSchema
+  ShadowDiagnosticEventSchema,
+  DiagnosticEventSchema
 ]);
 
 // src/storage/fsStorageProvider.ts
@@ -1328,6 +1407,9 @@ async function readRouteCostRecords(dir, deps) {
   }
   return records;
 }
+async function readDiagnosticEvents(dir, deps) {
+  return (await readSessionEvents(dir, deps)).filter((event) => event.type === "diagnostic");
+}
 async function readSessionEvents(dir, deps) {
   const files = (await deps.storage.list(dir)).filter((file) => file.endsWith(".jsonl"));
   const perFile = await Promise.all(files.map(async (file) => {
@@ -1368,14 +1450,21 @@ function hashPrompt(prompt) {
 
 // src/orchestrator/permissions.ts
 var ROLE_PERMISSIONS = {
-  rusty: ["read", "edit", "multiFileEdit", "destructive", "network", "shell"],
-  livingston: ["read", "edit", "multiFileEdit", "network", "shell"],
-  yen: ["read", "edit", "network", "shell"],
-  basher: ["read", "edit"],
+  architect: [
+    "read",
+    "edit",
+    "multiFileEdit",
+    "destructive",
+    "network",
+    "shell"
+  ],
+  integration: ["read", "edit", "multiFileEdit", "network", "shell"],
+  "local-runtime": ["read", "edit", "network", "shell"],
+  "routing-cost": ["read", "edit"],
   scribe: ["read", "edit"],
   ralph: ["read", "edit", "shell"],
   guardian: ["read"],
-  linus: ["read", "edit", "shell"],
+  tester: ["read", "edit", "shell"],
   reviewer: ["read"]
 };
 var elevatedTier = {
@@ -1671,6 +1760,8 @@ async function runSubsession(client, req, deps = {}) {
 
 // src/orchestrator/coordinator.ts
 function warnUnknownRole(roleID, warn, warnedRoles) {
+  if (isKnownNonWorkerRole(roleID))
+    return;
   if (warnedRoles !== undefined) {
     if (warnedRoles.has(roleID))
       return;
@@ -1749,7 +1840,7 @@ function routingInput(input, role) {
     ...input.task,
     prompt: input.task.prompt ?? input.prompt
   }).tier;
-  const permissionTier = elevateTierForPermissions(classifiedTier, permissionsFor(input.roleID));
+  const permissionTier = elevateTierForPermissions(classifiedTier, permissionsFor(role.roleID));
   const tier = permissionTier;
   const requirement = roleToRequirement(role, input.task, tier);
   const task = roleAdjustedTask(role, input, requirement);
@@ -8557,22 +8648,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**.",
@@ -8593,8 +8732,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",
@@ -9805,16 +9946,165 @@ var RosterSchema = z17.object({
   universe: z17.string().min(1),
   entries: z17.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(text2) {
+  const result = parseRosterResult(text2);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.roster;
+}
+function parseRosterResult(text2) {
+  const match = ROSTER_JSON_FENCE.exec(text2);
+  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));
 }
+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) {
@@ -9822,7 +10112,7 @@ function enforceGuaranteedRoles(roster) {
   }
   const added = missing.map((roleID) => ({
     roleID,
-    agentName: roleID
+    agentName: defaultAgentNameForGuaranteedRole(roleID)
   }));
   return { universe: roster.universe, entries: [...roster.entries, ...added] };
 }
@@ -10227,6 +10517,105 @@ function agentModelLine(diagnostic, nameWidth, searchedPaths) {
   }
   return `    ${mark} ${name} [${diagnostic.mode}]  ${modelText2}  ${provenance}  ${parts.join(" · ")}`;
 }
+function diagnosticMark(level) {
+  switch (level) {
+    case "error":
+      return "✗";
+    case "warn":
+      return "⚠";
+    default:
+      return "·";
+  }
+}
+function diagnosticsSection(diagnostics) {
+  const notable = diagnostics.filter((diagnostic) => diagnostic.level === "warn" || diagnostic.level === "error");
+  if (notable.length === 0) {
+    return [];
+  }
+  const recent = notable.slice(-5);
+  const lines = [
+    `  plugin diagnostics: ${notable.length} warning/error event(s)`
+  ];
+  for (const diagnostic of recent) {
+    lines.push(`    ${diagnosticMark(diagnostic.level)} [${diagnostic.code}] ${diagnosticDescription(diagnostic.code)}`);
+  }
+  if (notable.length > recent.length) {
+    lines.push(`    … ${notable.length - recent.length} older diagnostic event(s) omitted`);
+  }
+  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) {
@@ -10262,6 +10651,10 @@ function renderDoctor(input) {
     }
   }
   lines.push(`  telemetry: ${input.telemetryPath} — ${input.telemetryRecords} record(s)`);
+  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:");
@@ -12487,13 +12880,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))`,
@@ -12537,14 +12940,14 @@ ${LOOP_HELP}` };
   const backlogText = await runtime.readBacklog(flags.backlogPath) ?? "";
   const items = parseBacklog2(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) {
@@ -12622,9 +13025,19 @@ async function runCli(argv, deps) {
     if (command === "doctor") {
       const config = await deps.loadConfig(configPath, configResolution);
       let opencodeConfigError;
-      const [snapshots, records, cacheEntries, agentFiles, opencodeConfig] = await Promise.all([
+      let rosterLoadError;
+      const [
+        snapshots,
+        records,
+        diagnostics,
+        cacheEntries,
+        agentFiles,
+        opencodeConfig,
+        roster
+      ] = await Promise.all([
         deps.probe(config),
         deps.readTelemetry(telemetryPath),
+        deps.readDiagnostics !== undefined ? deps.readDiagnostics() : Promise.resolve(undefined),
         deps.cachePort !== undefined ? deps.cachePort.listEntries(deps.cachePort.resolveCacheRoot(parsed.cacheRoot)).catch(() => {
           return;
         }) : Promise.resolve(undefined),
@@ -12632,7 +13045,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, {
@@ -12647,6 +13064,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({
@@ -12656,6 +13085,10 @@ 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 } : {},
           ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
@@ -13618,16 +14051,16 @@ function insertRecords(db, records) {
     throw error;
   }
 }
-function warnMemoryIndexRecordRejections(result) {
+function warnMemoryIndexRecordRejections(result, warn) {
   if (result.rejectedRows === 0) {
     return;
   }
-  console.warn(`[openteam] memory index reader rejected ${result.rejectedRows} row(s); semantic memory may be incomplete.`);
+  (warn ?? console.warn)(`[openteam] memory index reader rejected ${result.rejectedRows} row(s); semantic memory may be incomplete.`);
   for (const rejection of result.rejections) {
-    console.warn(`[openteam]   • memory_records:${rejection.recordId}: ${rejection.detail}`);
+    (warn ?? console.warn)(`[openteam]   • memory_records:${rejection.recordId}: ${rejection.detail}`);
   }
 }
-function createMemoryIndex(db) {
+function createMemoryIndex(db, warn) {
   db.exec(SCHEMA2);
   const allRecordsFn = () => {
     const rows = db.query("SELECT id, payload FROM memory_records ORDER BY created_at ASC, id ASC").all();
@@ -13655,7 +14088,7 @@ function createMemoryIndex(db) {
   };
   const allRecordsWithWarning = () => {
     const result = allRecordsFn();
-    warnMemoryIndexRecordRejections(result);
+    warnMemoryIndexRecordRejections(result, warn);
     return result.records;
   };
   const state = () => {
@@ -14218,7 +14651,6 @@ async function* linesFromReadable(readable) {
 }
 
 // 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);
@@ -14231,38 +14663,41 @@ ${json}
 \`\`\`
 `;
 }
-function parseRoster(text2) {
-  const match = ROSTER_JSON_FENCE.exec(text2);
-  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, path4 = OPENTEAM_ROSTER_PATH) {
   await storage.write(path4, serializeRoster(roster));
   return path4;
 }
-async function loadRoster(storage, path4 = OPENTEAM_ROSTER_PATH) {
+async function loadRosterFile(storage, path4 = OPENTEAM_ROSTER_PATH) {
   const content = await storage.read(path4);
   if (content === undefined) {
-    return;
+    return { status: "absent", path: path4 };
+  }
+  const parsed = parseRosterResult(content);
+  if (!parsed.ok) {
+    return { status: "invalid", path: path4, error: parsed.error };
   }
-  return parseRoster(content);
+  return {
+    status: "loaded",
+    path: path4,
+    roster: enforceGuaranteedRoles(parsed.roster)
+  };
 }
 async function loadOrGenerateRoster(storage, generate, path4 = OPENTEAM_ROSTER_PATH) {
-  const existing = await loadRoster(storage, path4);
-  if (existing !== undefined) {
-    return { roster: existing, regenerated: false };
+  const existing = await loadRosterFile(storage, path4);
+  if (existing.status === "loaded") {
+    return { roster: existing.roster, regenerated: false };
   }
-  const roster = await generate();
-  await persistRoster(storage, roster, path4);
-  return { roster, regenerated: true };
+  const roster = enforceGuaranteedRoles(await generate());
+  if (existing.status === "absent") {
+    await persistRoster(storage, roster, path4);
+    return { roster, regenerated: true };
+  }
+  return {
+    roster,
+    regenerated: true,
+    recoveredFromInvalidPersisted: true,
+    invalidPersistedRosterError: existing.error.message
+  };
 }
 
 // src/plugin/orchestrateTool.ts
@@ -14497,7 +14932,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   const warn = deps.warn ?? console.warn;
   try {
     const db = await openDatabase(semantic.indexPath);
-    const index = createMemoryIndex(db);
+    const index = createMemoryIndex(db, warn);
     const rebuildResult = await rebuildMemoryIndexFromStorage(index, semantic.logPath, { storage: deps.storage });
     if (rebuildResult.rejectedLines > 0) {
       warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
@@ -14518,7 +14953,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.9.0",
+  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",
@@ -14643,6 +15078,18 @@ function createGitLastCommit(exec) {
 var execFileAsync2 = promisify2(execFile2);
 var AGENT_DIR2 = dirname5(ORCHESTRATOR_AGENT_PATH);
 var storage = createFsStorageProvider(process.cwd());
+async function readStoredRosterForDoctor() {
+  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);
 var migratePort = createMigrateAdapter(process.cwd());
 var nodeExec2 = async (command, args) => {
   try {
@@ -14798,6 +15245,9 @@ var deps = {
     storage,
     legacyTelemetryPath: path4
   }),
+  readDiagnostics: () => readDiagnosticEvents(DEFAULT_SESSIONS_DIR, {
+    storage
+  }),
   readGraphSnapshot: createGraphStatusSnapshotReader({
     storage,
     fallbackConfig: loadOpenTeamConfig({}),
@@ -14818,6 +15268,8 @@ var deps = {
   cachePort: realCacheAdapter,
   purge: createCliPurgeRuntime(),
   loopRuntime: createCliLoopRuntime(),
+  loadRosterForDoctor: readStoredRosterForDoctor,
+  auditRoster: auditStoredRosterForDoctor,
   version: PACKAGE_VERSION
 };
 function createCliPurgeRuntime() {
@@ -14887,7 +15339,7 @@ function createCliLoopRuntime() {
   const agentFileExists = (agentName) => storage.exists(`${AGENT_DIR2}/${agentName}.md`);
   const generate = () => generateRoster("openteam initial roster", fallbackRosterSource);
   return {
-    loadRoster: () => loadRoster(storage),
+    loadRosterFile: () => loadRosterFile(storage),
     loadOrGenerateRoster: async () => (await loadOrGenerateRoster(storage, generate)).roster,
     agentFileExists,
     readBacklog: (path4) => storage.read(path4),
@@ -14995,6 +15447,9 @@ async function main() {
       storage,
       legacyTelemetryPath: path4
     }),
+    readDiagnostics: () => readDiagnosticEvents(effectiveSessionsDir, {
+      storage
+    }),
     detectLegacyLayout: async () => detectLegacyLayout(legacyExists),
     migrateLegacyLayout: () => migrateLegacyLayout(planLegacyMigration(legacyExists), migratePort)
   };