@jmanuelcorral/openteam 0.9.0 → 0.9.2

package/dist/index.js

@@ -98,8 +98,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,
@@ -108,8 +108,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: false
   },
-  livingston: {
-    roleID: "livingston",
+  integration: {
+    roleID: "integration",
     opencodeAgent: "integration",
     defaultTier: "moderate",
     minReasoningTier: 4,
@@ -118,8 +118,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: false
   },
-  yen: {
-    roleID: "yen",
+  "local-runtime": {
+    roleID: "local-runtime",
     opencodeAgent: "local-runtime",
     defaultTier: "moderate",
     minReasoningTier: 3,
@@ -128,8 +128,8 @@ var TEAM_ROLES = {
     preferredFrontierModels: ["auto"],
     localFirst: true
   },
-  basher: {
-    roleID: "basher",
+  "routing-cost": {
+    roleID: "routing-cost",
     opencodeAgent: "routing-cost",
     defaultTier: "moderate",
     minReasoningTier: 3,
@@ -171,8 +171,8 @@ var TEAM_ROLES = {
     localFirst: true,
     requiresLocalRuntime: true
   },
-  linus: {
-    roleID: "linus",
+  tester: {
+    roleID: "tester",
     opencodeAgent: "tester",
     defaultTier: "simple",
     minReasoningTier: 2,
@@ -192,8 +192,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 {
@@ -2878,6 +2905,50 @@ var ModelCapabilityProfileSchema = z10.object({
   availability: z10.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 = z11.object({
@@ -2971,6 +3042,13 @@ var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
     "unknown"
   ])
 });
+var DiagnosticLevelSchema = z11.enum(["debug", "info", "warn", "error"]);
+var DiagnosticCodeSchema = z11.enum(DIAGNOSTIC_CODES);
+var DiagnosticEventSchema = EventBaseSchema.extend({
+  type: z11.literal("diagnostic"),
+  level: DiagnosticLevelSchema,
+  code: DiagnosticCodeSchema
+});
 var OpenTeamEventSchema = z11.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
@@ -2979,7 +3057,8 @@ var OpenTeamEventSchema = z11.discriminatedUnion("type", [
   DecisionEventSchema,
   ActivityEventSchema,
   SessionEndpointEventSchema,
-  ShadowDiagnosticEventSchema
+  ShadowDiagnosticEventSchema,
+  DiagnosticEventSchema
 ]);
 
 // src/telemetry/types.ts
@@ -3162,6 +3241,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) => {
@@ -3579,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**.",
@@ -3615,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",
@@ -5728,14 +5860,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 = {
@@ -6031,6 +6170,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;
@@ -6109,7 +6250,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);
@@ -6517,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));
@@ -6530,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) {
@@ -6537,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] };
 }
@@ -6569,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);
@@ -6582,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 };
   }
-  return parseRoster(content);
+  const parsed = parseRosterResult(content);
+  if (!parsed.ok) {
+    return { status: "invalid", path: path2, error: parsed.error };
+  }
+  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 = await generate();
-  await persistRoster(storage, roster, path2);
-  return { roster, regenerated: true };
+  const roster = enforceGuaranteedRoles(await generate());
+  if (existing.status === "absent") {
+    await persistRoster(storage, roster, path2);
+    return { roster, regenerated: true };
+  }
+  return {
+    roster,
+    regenerated: true,
+    recoveredFromInvalidPersisted: true,
+    invalidPersistedRosterError: existing.error.message
+  };
 }
 
 // src/plugin/availability.ts
