@jmanuelcorral/openteam 0.9.0 → 0.9.1

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 = ["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) => {
@@ -5728,14 +5810,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 +6120,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 +6200,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);
@@ -7641,6 +7732,34 @@ 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 agentModelsSection(diagnostics, searchedPaths) {
   const lines = ["  agent models:"];
   if (diagnostics.length === 0) {
@@ -7676,6 +7795,9 @@ function renderDoctor(input) {
     }
   }
   lines.push(`  telemetry: ${input.telemetryPath} — ${input.telemetryRecords} record(s)`);
+  if (input.diagnostics !== undefined) {
+    lines.push(...diagnosticsSection(input.diagnostics));
+  }
   if (input.otelBackend !== undefined) {
     const otel = input.otelBackend;
     lines.push("  opentelemetry:");
@@ -9455,9 +9577,17 @@ 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([
+      const [
+        snapshots,
+        records,
+        diagnostics,
+        cacheEntries,
+        agentFiles,
+        opencodeConfig
+      ] = 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),
@@ -9489,6 +9619,7 @@ async function runCli(argv, deps) {
           telemetryRecords: records.length,
           agentModels,
           opencodeConfigPaths,
+          ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
           ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
           ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
           ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
@@ -9650,6 +9781,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 +11332,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 +11369,7 @@ function createMemoryIndex(db) {
   };
   const allRecordsWithWarning = () => {
     const result = allRecordsFn();
-    warnMemoryIndexRecordRejections(result);
+    warnMemoryIndexRecordRejections(result, warn);
     return result.records;
   };
   const state = () => {
@@ -11987,6 +12208,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 +12439,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 +12504,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.9.0",
+  version: "0.9.1",
   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 +12617,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 +12656,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 +12851,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 +12859,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 +12888,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 +12906,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 +12920,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;
@@ -12783,6 +13006,9 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
       storage,
       legacyTelemetryPath: path4
     }),
+    readDiagnostics: () => readDiagnosticEvents(sessionsDir, {
+      storage
+    }),
     readGraphSnapshot: createGraphStatusSnapshotReader({
       storage,
       fallbackConfig: config,
@@ -12876,7 +13102,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 +13120,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 +13148,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 +13164,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 +13244,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 +13263,7 @@ var server = async (ctx, rawOptions) => {
       sink,
       now,
       newDecisionID: () => crypto.randomUUID(),
+      warn: diagnostics.warn("unknown-role"),
       localRuntimeReachable,
       reachableRuntimeIds: probeReachableRuntimeIds,
       runtimeLimiter
@@ -13075,7 +13320,6 @@ export {
   readOpencodeVersion,
   logTelemetryWarning,
   logTelemetryError,
-  logOpencodeVersionReadFailure,
   logOpencodeServerUrl,
   logAvailabilityRefreshError,
   isMissingFile,