@jmanuelcorral/openteam 0.13.0 → 0.14.0

package/dist/index.js

@@ -95,8 +95,8 @@ var AgentRoleProfileSchema = z.object({
   preferredFrontierModels: z.array(z.union([modelSelectionSchema, z.literal("auto")])),
   localFirst: z.boolean(),
   requiresLocalRuntime: z.boolean().optional(),
-  localRuntimes: z.array(z.enum(["ollama", "lmstudio", "foundry-local", "lemonade"])).optional(),
-  localModels: z.partialRecord(z.enum(["ollama", "lmstudio", "foundry-local", "lemonade"]), z.string().min(1)).optional()
+  localRuntimes: z.array(z.string().min(1)).optional(),
+  localModels: z.record(z.string().min(1), z.string().min(1)).optional()
 }).strict();
 var TEAM_ROLES = {
   architect: {
@@ -403,14 +403,33 @@ var defaultFrontierModel = {
   modelID: "claude-sonnet-4-5"
 };
 var DEFAULT_LOCAL_MAX_CONCURRENCY = 4;
+var LocalRuntimeKindSchema = z2.enum([
+  "ollama",
+  "lmstudio",
+  "foundry-local",
+  "lemonade"
+]);
 var LocalRuntimeSchema = z2.object({
-  id: z2.enum(["ollama", "lmstudio", "foundry-local", "lemonade"]),
+  id: z2.string().min(1),
+  kind: LocalRuntimeKindSchema.optional(),
   enabled: z2.boolean().default(true),
   baseURL: z2.string().url().optional(),
   discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema,
   maxConcurrency: z2.number().int().positive().optional()
-}).strict();
+}).strict().superRefine((runtime, ctx) => {
+  const resolvedKind = runtime.kind ?? runtime.id;
+  if (!LocalRuntimeKindSchema.safeParse(resolvedKind).success) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["kind"],
+      message: `local runtime "${runtime.id}" has no resolvable kind: add "kind" ` + "(one of ollama, lmstudio, foundry-local, lemonade), since the id is " + "not itself a runtime kind."
+    });
+  }
+});
+function localRuntimeKind(runtime) {
+  return runtime.kind ?? runtime.id;
+}
 var MemoryScopeSchema = z2.enum(["project", "user"]);
 var MemoryExtractionModeSchema = z2.enum([
   "local",
@@ -492,7 +511,23 @@ var OpenTeamConfigObjectSchema = z2.object({
     localOnly: false
   }),
   local: z2.object({
-    runtimes: z2.array(LocalRuntimeSchema).default([])
+    runtimes: z2.array(LocalRuntimeSchema).default([]).superRefine((runtimes, ctx) => {
+      const seen = new Set;
+      for (let index = 0;index < runtimes.length; index += 1) {
+        const runtime = runtimes[index];
+        if (runtime === undefined) {
+          continue;
+        }
+        if (seen.has(runtime.id)) {
+          ctx.addIssue({
+            code: z2.ZodIssueCode.custom,
+            path: [index, "id"],
+            message: `duplicate local runtime id "${runtime.id}": each local.runtimes[].id must be unique within the array.`
+          });
+        }
+        seen.add(runtime.id);
+      }
+    })
   }).strict().default({
     runtimes: []
   }),
@@ -2681,6 +2716,7 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
     "local.runtimes[]",
     [
       "id",
+      "kind",
       "enabled",
       "baseURL",
       "discovery",
@@ -3031,6 +3067,16 @@ var MeetingEventSchema = EventBaseSchema.extend({
   roles: z11.array(z11.string().min(1)),
   decisionIDs: z11.array(z11.string().min(1)).optional()
 });
+var QueueEventSchema = EventBaseSchema.extend({
+  type: z11.literal("queue"),
+  runtimeId: z11.string().min(1),
+  waitedMs: z11.number().finite().min(0),
+  activeCount: z11.number().int().min(0),
+  queuedCount: z11.number().int().min(0),
+  decisionID: z11.string().min(1).optional(),
+  agent: z11.string().min(1).optional(),
+  batchID: z11.string().min(1).optional()
+});
 var DecisionEventSchema = EventBaseSchema.extend({
   type: z11.literal("decision"),
   agent: z11.string().min(1).optional(),
@@ -3076,6 +3122,7 @@ var OpenTeamEventSchema = z11.discriminatedUnion("type", [
   MessageEventSchema,
   ToolcallEventSchema,
   MeetingEventSchema,
+  QueueEventSchema,
   DecisionEventSchema,
   ActivityEventSchema,
   SessionEndpointEventSchema,
@@ -5052,11 +5099,14 @@ function createRuntimeConcurrencyLimiter(options) {
     acquire(runtimeId) {
       const immediate = tryAcquire(runtimeId);
       if (immediate !== undefined) {
-        return Promise.resolve(immediate);
+        return Promise.resolve({ release: immediate, waitedMs: 0 });
       }
       const state = stateFor(runtimeId);
+      const queuedAt = options.now();
       return new Promise((resolve3) => {
-        state.queue.push(resolve3);
+        state.queue.push((release) => {
+          resolve3({ release, waitedMs: options.now() - queuedAt });
+        });
       });
     },
     activeCount(runtimeId) {
@@ -5414,10 +5464,11 @@ class RuntimeRegistry {
         continue;
       }
       const probedAt = this.clock();
-      const adapter = this.adapters[runtime.id];
+      const adapter = this.adapters[localRuntimeKind(runtime)];
       const options = this.createProbeOptions(runtime, probedAt);
       try {
-        snapshots.push(await adapter.probe(options));
+        const snapshot = await adapter.probe(options);
+        snapshots.push({ ...snapshot, id: runtime.id });
       } catch (error) {
         snapshots.push(unavailableSnapshot({
           id: runtime.id,
@@ -5437,7 +5488,7 @@ class RuntimeRegistry {
     if (runtime.baseURL !== undefined) {
       options.baseURL = runtime.baseURL;
     }
-    if (runtime.id === "foundry-local" && runtime.discovery !== "manual" && this.foundryDiscovery !== undefined) {
+    if (localRuntimeKind(runtime) === "foundry-local" && runtime.discovery !== "manual" && this.foundryDiscovery !== undefined) {
       options.discovery = this.foundryDiscovery;
     }
     return options;
@@ -6538,6 +6589,28 @@ async function safeEmit(sink, event) {
     await sink.emit(event);
   } catch {}
 }
+function buildQueueEvent(observation, sessionID, ts, correlation) {
+  const event = {
+    v: EVENT_SCHEMA_VERSION,
+    type: "queue",
+    ts,
+    sessionID,
+    runtimeId: observation.runtimeId,
+    waitedMs: observation.waitedMs,
+    activeCount: observation.activeCount,
+    queuedCount: observation.queuedCount
+  };
+  if (correlation.decisionID !== undefined) {
+    event.decisionID = correlation.decisionID;
+  }
+  if (correlation.agent !== undefined) {
+    event.agent = correlation.agent;
+  }
+  if (correlation.batchID !== undefined) {
+    event.batchID = correlation.batchID;
+  }
+  return event;
+}
 async function runRoleTaskWithCorrelation(input, deps, correlation, batch) {
   if (getRoleProfile(input.roleID, input.config.orchestrator?.roles) === undefined) {
     warnUnknownRole(input.roleID, deps.warn, deps.warnedRoles);
@@ -6575,16 +6648,40 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch) {
   const subsessionDeps = deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs };
   const runtimeId = selection.runtimeId;
   let release;
+  let queueObservation;
   if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
-    release = deps.runtimeLimiter.tryAcquire(runtimeId);
+    const limiter = deps.runtimeLimiter;
+    release = limiter.tryAcquire(runtimeId);
+    let waitedMs = 0;
     if (release === undefined) {
-      release = await deps.runtimeLimiter.acquire(runtimeId);
-    }
+      const acquisition = await limiter.acquire(runtimeId);
+      release = acquisition.release;
+      waitedMs = acquisition.waitedMs;
+    }
+    queueObservation = {
+      runtimeId,
+      waitedMs,
+      activeCount: limiter.activeCount(runtimeId),
+      queuedCount: limiter.queuedCount(runtimeId)
+    };
   }
   try {
     const subsession = await runSubsession(deps.client, request, subsessionDeps);
     const record = buildRecord(input, decision2, subsession, deps, correlation.decisionID, correlation.batchID);
     await safeEmit(deps.sink, correlatedCostRecordToRouteEvent(record));
+    if (queueObservation !== undefined) {
+      const sessionID = recordSessionID(input, subsession);
+      if (sessionID !== undefined) {
+        const queueCorrelation = {
+          decisionID: correlation.decisionID,
+          agent: input.roleID
+        };
+        if (correlation.batchID !== undefined) {
+          queueCorrelation.batchID = correlation.batchID;
+        }
+        await safeEmit(deps.sink, buildQueueEvent(queueObservation, sessionID, deps.now(), queueCorrelation));
+      }
+    }
     return { decision: decision2, subsession, record };
   } finally {
     release?.();
@@ -7505,6 +7602,60 @@ function createTelemetryEventSink(options, deps) {
   return { sink, resolution };
 }
 
+// src/telemetry/queueWait.ts
+function percentile(sortedAsc, p) {
+  const rank = Math.ceil(p / 100 * sortedAsc.length);
+  const index = Math.min(Math.max(rank, 1), sortedAsc.length) - 1;
+  return sortedAsc[index] ?? 0;
+}
+function summarizeGroup(runtimeId, waits, maxQueued, maxActive) {
+  const sorted = [...waits].sort((a, b) => a - b);
+  return {
+    runtimeId,
+    samples: sorted.length,
+    contended: sorted.filter((wait) => wait > 0).length,
+    p50Ms: percentile(sorted, 50),
+    p95Ms: percentile(sorted, 95),
+    maxMs: sorted[sorted.length - 1] ?? 0,
+    maxQueued,
+    maxActive
+  };
+}
+function summarizeQueueWaits(events) {
+  if (events.length === 0) {
+    return;
+  }
+  const allWaits = [];
+  let overallMaxQueued = 0;
+  let overallMaxActive = 0;
+  const byRuntime = new Map;
+  for (const event of events) {
+    allWaits.push(event.waitedMs);
+    overallMaxQueued = Math.max(overallMaxQueued, event.queuedCount);
+    overallMaxActive = Math.max(overallMaxActive, event.activeCount);
+    let group = byRuntime.get(event.runtimeId);
+    if (group === undefined) {
+      group = { waits: [], maxQueued: 0, maxActive: 0 };
+      byRuntime.set(event.runtimeId, group);
+    }
+    group.waits.push(event.waitedMs);
+    group.maxQueued = Math.max(group.maxQueued, event.queuedCount);
+    group.maxActive = Math.max(group.maxActive, event.activeCount);
+  }
+  const overall = summarizeGroup("*", allWaits, overallMaxQueued, overallMaxActive);
+  const perRuntime = [...byRuntime.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([runtimeId, group]) => summarizeGroup(runtimeId, group.waits, group.maxQueued, group.maxActive));
+  return {
+    samples: overall.samples,
+    contended: overall.contended,
+    p50Ms: overall.p50Ms,
+    p95Ms: overall.p95Ms,
+    maxMs: overall.maxMs,
+    maxQueued: overall.maxQueued,
+    maxActive: overall.maxActive,
+    perRuntime
+  };
+}
+
 // src/web/paths.ts
 var DEFAULT_DECISIONS_PATH = ".opencode/openteam/decisions.md";
 
@@ -7982,6 +8133,24 @@ function isNetworkRuntime(baseURL) {
     return false;
   }
 }
+function queueWaitSection(view) {
+  const lines = ["  local queue wait (#144, per openteam process):"];
+  const summary = view.summary;
+  if (summary === undefined || summary.samples === 0) {
+    lines.push("    (no queue samples recorded yet — run an orchestrated load, then re-run doctor)");
+    return lines;
+  }
+  const mark = summary.contended > 0 ? "⚠" : "✓";
+  lines.push(`  ${mark} ${summary.samples} dispatch(es), ${summary.contended} queued — ` + `p50 ${summary.p50Ms}ms · p95 ${summary.p95Ms}ms · max ${summary.maxMs}ms`);
+  lines.push(`    peak depth: ${summary.maxActive} active · ${summary.maxQueued} queued`);
+  for (const runtime of summary.perRuntime) {
+    lines.push(`    ${runtime.runtimeId.padEnd(14)} ${runtime.samples} sample(s), ` + `${runtime.contended} queued — p50 ${runtime.p50Ms}ms · p95 ${runtime.p95Ms}ms · ` + `max ${runtime.maxMs}ms · peak ${runtime.maxActive} active/${runtime.maxQueued} queued`);
+  }
+  if (summary.contended > 0) {
+    lines.push("    Lower a runtime's maxConcurrency in .opencode/openteam.json to leave slots for interactive traffic.");
+  }
+  return lines;
+}
 function failureReasonText(reason, searchedPaths) {
   switch (reason) {
     case "provider-not-configured": {
@@ -8141,6 +8310,20 @@ function rosterHealthSection(audit, loadError, rosterRoleCount) {
   }
   return lines;
 }
+function gitignoreSection(gitignore) {
+  if (gitignore.missingRules.length === 0) {
+    return [
+      "  gitignore:",
+      `    ✓ ${gitignore.path} ignores openteam's generated runtime state.`
+    ];
+  }
+  const quoted = gitignore.missingRules.map((rule) => `\`${rule}\``).join(", ");
+  const lines = ["  gitignore:"];
+  lines.push(gitignore.exists ? `    ✗ ${gitignore.path} is missing openteam ignore rule(s): ${gitignore.missingRules.join(", ")}` : `    ✗ ${gitignore.path} does not exist, so no openteam ignore rule(s) are in place: ${gitignore.missingRules.join(", ")}`);
+  lines.push("      problem: openteam writes machine-local runtime output (telemetry, graph state, soak recordings) that must not be committed.");
+  lines.push(`      remedy: add ${quoted} to ${gitignore.path} (or re-run \`openteam setup\`), then re-run \`openteam doctor\`.`);
+  return lines;
+}
 function agentModelsSection(diagnostics, searchedPaths) {
   const lines = ["  agent models:"];
   if (diagnostics.length === 0) {
@@ -8184,10 +8367,16 @@ function renderDoctor(input) {
     lines.push(`  ⚠ ${snapshot.id} is reached over the network: its ${cap}-slot cap is enforced per openteam process, so`, "    two processes at once (an opencode session plus 'openteam console') can together exceed it.");
   }
   lines.push(`  telemetry: ${input.telemetryPath} — ${input.telemetryRecords} record(s)`);
+  if (input.queueWait !== undefined) {
+    lines.push(...queueWaitSection(input.queueWait));
+  }
   if (input.diagnostics !== undefined) {
     lines.push(...diagnosticsSection(input.diagnostics));
   }
   lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount));
+  if (input.gitignore !== undefined) {
+    lines.push(...gitignoreSection(input.gitignore));
+  }
   if (input.otelBackend !== undefined) {
     const otel = input.otelBackend;
     lines.push("  opentelemetry:");
@@ -8453,6 +8642,143 @@ function renderMigration(report) {
 // src/commands/purge.ts
 import * as path3 from "node:path";
 
+// src/storage/graph/soakRecorder.ts
+var SOAK_EVIDENCE_DIR = ".opencode/soak";
+var SOAK_RECORDER_BASE_DIR = ".opencode";
+var SOAK_RECORDER_ID_FILENAME = "soak-recorder-id";
+var SOAK_RECORDER_ID_PATH = `${SOAK_RECORDER_BASE_DIR}/${SOAK_RECORDER_ID_FILENAME}`;
+async function ensureRecorderId(ports, basePath) {
+  const idPath = `${basePath}/${SOAK_RECORDER_ID_FILENAME}`;
+  if (await ports.fs.exists(idPath)) {
+    const id = (await ports.fs.readFile(idPath)).trim();
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
+      return id;
+    }
+  }
+  const newId = ports.id.randomUUID();
+  await ports.fs.writeFile(idPath, newId);
+  return newId;
+}
+async function readAllChains(ports, evidenceDir) {
+  if (!await ports.fs.exists(evidenceDir)) {
+    return { chains: [], rejectedLines: 0, rejections: [] };
+  }
+  const files = await ports.fs.readDir(evidenceDir);
+  const chains = [];
+  const rejections = [];
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) {
+      continue;
+    }
+    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
+    const lines = content.split(`
+`);
+    const observations = [];
+    for (const [index, line] of lines.entries()) {
+      if (line.trim().length === 0) {
+        continue;
+      }
+      const lineNumber = index + 1;
+      let rawParsed;
+      try {
+        rawParsed = JSON.parse(line);
+      } catch {
+        rejections.push({ file, lineNumber, detail: "invalid JSON" });
+        continue;
+      }
+      const parsed = SoakObservationSchema.safeParse(rawParsed);
+      if (parsed.success) {
+        observations.push(parsed.data);
+      } else {
+        rejections.push({
+          file,
+          lineNumber,
+          detail: formatSoakObservationIssues(parsed.error.issues)
+        });
+      }
+    }
+    if (observations.length > 0) {
+      chains.push(observations);
+    }
+  }
+  return { chains, rejectedLines: rejections.length, rejections };
+}
+function formatSoakObservationIssues(issues) {
+  return issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+}
+function canonicalObservationPreimage2(obs) {
+  return JSON.stringify({
+    version: obs.version,
+    seq: obs.seq,
+    timestamp: obs.timestamp,
+    platform: obs.platform,
+    opencodeVersion: obs.opencodeVersion,
+    provenance: obs.provenance,
+    traceDigest: obs.traceDigest,
+    criticalDivergences: obs.criticalDivergences,
+    privacy: obs.privacy,
+    duplicateEffects: obs.duplicateEffects,
+    modelVerification: obs.modelVerification
+  });
+}
+async function appendObservation(ports, evidenceDir, recorderId, input) {
+  if (input.opencodeVersion === "unknown") {
+    throw new Error("opencode-version-unreadable");
+  }
+  await ports.fs.mkdir(evidenceDir);
+  const chainPath = `${evidenceDir}/${recorderId}.jsonl`;
+  let seq = 0;
+  let prevChainDigest = "0".repeat(64);
+  if (await ports.fs.exists(chainPath)) {
+    const content = await ports.fs.readFile(chainPath);
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    if (lines.length > 0) {
+      const lastLine = lines[lines.length - 1];
+      let rawParsed;
+      try {
+        rawParsed = JSON.parse(lastLine);
+      } catch {
+        throw new Error("corrupt chain tail: invalid JSON");
+      }
+      const parsed = SoakObservationSchema.safeParse(rawParsed);
+      if (!parsed.success) {
+        const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+        throw new Error(`corrupt chain tail: ${detail}`);
+      }
+      seq = parsed.data.seq + 1;
+      prevChainDigest = parsed.data.chainDigest;
+    }
+  }
+  const timestamp = ports.clock.now();
+  const base = {
+    version: 1,
+    seq,
+    timestamp,
+    platform: input.platform,
+    opencodeVersion: input.opencodeVersion,
+    provenance: input.provenance,
+    traceDigest: input.traceDigest,
+    criticalDivergences: input.criticalDivergences,
+    privacy: input.privacy,
+    duplicateEffects: input.duplicateEffects,
+    modelVerification: input.modelVerification
+  };
+  const preimage = canonicalObservationPreimage2(base);
+  const chainDigest = sha256Hex(prevChainDigest + preimage);
+  const observation = { ...base, chainDigest };
+  assertReferenceOnly(observation);
+  const line = JSON.stringify(observation);
+  if (await ports.fs.exists(chainPath)) {
+    const existing = await ports.fs.readFile(chainPath);
+    await ports.fs.writeFile(chainPath, `${existing}
+${line}`);
+  } else {
+    await ports.fs.writeFile(chainPath, line);
+  }
+  return observation;
+}
+
 // src/commands/setup.ts
 var OPENTEAM_PLUGIN_SPEC = "@jmanuelcorral/openteam";
 var OPENCODE_GITIGNORE_PATH = ".opencode/.gitignore";
@@ -8464,6 +8790,11 @@ var GENERATED_OPENTEAM_STATE_PATHS = [
   DEFAULT_STORAGE_SQLITE_INDEX_PATH,
   DEFAULT_MEMORY_INDEX_PATH
 ];
+var GENERATED_OPENTEAM_STATE_GROUPS = [
+  { kind: "dir", paths: GENERATED_OPENTEAM_STATE_PATHS },
+  { kind: "dir", paths: [SOAK_EVIDENCE_DIR] },
+  { kind: "file", paths: [SOAK_RECORDER_ID_PATH] }
+];
 var OPENCODE_DIR = ".opencode";
 var AGENT_DIR = `${OPENCODE_DIR}/agent`;
 function splitSetupPath(path3) {
@@ -8484,18 +8815,27 @@ function commonGeneratedStateRoot(paths) {
   }
   return common.join("/");
 }
-function generatedStateIgnoreRule() {
-  const root = commonGeneratedStateRoot(GENERATED_OPENTEAM_STATE_PATHS);
+function generatedStateIgnoreRule(group) {
+  const root = commonGeneratedStateRoot(group.paths);
   const opencodePrefix = `${OPENCODE_DIR}/`;
   if (!root.startsWith(opencodePrefix)) {
     throw new Error(`generated openteam state path is outside ${OPENCODE_DIR}`);
   }
-  return `${root.slice(opencodePrefix.length)}/`;
+  const rule = root.slice(opencodePrefix.length);
+  return group.kind === "dir" ? `${rule}/` : rule;
 }
-var OPENCODE_GITIGNORE_GENERATED_STATE_RULES = [
-  generatedStateIgnoreRule()
-];
+var OPENCODE_GITIGNORE_GENERATED_STATE_RULES = GENERATED_OPENTEAM_STATE_GROUPS.map(generatedStateIgnoreRule);
 var LEGACY_OPENCODE_GITIGNORE_STATE_RULES = ["openteam/"];
+function normalizeGitignoreRule(line) {
+  return line.trim().replace(/^\/+/, "");
+}
+function activeGitignoreRules(gitignore) {
+  return gitignore.split(/\r?\n/).map(normalizeGitignoreRule).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function missingGeneratedStateRules(gitignore) {
+  const present = new Set(activeGitignoreRules(gitignore));
+  return OPENCODE_GITIGNORE_GENERATED_STATE_RULES.filter((rule) => !present.has(rule));
+}
 
 // src/commands/purge.ts
 var PURGE_CATEGORY_IDS = [
@@ -8543,7 +8883,7 @@ function resolveStaticPurgeItems(config, paths) {
       ...paths.opencodeConfigPaths.map((p) => ({ kind: "opencode-config", path: p })),
       { kind: "gitignore", path: paths.gitignorePath }
     ],
-    roster: [],
+    roster: [{ kind: "file", path: OPENTEAM_ROSTER_PATH }],
     decisions: [
       { kind: "file", path: paths.decisionsPath },
       { kind: "file", path: paths.telemetryPath }
@@ -8835,8 +9175,12 @@ function categoryPrompt(id, items) {
       return "Remove openteam configuration and wiring?";
     case "roster": {
       const names = items.filter((item) => item.kind === "agent").map((item) => item.name);
-      const listed = names.join(", ");
-      return `Remove the agent roster? (${names.length} user agent${names.length === 1 ? "" : "s"}: ${listed})`;
+      const hasRegistry = items.some((item) => item.kind === "file" && item.path === OPENTEAM_ROSTER_PATH);
+      const plural = names.length === 1 ? "" : "s";
+      const agentNames = names.length > 0 ? `: ${names.join(", ")}` : "";
+      const agentClause = `${names.length} user agent${plural}${agentNames}`;
+      const parts = hasRegistry ? [`roster registry (${OPENTEAM_ROSTER_PATH})`, agentClause] : [agentClause];
+      return `Remove the agent roster? (${parts.join("; ")})`;
     }
     case "decisions":
       return "Remove decisions and telemetry?";
@@ -8898,7 +9242,9 @@ async function collectCategories(input) {
   const { runtime, config, paths } = input;
   const staticItems = resolveStaticPurgeItems(config, paths);
   const agents = await runtime.port.listAgents();
-  const rosterItems = agents.filter((agent) => path3.resolve(agent.path) !== path3.resolve(paths.orchestratorAgentPath)).map((agent) => ({ kind: "agent", path: agent.path, name: agent.name }));
+  const discoveredAgents = agents.filter((agent) => path3.resolve(agent.path) !== path3.resolve(paths.orchestratorAgentPath)).map((agent) => ({ kind: "agent", path: agent.path, name: agent.name }));
+  const rosterRegistry = await presentItemsFor(runtime.port, staticItems.roster);
+  const rosterItems = [...rosterRegistry, ...discoveredAgents];
   const worktrees = await runtime.port.listWorktrees();
   const worktreeItems = worktrees.map((worktree) => ({
     kind: "worktree",
@@ -10051,6 +10397,15 @@ async function runCli(argv, deps) {
         ...defaultModel !== undefined ? { defaultModel } : {}
       });
       const legacyLayout = deps.detectLegacyLayout !== undefined ? await deps.detectLegacyLayout() : undefined;
+      let gitignoreCoverage;
+      if (deps.readGitignore !== undefined) {
+        const raw = await deps.readGitignore();
+        gitignoreCoverage = {
+          path: OPENCODE_GITIGNORE_PATH,
+          exists: raw !== undefined,
+          missingRules: missingGeneratedStateRules(raw ?? "")
+        };
+      }
       const otelBackend = describeOtelBackendForDoctor({
         backend: "opentelemetry",
         connectionEnv: "APPLICATIONINSIGHTS_CONNECTION_STRING"
@@ -10067,6 +10422,12 @@ async function runCli(argv, deps) {
           rosterLoadError = err instanceof Error ? err.message : String(err);
         }
       }
+      let queueWait;
+      if (deps.readQueueEvents !== undefined) {
+        const queueEvents = await deps.readQueueEvents();
+        const summary = summarizeQueueWaits(queueEvents);
+        queueWait = summary !== undefined ? { summary } : {};
+      }
       return {
         exitCode: 0,
         stdout: renderDoctor({
@@ -10076,6 +10437,7 @@ async function runCli(argv, deps) {
           telemetryRecords: records.length,
           agentModels,
           opencodeConfigPaths,
+          ...queueWait !== undefined ? { queueWait } : {},
           ...rosterAudit !== undefined ? { rosterAudit } : {},
           ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
           ...rosterLoadError !== undefined ? { rosterLoadError } : {},
@@ -10083,7 +10445,8 @@ async function runCli(argv, deps) {
           ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
           ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
           ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
-          ...otelBackend !== undefined ? { otelBackend } : {}
+          ...otelBackend !== undefined ? { otelBackend } : {},
+          ...gitignoreCoverage !== undefined ? { gitignore: gitignoreCoverage } : {}
         })
       };
     }
@@ -10759,139 +11122,6 @@ function compareShadowRun(legacy, shadow) {
   };
 }
 
-// src/storage/graph/soakRecorder.ts
-async function ensureRecorderId(ports, basePath) {
-  const idPath = `${basePath}/soak-recorder-id`;
-  if (await ports.fs.exists(idPath)) {
-    const id = (await ports.fs.readFile(idPath)).trim();
-    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
-      return id;
-    }
-  }
-  const newId = ports.id.randomUUID();
-  await ports.fs.writeFile(idPath, newId);
-  return newId;
-}
-async function readAllChains(ports, evidenceDir) {
-  if (!await ports.fs.exists(evidenceDir)) {
-    return { chains: [], rejectedLines: 0, rejections: [] };
-  }
-  const files = await ports.fs.readDir(evidenceDir);
-  const chains = [];
-  const rejections = [];
-  for (const file of files) {
-    if (!file.endsWith(".jsonl")) {
-      continue;
-    }
-    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
-    const lines = content.split(`
-`);
-    const observations = [];
-    for (const [index, line] of lines.entries()) {
-      if (line.trim().length === 0) {
-        continue;
-      }
-      const lineNumber = index + 1;
-      let rawParsed;
-      try {
-        rawParsed = JSON.parse(line);
-      } catch {
-        rejections.push({ file, lineNumber, detail: "invalid JSON" });
-        continue;
-      }
-      const parsed = SoakObservationSchema.safeParse(rawParsed);
-      if (parsed.success) {
-        observations.push(parsed.data);
-      } else {
-        rejections.push({
-          file,
-          lineNumber,
-          detail: formatSoakObservationIssues(parsed.error.issues)
-        });
-      }
-    }
-    if (observations.length > 0) {
-      chains.push(observations);
-    }
-  }
-  return { chains, rejectedLines: rejections.length, rejections };
-}
-function formatSoakObservationIssues(issues) {
-  return issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
-}
-function canonicalObservationPreimage2(obs) {
-  return JSON.stringify({
-    version: obs.version,
-    seq: obs.seq,
-    timestamp: obs.timestamp,
-    platform: obs.platform,
-    opencodeVersion: obs.opencodeVersion,
-    provenance: obs.provenance,
-    traceDigest: obs.traceDigest,
-    criticalDivergences: obs.criticalDivergences,
-    privacy: obs.privacy,
-    duplicateEffects: obs.duplicateEffects,
-    modelVerification: obs.modelVerification
-  });
-}
-async function appendObservation(ports, evidenceDir, recorderId, input) {
-  if (input.opencodeVersion === "unknown") {
-    throw new Error("opencode-version-unreadable");
-  }
-  await ports.fs.mkdir(evidenceDir);
-  const chainPath = `${evidenceDir}/${recorderId}.jsonl`;
-  let seq = 0;
-  let prevChainDigest = "0".repeat(64);
-  if (await ports.fs.exists(chainPath)) {
-    const content = await ports.fs.readFile(chainPath);
-    const lines = content.split(`
-`).filter((l) => l.trim().length > 0);
-    if (lines.length > 0) {
-      const lastLine = lines[lines.length - 1];
-      let rawParsed;
-      try {
-        rawParsed = JSON.parse(lastLine);
-      } catch {
-        throw new Error("corrupt chain tail: invalid JSON");
-      }
-      const parsed = SoakObservationSchema.safeParse(rawParsed);
-      if (!parsed.success) {
-        const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
-        throw new Error(`corrupt chain tail: ${detail}`);
-      }
-      seq = parsed.data.seq + 1;
-      prevChainDigest = parsed.data.chainDigest;
-    }
-  }
-  const timestamp = ports.clock.now();
-  const base = {
-    version: 1,
-    seq,
-    timestamp,
-    platform: input.platform,
-    opencodeVersion: input.opencodeVersion,
-    provenance: input.provenance,
-    traceDigest: input.traceDigest,
-    criticalDivergences: input.criticalDivergences,
-    privacy: input.privacy,
-    duplicateEffects: input.duplicateEffects,
-    modelVerification: input.modelVerification
-  };
-  const preimage = canonicalObservationPreimage2(base);
-  const chainDigest = sha256Hex(prevChainDigest + preimage);
-  const observation = { ...base, chainDigest };
-  assertReferenceOnly(observation);
-  const line = JSON.stringify(observation);
-  if (await ports.fs.exists(chainPath)) {
-    const existing = await ports.fs.readFile(chainPath);
-    await ports.fs.writeFile(chainPath, `${existing}
-${line}`);
-  } else {
-    await ports.fs.writeFile(chainPath, line);
-  }
-  return observation;
-}
-
 // src/plugin/soakObserver.ts
 function resolvePlatform(platform) {
   if (platform === "win32")
@@ -13036,7 +13266,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.13.0",
+  version: "0.14.0",
   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",
@@ -13212,7 +13442,6 @@ function warnSoakEvidenceRejections(result, warn) {
 var SHADOW_CERT_PATH = "artifacts/graph-shadow-certificate.json";
 var RELEASE_CERT_PATH = "artifacts/graph-release-certificate.json";
 var SOAK_CERT_PATH = "artifacts/graph-soak-certificate.json";
-var SOAK_EVIDENCE_DIR = ".opencode/soak";
 async function readAndParseCertificate(storage, path4, parse2, digestExtractor) {
   try {
     const content = await storage.read(path4);
@@ -13735,14 +13964,14 @@ var server = async (ctx, rawOptions) => {
   let shadowDeps;
   if (graphConfig.effectiveMode !== "off") {
     const recorderPorts = recorderPortsFromStorage(storage);
-    const recorderId = await ensureRecorderId(recorderPorts, ".opencode");
+    const recorderId = await ensureRecorderId(recorderPorts, SOAK_RECORDER_BASE_DIR);
     shadowDeps = {
       gate: {
         mode: graphConfig.configuredMode,
         killSwitch: graphConfig.killSwitch
       },
       ports: recorderPorts,
-      evidenceDir: ".opencode/soak",
+      evidenceDir: SOAK_EVIDENCE_DIR,
       recorderId,
       resolveOpencodeVersion: getOpencodeVersion,
       criticalCodes: DEFAULT_SOAK_POLICY.criticalDivergenceCodes
@@ -13777,7 +14006,8 @@ var server = async (ctx, rawOptions) => {
     return reachableRuntimeIds(snapshots);
   };
   const runtimeLimiter = createRuntimeConcurrencyLimiter({
-    capacityFor: (id) => config.local.runtimes.find((runtime) => runtime.id === id)?.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY
+    capacityFor: (id) => config.local.runtimes.find((runtime) => runtime.id === id)?.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY,
+    now
   });
   const orchestrateTool = createOrchestrateTool({
     client: orchestrateClient,