@@ -7641,6 +7933,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) {
@@ -7676,6 +8067,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:");
@@ -9320,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))`,
@@ -9370,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) {
@@ -9455,9 +9860,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),
@@ -9465,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, {
@@ -9480,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({
@@ -9489,6 +9920,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 } : {},
@@ -9650,6 +10085,96 @@ function createCommandTool(deps) {
   });
 }
 
+// src/plugin/diagnostics.ts
+var PLUGIN_DIAGNOSTIC_SESSION_ID = "plugin";
+function asDiagnosticClient(client) {
+  if (typeof client !== "object" || client === null) {
+    return {};
+  }
+  return client;
+}
+function appLogOptions(diagnostic, directory) {
+  return {
+    body: {
+      service: "openteam",
+      level: diagnostic.level,
+      message: diagnosticDescription(diagnostic.code),
+      extra: {
+        code: diagnostic.code,
+        sessionID: diagnostic.sessionID,
+        source: "plugin"
+      }
+    },
+    ...directory !== undefined && directory.length > 0 ? { query: { directory } } : {}
+  };
+}
+function toastOptions(diagnostic, directory) {
+  return {
+    body: {
+      title: `openteam ${diagnostic.level}`,
+      message: `${diagnosticDescription(diagnostic.code)} Run \`openteam doctor\` for details.`,
+      variant: diagnostic.level === "error" ? "error" : "warning",
+      duration: 8000
+    },
+    ...directory !== undefined && directory.length > 0 ? { query: { directory } } : {}
+  };
+}
+function fireAndForget(run) {
+  try {
+    Promise.resolve(run()).catch(() => {});
+  } catch {}
+}
+function shouldToast(diagnostic, options) {
+  if (options?.toast !== undefined) {
+    return options.toast;
+  }
+  return diagnostic.level === "warn" || diagnostic.level === "error";
+}
+function createPluginDiagnosticChannel(deps) {
+  const client = asDiagnosticClient(deps.client);
+  const toastKeys = new Set;
+  let eventSink = deps.sink ?? createNullEventSink();
+  const emit = (input, options = {}) => {
+    const diagnostic = {
+      v: EVENT_SCHEMA_VERSION,
+      type: "diagnostic",
+      ts: deps.now(),
+      sessionID: input.sessionID ?? PLUGIN_DIAGNOSTIC_SESSION_ID,
+      level: input.level,
+      code: input.code
+    };
+    if (options.persist !== false) {
+      fireAndForget(() => eventSink.emit(diagnostic));
+    }
+    const log = client.app?.log;
+    if (typeof log === "function") {
+      fireAndForget(() => log.call(client.app, appLogOptions(diagnostic, deps.directory)));
+    }
+    if (shouldToast(diagnostic, options) && !toastKeys.has(input.code)) {
+      const showToast = client.tui?.showToast;
+      toastKeys.add(input.code);
+      if (typeof showToast === "function") {
+        fireAndForget(() => showToast.call(client.tui, toastOptions(diagnostic, deps.directory)));
+      }
+    }
+  };
+  return {
+    setEventSink: (sink) => {
+      eventSink = sink;
+    },
+    emit,
+    sink: (level, code, options = {}) => (message) => {
+      emit({ level, code }, options);
+    },
+    warn: (code, options = {}) => (message) => {
+      emit({ level: "warn", code }, options);
+    },
+    info: (code, options = {}) => (message) => {
+      emit({ level: "info", code }, options);
+    }
+  };
+}
+
 // src/plugin/graphTool.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 
@@ -11111,16 +11636,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(SCHEMA);
   const allRecordsFn = () => {
     const rows = db.query("SELECT id, payload FROM memory_records ORDER BY created_at ASC, id ASC").all();
@@ -11148,7 +11673,7 @@ function createMemoryIndex(db) {
   };
   const allRecordsWithWarning = () => {
     const result = allRecordsFn();
-    warnMemoryIndexRecordRejections(result);
+    warnMemoryIndexRecordRejections(result, warn);
     return result.records;
   };
   const state = () => {
@@ -11987,6 +12512,7 @@ function createOrchestrateTool(deps) {
           sink: deps.sink,
           now: deps.now,
           newDecisionID: deps.newDecisionID,
+          warn: deps.warn,
           warnedRoles: _pluginWarnedRoles,
           localRuntimeReachable: deps.localRuntimeReachable,
           reachableRuntimeIds: deps.reachableRuntimeIds,
@@ -12217,7 +12743,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.`);
@@ -12282,7 +12808,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // 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",
@@ -12395,24 +12921,24 @@ function createShellExec($) {
     };
   };
 }
-function logAvailabilityRefreshError(error) {
+function logAvailabilityRefreshError(error, warn) {
   const message = error instanceof Error ? error.message : String(error);
-  console.warn(`[openteam] availability refresh failed: ${message}`);
+  (warn ?? console.warn)(`[openteam] availability refresh failed: ${message}`);
 }
-function logTelemetryError(error) {
+function logTelemetryError(error, warn) {
   const message = error instanceof Error ? error.message : String(error);
-  console.warn(`[openteam] telemetry write failed: ${message}`);
+  (warn ?? console.warn)(`[openteam] telemetry write failed: ${message}`);
 }
-function logTelemetryWarning(message) {
-  console.warn(message);
+function logTelemetryWarning(message, warn) {
+  (warn ?? console.warn)(message);
 }
 var opencodeServerUrlLogged = false;
-function logOpencodeServerUrl(serverUrl) {
+function logOpencodeServerUrl(serverUrl, warn) {
   if (opencodeServerUrlLogged) {
     return;
   }
   opencodeServerUrlLogged = true;
-  console.warn(`[openteam] plugin initialisation ctx.serverUrl: ${serverUrl.toString()}`);
+  (warn ?? console.warn)(`[openteam] plugin initialisation ctx.serverUrl: ${serverUrl.toString()}`);
 }
 var MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES = 64;
 function createOpencodeVersionReadFailureLogger(maxCauses = MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES, warn) {
@@ -12434,26 +12960,25 @@ function createOpencodeVersionReadFailureLogger(maxCauses = MAX_LOGGED_OPENCODE_
     (warn ?? console.warn)(`[openteam] opencode version read failed: ${message}`);
   };
 }
-var logOpencodeVersionReadFailure = createOpencodeVersionReadFailureLogger();
-function warnNoRuntimeConfigFound(paths, optionsOnly, localModel) {
+function warnNoRuntimeConfigFound(paths, optionsOnly, localModel, warn) {
   const searched = paths.join(", ");
   const modelRef = localModel !== null ? `\`${localModel.providerID}/${localModel.modelID}\`` : "none (no local runtime configured)";
   if (optionsOnly) {
-    console.warn(`[openteam] config file not found (searched: ${searched}); ` + `routing is configured by plugin options only — local runtimes declared ` + `in ${paths[0] ?? searched} are not loaded. ` + `Local model in use: ${modelRef}. ` + `Create ${DEFAULT_CONFIG_PATH} to persist your local runtime configuration.`);
+    (warn ?? console.warn)(`[openteam] config file not found (searched: ${searched}); ` + `routing is configured by plugin options only — local runtimes declared ` + `in ${paths[0] ?? searched} are not loaded. ` + `Local model in use: ${modelRef}. ` + `Create ${DEFAULT_CONFIG_PATH} to persist your local runtime configuration.`);
   } else {
-    console.warn(`[openteam] no config file found at ${searched}. ` + `Routing uses schema defaults — local model: ${modelRef}. ` + `Privacy-sensitive tasks under forceLocalOnSensitive will be routed to frontier ` + `(no local runtime configured). Run \`openteam setup\` or create ${DEFAULT_CONFIG_PATH}.`);
+    (warn ?? console.warn)(`[openteam] no config file found at ${searched}. ` + `Routing uses schema defaults — local model: ${modelRef}. ` + `Privacy-sensitive tasks under forceLocalOnSensitive will be routed to frontier ` + `(no local runtime configured). Run \`openteam setup\` or create ${DEFAULT_CONFIG_PATH}.`);
   }
 }
 function warnInertPrivacySetting(paths, warn) {
   (warn ?? console.warn)(`[openteam] privacyMode is "forceLocalOnSensitive" but no local runtime is configured ` + `(searched: ${paths.join(", ")}). ` + `Privacy-sensitive tasks will be routed to frontier and labelled "frontier" in telemetry ` + `(rationale: "privacy-force-local-none-configured"). ` + `To keep sensitive prompts local, configure a local runtime in ` + `${paths[0] ?? DEFAULT_CONFIG_PATH} or use the alwaysLocal override per request.`);
 }
-function warnSoakEvidenceRejections(result) {
+function warnSoakEvidenceRejections(result, warn) {
   if (result.rejectedLines === 0) {
     return;
   }
-  console.warn(`[openteam] soak evidence reader rejected ${result.rejectedLines} observation line(s); cutover gate evidence may be incomplete.`);
+  (warn ?? console.warn)(`[openteam] soak evidence reader rejected ${result.rejectedLines} observation line(s); cutover gate evidence may be incomplete.`);
   for (const rejection of result.rejections) {
-    console.warn(`[openteam]   • ${rejection.file}:${rejection.lineNumber}: ${rejection.detail}`);
+    (warn ?? console.warn)(`[openteam]   • ${rejection.file}:${rejection.lineNumber}: ${rejection.detail}`);
   }
 }
 var SHADOW_CERT_PATH = "artifacts/graph-shadow-certificate.json";
@@ -12630,7 +13155,7 @@ function createLazyOpencodeVersionReader(serverUrl, options = {}) {
     }
   };
 }
-async function buildGateInput(config, storage, opencodeVersion) {
+async function buildGateInput(config, storage, opencodeVersion, warn) {
   const shadow = await readAndParseCertificate(storage, SHADOW_CERT_PATH, (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => shadowCertificateBindingDigest(cert.evidence));
   const shadowDigest = shadow.status === "valid" ? shadow.digest : "0".repeat(64);
   const release = await readAndParseCertificate(storage, RELEASE_CERT_PATH, (raw) => parseReleaseCertificate(raw, opencodeVersion, shadowDigest), (cert) => cert.digest);
@@ -12638,7 +13163,7 @@ async function buildGateInput(config, storage, opencodeVersion) {
   try {
     const recorderPorts = recorderPortsFromStorage(storage);
     const chainRead = await readAllChains(recorderPorts, SOAK_EVIDENCE_DIR);
-    warnSoakEvidenceRejections(chainRead);
+    warnSoakEvidenceRejections(chainRead, warn);
     if (chainRead.chains.length > 0) {
       soakLedgerDigest = canonicalLedger(chainRead.chains);
     }
@@ -12667,8 +13192,8 @@ function recorderPortsFromStorage(storage) {
     id: { randomUUID: () => crypto.randomUUID() }
   };
 }
-async function buildMemoryInjectorFromConfig(config, storage) {
-  const runtime = await buildMemoryRuntimeFromConfig(config, { storage }, { requireInjectionEnabled: true });
+async function buildMemoryInjectorFromConfig(config, storage, warn) {
+  const runtime = await buildMemoryRuntimeFromConfig(config, { storage, ...warn !== undefined ? { warn } : {} }, { requireInjectionEnabled: true });
   if (runtime === undefined) {
     return;
   }
@@ -12685,8 +13210,10 @@ async function buildMemoryInjectorFromConfig(config, storage) {
     }
   });
 }
-function createEventSink(rawOptions, storage = createFsStorageProvider(process.cwd())) {
+function createEventSink(rawOptions, storage = createFsStorageProvider(process.cwd()), loggers = {}) {
   const options = telemetryOptions(rawOptions);
+  const onError = loggers.onError !== undefined ? loggers.onError : (error) => logTelemetryError(error);
+  const onWarn = loggers.onWarn !== undefined ? loggers.onWarn : (message) => logTelemetryWarning(message);
   const { sink } = createTelemetryEventSink({
     enabled: options.enabled,
     otel: OtelBackendConfigSchema.parse({
@@ -12697,13 +13224,13 @@ function createEventSink(rawOptions, storage = createFsStorageProvider(process.c
     eventLog: {
       dir: options.sessionsDir,
       storage,
-      onError: logTelemetryError
+      onError
     },
     otel: {
       env: (name) => process.env[name],
       buildExporter: createOtlpSpanExporter,
-      onError: logTelemetryError,
-      onWarn: logTelemetryWarning
+      onError,
+      onWarn
     }
   });
   return sink;
@@ -12721,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 }) => {
@@ -12783,6 +13322,9 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
       storage,
       legacyTelemetryPath: path4
     }),
+    readDiagnostics: () => readDiagnosticEvents(sessionsDir, {
+      storage
+    }),
     readGraphSnapshot: createGraphStatusSnapshotReader({
       storage,
       fallbackConfig: config,
@@ -12801,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
   };
 }
@@ -12876,7 +13420,13 @@ function createLoopTool(deps) {
   });
 }
 var server = async (ctx, rawOptions) => {
-  logOpencodeServerUrl(ctx.serverUrl);
+  const now = () => Date.now();
+  const diagnostics = createPluginDiagnosticChannel({
+    client: ctx.client,
+    directory: ctx.directory,
+    now
+  });
+  logOpencodeServerUrl(ctx.serverUrl, diagnostics.info("opencode-server-url", { persist: false, toast: false }));
   const storage = createFsStorageProvider(ctx.directory || ctx.worktree || process.cwd());
   const runtimeConfig = await loadRuntimeOpenTeamConfig(storage, rawOptions);
   const config = runtimeConfig.config;
@@ -12888,13 +13438,23 @@ var server = async (ctx, rawOptions) => {
   const cache = createAvailabilityCache({
     config,
     registry,
-    onRefreshError: logAvailabilityRefreshError
+    onRefreshError: (error) => logAvailabilityRefreshError(error, diagnostics.warn("availability-refresh-failed", { toast: false }))
   });
   cache.refresh();
   const telemetryPath = telemetryOptions(rawOptions).path;
   const sessionsDir = telemetryOptions(rawOptions).sessionsDir;
-  const sink = createEventSink(rawOptions, storage);
-  const injectMemory = await buildMemoryInjectorFromConfig(config, storage);
+  const sink = createEventSink(rawOptions, storage, {
+    onError: (error) => logTelemetryError(error, diagnostics.warn("telemetry-write-failed", {
+      persist: false,
+      toast: false
+    })),
+    onWarn: (message) => logTelemetryWarning(message, diagnostics.warn("telemetry-warning", {
+      persist: false,
+      toast: false
+    }))
+  });
+  diagnostics.setEventSink(sink);
+  const injectMemory = await buildMemoryInjectorFromConfig(config, storage, diagnostics.warn("memory-runtime-warning", { toast: false }));
   const sessionTracker = createSessionTracker();
   const hooks = createHooks(config, cache.get, injectMemory === undefined ? {
     sink,
@@ -12906,7 +13466,6 @@ var server = async (ctx, rawOptions) => {
   });
   const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage, runtimeConfig.source, rawOptions);
   const toolcalls = createToolcallTracker({ sink });
-  const now = () => Date.now();
   const announcedSessions = new Set;
   const announceEndpoint = (sessionID) => {
     if (sessionID === undefined || announcedSessions.has(sessionID)) {
@@ -12923,24 +13482,25 @@ var server = async (ctx, rawOptions) => {
   };
   let graphConfig = resolveGraphConfig(config, runtimeConfig.source);
   if (!runtimeConfig.fileFound) {
-    warnNoRuntimeConfigFound(runtimeConfig.searchedPaths, runtimeConfig.optionsFound, localDefault(config));
+    warnNoRuntimeConfigFound(runtimeConfig.searchedPaths, runtimeConfig.optionsFound, localDefault(config), diagnostics.warn("config-missing"));
   }
   if (config.privacyMode === "forceLocalOnSensitive" && localDefault(config) === null) {
-    warnInertPrivacySetting(runtimeConfig.searchedPaths);
+    warnInertPrivacySetting(runtimeConfig.searchedPaths, diagnostics.warn("privacy-inert"));
   }
   const getOpencodeVersion = createLazyOpencodeVersionReader(ctx.serverUrl, {
     client: ctx.client,
-    onFailure: logOpencodeVersionReadFailure
+    onFailure: createOpencodeVersionReadFailureLogger(MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES, diagnostics.warn("opencode-version-read-failed", { toast: false }))
   });
   if (isGateApplicable(graphConfig.effectiveMode)) {
     const opencodeVersion = await getOpencodeVersion();
-    const gateInput = await buildGateInput(config, storage, opencodeVersion);
+    const gateInput = await buildGateInput(config, storage, opencodeVersion, diagnostics.warn("soak-evidence-rejected", { toast: false }));
     const gateResult = evaluateGraphGate(gateInput);
     graphConfig = applyGraphGate(graphConfig, gateResult);
     if (graphConfig.gateDenied === true && graphConfig.gateViolations !== undefined) {
-      console.warn("[openteam] ⛔ cutover gate denied active mode — degrading to off");
+      const graphGateWarn = diagnostics.warn("graph-gate-denied");
+      graphGateWarn("[openteam] ⛔ cutover gate denied active mode — degrading to off");
       for (const v of graphConfig.gateViolations) {
-        console.warn(`[openteam]   • ${v.code}: ${v.detail}`);
+        graphGateWarn(`[openteam]   • ${v.code}: ${v.detail}`);
       }
     }
   }
@@ -13002,14 +13562,16 @@ var server = async (ctx, rawOptions) => {
     observeLegacyExecution: graphSurface.observeLegacyExecution,
     localRuntimeReachable,
     reachableRuntimeIds: probeReachableRuntimeIds,
-    runtimeLimiter
+    runtimeLimiter,
+    warn: diagnostics.warn("unknown-role")
   });
   const memoryTool = createMemoryTool({
     config,
     storage,
     now,
     localRuntimeReachable,
-    fetch: globalThis.fetch
+    fetch: globalThis.fetch,
+    warn: diagnostics.warn("memory-extraction-warning", { toast: false })
   });
   const loopTool = createLoopTool({
     storage,
@@ -13019,6 +13581,7 @@ var server = async (ctx, rawOptions) => {
       sink,
       now,
       newDecisionID: () => crypto.randomUUID(),
+      warn: diagnostics.warn("unknown-role"),
       localRuntimeReachable,
       reachableRuntimeIds: probeReachableRuntimeIds,
       runtimeLimiter
@@ -13075,7 +13638,6 @@ export {
   readOpencodeVersion,
   logTelemetryWarning,
   logTelemetryError,
-  logOpencodeVersionReadFailure,
   logOpencodeServerUrl,
   logAvailabilityRefreshError,
   isMissingFile,