@jmanuelcorral/openteam 0.17.5 → 0.18.0

package/dist/cli.js

@@ -12,7 +12,6 @@ import {
   confirm as clackConfirm,
   isCancel as clackIsCancel
 } from "@clack/prompts";
-import { createOpencodeClient } from "@opencode-ai/sdk";
 
 // src/cli/consoleServe.ts
 import { randomBytes } from "node:crypto";
@@ -48,65 +47,6 @@ import { z as z2 } from "zod";
 
 // src/orchestrator/roles.ts
 import { z } from "zod";
-
-// src/capabilities/select.ts
-var BLENDED_COST_INPUT_WEIGHT = 0.75;
-var BLENDED_COST_OUTPUT_WEIGHT = 1 - BLENDED_COST_INPUT_WEIGHT;
-var availabilityRank = {
-  available: 0,
-  degraded: 1,
-  unavailable: 2
-};
-var tierRequirements = {
-  trivial: { reasoning: 0, code: 1, context: 8000 },
-  simple: { reasoning: 1, code: 2, context: 16000 },
-  moderate: { reasoning: 3, code: 3, context: 32000 },
-  hard: { reasoning: 4, code: 5, context: 64000 }
-};
-function deriveRequirement(tier, task) {
-  const base = tierRequirements[tier];
-  const estimatedContext = (task.estimatedInputTokens ?? 0) + (task.estimatedOutputTokens ?? 0);
-  const contextFromPrompt = Math.ceil(task.promptChars / 4);
-  const minContextWindow = Math.max(base.context, estimatedContext, contextFromPrompt);
-  const codeBump = task.hasCode ? 1 : 0;
-  return {
-    minReasoningTier: base.reasoning,
-    minCodeQualityTier: Math.min(5, base.code + codeBump),
-    minContextWindow,
-    needsTools: task.requiresTools === true,
-    needsVision: task.requiresVision === true
-  };
-}
-function blendedCostPer1M(profile) {
-  return profile.costPer1M.inputUSD * BLENDED_COST_INPUT_WEIGHT + profile.costPer1M.outputUSD * BLENDED_COST_OUTPUT_WEIGHT;
-}
-function modelKey(profile) {
-  return `${profile.ref.providerID}/${profile.ref.modelID}`;
-}
-function compareCapableFrontier(req, left, right) {
-  const costDelta = blendedCostPer1M(left) - blendedCostPer1M(right);
-  if (costDelta !== 0) {
-    return costDelta;
-  }
-  const availabilityDelta = availabilityRank[left.availability] - availabilityRank[right.availability];
-  if (availabilityDelta !== 0) {
-    return availabilityDelta;
-  }
-  const reasoningWasteDelta = left.reasoningTier - req.minReasoningTier - (right.reasoningTier - req.minReasoningTier);
-  if (reasoningWasteDelta !== 0) {
-    return reasoningWasteDelta;
-  }
-  return modelKey(left).localeCompare(modelKey(right));
-}
-function satisfiesRequirement(req, profile) {
-  return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= req.minContextWindow && profile.reasoningTier >= req.minReasoningTier && profile.codeQualityTier >= req.minCodeQualityTier && (!req.needsTools || profile.supportsToolCalling) && (!req.needsVision || profile.supportsVision);
-}
-function selectCheapestCapableFrontier(req, profiles) {
-  const selected = profiles.filter((profile) => satisfiesRequirement(req, profile)).sort((left, right) => compareCapableFrontier(req, left, right))[0];
-  return selected?.ref ?? null;
-}
-
-// src/orchestrator/roles.ts
 var modelSelectionSchema = z.object({
   providerID: z.string().min(1),
   modelID: z.string().min(1)
@@ -276,15 +216,6 @@ function synthesiseFallbackProfile(roleID) {
     localFirst: true
   };
 }
-function roleToRequirement(role, task, tier) {
-  const baseRequirement = deriveRequirement(tier ?? role.defaultTier, task);
-  return {
-    ...baseRequirement,
-    minReasoningTier: Math.max(baseRequirement.minReasoningTier, role.minReasoningTier),
-    minCodeQualityTier: Math.max(baseRequirement.minCodeQualityTier, role.minCodeQualityTier),
-    needsTools: baseRequirement.needsTools || role.needsToolCallingByDefault
-  };
-}
 
 // src/config/migrations.ts
 var CURRENT_CONFIG_VERSION = 1;
@@ -440,7 +371,8 @@ var OrchestratorRolesSchema = z2.record(z2.string().min(1), z2.unknown()).defaul
   return parsedRoles;
 });
 var OrchestratorConfigSchema = z2.object({
-  roles: OrchestratorRolesSchema
+  roles: OrchestratorRolesSchema,
+  maxRetries: z2.number().int().min(0).optional()
 }).strict();
 var defaultFrontierModel = {
   providerID: "anthropic",
@@ -609,456 +541,6 @@ import { z as z7 } from "zod";
 // src/orchestrator/coordinator.ts
 import { z as z6 } from "zod";
 
-// src/capabilities/classify.ts
-var hardKeywords = [
-  "security",
-  "auth",
-  "authentication",
-  "authorization",
-  "concurrency",
-  "race condition",
-  "architecture",
-  "refactor",
-  "migration",
-  "debug",
-  "root cause"
-];
-function scoreOverride(override) {
-  if (override === "alwaysFrontier") {
-    return 30;
-  }
-  if (override === "alwaysLocal") {
-    return -20;
-  }
-  return 0;
-}
-function tierFromScore(score) {
-  if (score <= 15) {
-    return "trivial";
-  }
-  if (score <= 35) {
-    return "simple";
-  }
-  if (score <= 65) {
-    return "moderate";
-  }
-  return "hard";
-}
-function confidenceFromScore(score) {
-  if (score >= 75 || score <= 10) {
-    return 0.9;
-  }
-  if (score >= 30 && score <= 70) {
-    return 0.58;
-  }
-  return 0.72;
-}
-function addScore(condition, amount, reason, state) {
-  if (condition) {
-    state.score += amount;
-    state.reasons.push(reason);
-  }
-}
-function classifyHeuristic(task) {
-  const state = { score: scoreOverride(task.explicitOverride), reasons: [] };
-  const prompt = task.prompt?.toLowerCase() ?? "";
-  const estimatedTokens = (task.estimatedInputTokens ?? 0) + (task.estimatedOutputTokens ?? 0);
-  addScore(task.promptChars <= 80 && !task.hasCode && task.requiresTools !== true, -5, "short-text-prompt", state);
-  addScore(task.promptChars > 1500 || estimatedTokens > 700, 10, "large-prompt", state);
-  addScore(task.promptChars > 5000 || estimatedTokens > 3000, 15, "very-large-context", state);
-  addScore(task.hasCode, 15, "code-present", state);
-  addScore(task.requiresTools === true, 15, "tools-required", state);
-  addScore(task.requiresVision === true, 15, "vision-required", state);
-  addScore((task.fileCount ?? 0) > 1, 20, "multi-file-task", state);
-  addScore((task.diffHunks ?? 0) > 2, 15, "multi-hunk-diff", state);
-  addScore(hardKeywords.some((keyword) => prompt.includes(keyword)), 25, "hard-keyword", state);
-  addScore(task.userAskedForQuality === true, 20, "quality-requested", state);
-  addScore(task.privacySensitive === true, 10, "privacy-sensitive", state);
-  const normalizedScore = Math.max(0, Math.min(100, state.score));
-  return {
-    tier: tierFromScore(normalizedScore),
-    confidence: confidenceFromScore(normalizedScore),
-    reasons: state.reasons.length > 0 ? state.reasons : ["no-hard-signals"],
-    ambiguous: normalizedScore >= 30 && normalizedScore <= 70
-  };
-}
-
-// src/local/slotPool.ts
-var POOL_SEPARATOR = "::";
-function slotPoolKey(runtime, modelID) {
-  if (modelID === undefined) {
-    return runtime.id;
-  }
-  const declared = runtime.modelConcurrency?.[modelID];
-  return declared === undefined ? runtime.id : `${runtime.id}${POOL_SEPARATOR}${modelID}`;
-}
-function withReportedModelSlots(runtime, reported) {
-  if (reported === undefined || Object.keys(reported).length === 0) {
-    return runtime;
-  }
-  return {
-    ...runtime,
-    modelConcurrency: { ...reported, ...runtime.modelConcurrency }
-  };
-}
-
-// src/capabilities/budget.ts
-var WARNING_UTILIZATION = 0.8;
-function projectedSpend(current, estimatedCostUSD) {
-  return Math.max(0, current) + Math.max(0, estimatedCostUSD);
-}
-function budgetExceeded(projected, limit) {
-  return limit !== undefined && projected >= limit;
-}
-function budgetNearLimit(projected, limit) {
-  return limit !== undefined && projected >= limit * WARNING_UTILIZATION && projected < limit;
-}
-function exhaustedDecision(budgets, reason) {
-  return {
-    action: budgets.hardStopOnBudgetExhaustion ? "blockFrontier" : "forceLocal",
-    reason
-  };
-}
-function evaluateBudget(state, estimatedCostUSD, budgets) {
-  const projectedSessionUSD = projectedSpend(state.sessionUSD, estimatedCostUSD);
-  const projectedMonthlyUSD = budgets.monthlyUSD === undefined ? undefined : projectedSpend(state.monthlyUSD ?? 0, estimatedCostUSD);
-  if (budgetExceeded(projectedSessionUSD, budgets.sessionUSD)) {
-    return exhaustedDecision(budgets, "session-budget-exhausted");
-  }
-  if (budgetExceeded(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
-    return exhaustedDecision(budgets, "monthly-budget-exhausted");
-  }
-  if (state.frontierTokens !== undefined && budgets.frontierTokensPerSession !== undefined && state.frontierTokens >= budgets.frontierTokensPerSession) {
-    return exhaustedDecision(budgets, "frontier-token-budget-exhausted");
-  }
-  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
-    return { action: "warn", reason: "session-budget-near-limit" };
-  }
-  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
-    return { action: "warn", reason: "monthly-budget-near-limit" };
-  }
-  return { action: "ok" };
-}
-
-// src/router/modelSelection.ts
-function modelKey2(model) {
-  return `${model.providerID}/${model.modelID}`;
-}
-function sameModel(left, right) {
-  return left.providerID === right.providerID && left.modelID === right.modelID;
-}
-function compareModels(left, right) {
-  return modelKey2(left).localeCompare(modelKey2(right));
-}
-function uniqueModelSelections(models) {
-  const byKey = new Map;
-  for (const model of models) {
-    byKey.set(modelKey2(model), model);
-  }
-  return [...byKey.values()].sort(compareModels);
-}
-function localDefault(config) {
-  return config.local.runtimes.find((runtime) => runtime.enabled)?.defaultModel ?? config.router.localDefault;
-}
-function resolveConfiguredFrontierBaseline(config) {
-  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
-    return config.baseline.pinnedModel;
-  }
-  return config.baseline.hardDefault;
-}
-function compareAvailableModels(left, right) {
-  return compareModels(left, right);
-}
-function defaultAvailableModels(config) {
-  const local = localDefault(config);
-  const models = [];
-  if (local !== null) {
-    models.push({ ...local, kind: "local", available: true });
-  }
-  models.push({
-    ...resolveConfiguredFrontierBaseline(config),
-    kind: "frontier",
-    available: true
-  });
-  return models.sort(compareAvailableModels);
-}
-function availableModels(input) {
-  return (input.availableModels ?? defaultAvailableModels(input.config)).slice().sort(compareAvailableModels);
-}
-function listedModel(input, model) {
-  return availableModels(input).find((candidate) => sameModel(candidate, model));
-}
-function frontierAvailable(input, model) {
-  return listedModel(input, model)?.available !== false;
-}
-function localCandidateIsUsable(input, model) {
-  return model.kind === "local" && model.available && !(input.task.requiresTools === true && model.supportsTools === false);
-}
-function availableLocalFallbacks(input, selected) {
-  return uniqueModelSelections(availableModels(input).filter((model) => localCandidateIsUsable(input, model)).filter((model) => !sameModel(model, selected)).map((model) => ({
-    providerID: model.providerID,
-    modelID: model.modelID
-  })));
-}
-
-// src/router/cost.ts
-function modelProfile(input, model) {
-  return input.profiles?.find((profile) => sameModel(profile.ref, model));
-}
-function estimatedCostUSD(input, model) {
-  const profile = modelProfile(input, model);
-  if (profile === undefined) {
-    return 0;
-  }
-  const inputTokens = input.task.estimatedInputTokens ?? 0;
-  const outputTokens = input.task.estimatedOutputTokens ?? 0;
-  return inputTokens / 1e6 * profile.costPer1M.inputUSD + outputTokens / 1e6 * profile.costPer1M.outputUSD;
-}
-function roundUSD(value) {
-  return Math.round(value * 1000000000000) / 1000000000000;
-}
-
-// src/router/frontierBaseline.ts
-function resolveFrontierBaseline(input, tier) {
-  if (input.config.baseline.mode === "pinned" && input.config.baseline.pinnedModel !== null) {
-    return { model: input.config.baseline.pinnedModel, rationale: [] };
-  }
-  if (input.profiles !== undefined) {
-    const selected = selectCheapestCapableFrontier(deriveRequirement(tier, input.task), input.profiles);
-    if (selected !== null) {
-      return {
-        model: selected,
-        rationale: ["auto-cheapest-capable-frontier"]
-      };
-    }
-    return {
-      model: input.config.baseline.hardDefault,
-      rationale: ["auto-cheapest-capable-unavailable-hard-default"]
-    };
-  }
-  return { model: input.config.baseline.hardDefault, rationale: [] };
-}
-
-// src/router/chooseModel.ts
-function localStatus(input, model) {
-  const listed = listedModel(input, model);
-  return {
-    available: input.availableModels === undefined ? listed?.available !== false : listed?.available === true,
-    missingTools: input.task.requiresTools === true && listed?.supportsTools === false
-  };
-}
-function buildFallbackChain(input, selected, frontier, allowFrontier) {
-  const chain = availableLocalFallbacks(input, selected);
-  if (allowFrontier && !sameModel(frontier, selected) && frontierAvailable(input, frontier)) {
-    chain.push(frontier);
-  }
-  return chain;
-}
-function inferRouteKind(config, selected, listed) {
-  if (listed !== undefined) {
-    return listed.kind;
-  }
-  return config.local.runtimes.some((runtime) => sameModel(runtime.defaultModel, selected)) ? "local" : "frontier";
-}
-function localFallbackReason(status) {
-  return status.missingTools ? "local-missing-tools-fallback" : "local-unavailable-fallback";
-}
-function decision(selected, routeKind, rationale, fallbackChain) {
-  return {
-    selected,
-    routeKind,
-    rationale,
-    fallbackChain
-  };
-}
-function blockedDecision(frontier, rationale, blockReason) {
-  return {
-    selected: frontier,
-    routeKind: "blocked",
-    rationale,
-    fallbackChain: [],
-    blockReason
-  };
-}
-function resolveLocalPrimary(input, primary, frontier, options) {
-  const status = localStatus(input, primary);
-  if (status.available && !status.missingTools) {
-    return decision(primary, "local", options.baseRationale, buildFallbackChain(input, primary, frontier, options.allowFrontier));
-  }
-  const fallbackReason = localFallbackReason(status);
-  const nextLocal = availableLocalFallbacks(input, primary)[0];
-  if (nextLocal !== undefined) {
-    return decision(nextLocal, "local", [...options.baseRationale, fallbackReason], buildFallbackChain(input, nextLocal, frontier, options.allowFrontier));
-  }
-  if (!options.allowFrontier) {
-    return decision(primary, "local", [...options.baseRationale, fallbackReason, options.noLocalRationale], []);
-  }
-  if (frontierAvailable(input, frontier)) {
-    return decision(frontier, "frontier", [...options.baseRationale, fallbackReason, "no-local-available-frontier"], []);
-  }
-  return decision(primary, "local", [...options.baseRationale, fallbackReason, "frontier-unavailable"], []);
-}
-function resolveFrontierPrimary(input, frontier, rationale) {
-  if (frontierAvailable(input, frontier)) {
-    return decision(frontier, "frontier", rationale, []);
-  }
-  const nextLocal = availableLocalFallbacks(input, frontier)[0];
-  if (nextLocal !== undefined) {
-    return decision(nextLocal, "local", [...rationale, "frontier-unavailable-fallback"], buildFallbackChain(input, nextLocal, frontier, false));
-  }
-  return decision(frontier, "frontier", [...rationale, "frontier-unavailable"], []);
-}
-function tierForInput(input) {
-  return input.tier ?? classifyHeuristic(input.task).tier;
-}
-function finalizeDecision(input, tier, frontier, budgetAction, core) {
-  const selectedCostUSD = estimatedCostUSD(input, core.selected);
-  const baselineCostUSD = estimatedCostUSD(input, frontier.model);
-  const savingsUSD = core.routeKind === "frontier" && sameModel(core.selected, frontier.model) ? 0 : baselineCostUSD - selectedCostUSD;
-  const result = {
-    ...core,
-    tier,
-    rationale: [...frontier.rationale, ...core.rationale],
-    estimatedCostUSD: roundUSD(selectedCostUSD),
-    baselineCostUSD: roundUSD(baselineCostUSD),
-    estimatedSavingsUSD: roundUSD(savingsUSD),
-    budgetAction
-  };
-  if (core.blockReason !== undefined) {
-    result.blockReason = core.blockReason;
-  }
-  return result;
-}
-function chooseModel(input) {
-  const tier = tierForInput(input);
-  const local = localDefault(input.config);
-  const frontier = resolveFrontierBaseline(input, tier);
-  const frontierCostUSD = estimatedCostUSD(input, frontier.model);
-  const budgetAction = input.budgetState === undefined ? { action: "ok" } : evaluateBudget(input.budgetState, frontierCostUSD, input.config.budgets);
-  const override = input.task.explicitOverride;
-  if (input.task.privacySensitive === true && input.config.privacyMode === "forceLocalOnSensitive") {
-    if (local === null) {
-      if (input.config.router.localOnly) {
-        return finalizeDecision(input, tier, frontier, budgetAction, blockedDecision(frontier.model, [
-          "privacy-force-local",
-          "privacy-force-local-none-configured",
-          "router-local-only"
-        ], "privacy-local-only-none-configured"));
-      }
-      return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
-        "privacy-force-local",
-        "privacy-force-local-none-configured"
-      ]));
-    }
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["privacy-force-local"],
-      allowFrontier: false,
-      noLocalRationale: "privacy-force-local-unavailable"
-    }));
-  }
-  if (budgetAction.action === "forceLocal" || budgetAction.action === "blockFrontier") {
-    if (local === null) {
-      if (budgetAction.action === "blockFrontier") {
-        return finalizeDecision(input, tier, frontier, budgetAction, blockedDecision(frontier.model, ["budget-blockFrontier", "budget-local-none-configured"], "budget-blockFrontier-none-configured"));
-      }
-      return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
-        "budget-forceLocal",
-        "budget-local-none-configured"
-      ]));
-    }
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: [`budget-${budgetAction.action}`],
-      allowFrontier: false,
-      noLocalRationale: "budget-local-unavailable"
-    }));
-  }
-  if (typeof override === "object") {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(override, inferRouteKind(input.config, override, listedModel(input, override)), ["explicit-model-override"], buildFallbackChain(input, override, frontier.model, true)));
-  }
-  if (override === "alwaysLocal") {
-    if (local === null) {
-      return finalizeDecision(input, tier, frontier, budgetAction, blockedDecision(frontier.model, ["explicit-always-local", "forced-local-none-configured"], "forced-local-none-configured"));
-    }
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["explicit-always-local"],
-      allowFrontier: false,
-      noLocalRationale: "forced-local-unavailable"
-    }));
-  }
-  if (input.config.router.localOnly) {
-    if (local === null) {
-      return finalizeDecision(input, tier, frontier, budgetAction, blockedDecision(frontier.model, ["router-local-only", "forced-local-none-configured"], "forced-local-none-configured"));
-    }
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["router-local-only"],
-      allowFrontier: false,
-      noLocalRationale: "forced-local-unavailable"
-    }));
-  }
-  if (override === "alwaysFrontier") {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
-  }
-  if (input.config.router.frontierOnly) {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["router-frontier-only"], []));
-  }
-  const shortEnoughForLocal = input.task.promptChars <= input.config.router.trivialPromptMaxChars;
-  const largeEnoughForFrontier = input.task.promptChars >= input.config.router.frontierPromptMinChars;
-  if (!input.task.hasCode && shortEnoughForLocal && !largeEnoughForFrontier) {
-    if (local === null) {
-      return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
-        "trivial-short-no-code",
-        "no-local-runtime-configured"
-      ]));
-    }
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["trivial-short-no-code"],
-      allowFrontier: true,
-      noLocalRationale: "forced-local-unavailable"
-    }));
-  }
-  return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
-    input.task.hasCode ? "code-detected" : "large-or-nontrivial-prompt"
-  ]));
-}
-
-// src/telemetry/cost.ts
-function routeKind(decision2) {
-  if (decision2.routeKind === "local")
-    return "local";
-  if (decision2.routeKind === "blocked")
-    return "blocked";
-  return "frontier";
-}
-function budgetAction(decision2) {
-  const reason = decision2.budgetAction.reason;
-  return reason === undefined ? decision2.budgetAction.action : `${decision2.budgetAction.action}:${reason}`;
-}
-function toCostRecord(decision2, context) {
-  const record = {
-    ts: context.ts,
-    promptHash: context.promptHash,
-    promptChars: context.promptChars,
-    tier: decision2.tier,
-    routeKind: routeKind(decision2),
-    selected: decision2.selected,
-    rationale: decision2.rationale.join(","),
-    estimatedCostUSD: decision2.estimatedCostUSD,
-    baselineCostUSD: decision2.baselineCostUSD,
-    estimatedSavingsUSD: decision2.estimatedSavingsUSD,
-    budgetAction: budgetAction(decision2)
-  };
-  if (context.sessionID !== undefined) {
-    record.sessionID = context.sessionID;
-  }
-  if (context.tokensIn !== undefined) {
-    record.tokensIn = context.tokensIn;
-  }
-  if (context.tokensOut !== undefined) {
-    record.tokensOut = context.tokensOut;
-  }
-  return record;
-}
-
 // src/storage/path.ts
 class StoragePathError extends Error {
   constructor(message) {
@@ -1457,9 +939,6 @@ function warnCostRecordRejections(result, source) {
 // src/telemetry/eventLog.ts
 var DEFAULT_SESSIONS_DIR = ".opencode/openteam-local/sessions";
 var LEGACY_SESSION_ID = "legacy";
-function createNullEventSink() {
-  return { emit: () => {} };
-}
 function parseEventsJsonl(text) {
   const events = [];
   const rejections = [];
@@ -1600,939 +1079,319 @@ function hashPrompt(prompt) {
   return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
 
-// src/orchestrator/permissions.ts
-var ROLE_PERMISSIONS = {
-  architect: [
-    "read",
-    "edit",
-    "multiFileEdit",
-    "destructive",
-    "network",
-    "shell"
+// src/orchestrator/coordinator.ts
+var TelemetryFailureClassSchema = z6.enum([
+  "create-rejected",
+  "create-no-id",
+  "prompt-rejected",
+  "prompt-timeout",
+  "prompt-rate-limited",
+  "prompt-auth",
+  "prompt-content-filter",
+  "prompt-context-length",
+  "prompt-validation",
+  "prompt-connection",
+  "prompt-server",
+  "unknown"
+]);
+var FAILURE_CAUSE_RULES = [
+  [
+    [
+      "rate limit",
+      "rate-limit",
+      "ratelimit",
+      /(?<!\d)429(?!\d)/,
+      "too many requests",
+      "quota exceeded"
+    ],
+    "prompt-rate-limited"
   ],
-  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"],
-  tester: ["read", "edit", "shell"],
-  reviewer: ["read"]
-};
-var elevatedTier = {
-  trivial: "simple",
-  simple: "moderate",
-  moderate: "hard",
-  hard: "hard"
-};
-function elevateTierForPermissions(baseTier, perms) {
-  const needsElevation = perms.includes("destructive") || perms.includes("multiFileEdit");
-  return needsElevation ? elevatedTier[baseTier] : baseTier;
-}
-
-// src/orchestrator/runtimeSelection.ts
-function configuredRuntime(runtimeId, config) {
-  return config.local.runtimes.find((runtime) => runtime.id === runtimeId);
-}
-function runtimeIdOfModel(model, config) {
-  return config.local.runtimes.find((runtime) => sameModel(runtime.defaultModel, model))?.id;
-}
-function roleLocalModel(role, runtimeId, fallback, runtime) {
-  const pinned = role.localModels?.[runtimeId];
-  if (pinned !== undefined) {
-    return { ...fallback, modelID: pinned };
-  }
-  const classModel = runtimeClassModel(role.localModelClass, runtime);
-  return classModel === undefined ? fallback : { ...fallback, modelID: classModel };
-}
-function runtimeClassModel(modelClass, runtime) {
-  if (modelClass === undefined || runtime === undefined) {
-    return;
+  [
+    [
+      "unauthorized",
+      "authentication",
+      /(?<!\d)(?:401|403)(?!\d)/,
+      "forbidden",
+      "api key",
+      "invalid key",
+      "permission denied"
+    ],
+    "prompt-auth"
+  ],
+  [
+    [
+      "content policy",
+      "content filter",
+      "content_filter",
+      "moderation",
+      "safety system",
+      "flagged by"
+    ],
+    "prompt-content-filter"
+  ],
+  [
+    [
+      "context length",
+      "context window",
+      "maximum context",
+      "too many tokens",
+      "token limit",
+      "context_length_exceeded"
+    ],
+    "prompt-context-length"
+  ],
+  [
+    [
+      "invalid request",
+      "invalid_request",
+      "validation",
+      "bad request",
+      /(?<!\d)400(?!\d)/,
+      "unprocessable",
+      "malformed"
+    ],
+    "prompt-validation"
+  ],
+  [
+    [
+      "econnrefused",
+      "econnreset",
+      "enotfound",
+      "network error",
+      "connection refused",
+      "connection reset",
+      "fetch failed",
+      "socket hang up"
+    ],
+    "prompt-connection"
+  ],
+  [
+    [
+      "internal server error",
+      /(?<!\d)(?:500|502|503|504)(?!\d)/,
+      "service unavailable",
+      "bad gateway",
+      "overloaded"
+    ],
+    "prompt-server"
+  ]
+];
+var TIMEOUT_NEEDLES = [
+  "timed out",
+  "timeout",
+  "timedout",
+  "etimedout",
+  "deadline exceeded"
+];
+function matchFailureCause(lowerReason) {
+  for (const [needles, cls] of FAILURE_CAUSE_RULES) {
+    if (needles.some((needle) => typeof needle === "string" ? lowerReason.includes(needle) : needle.test(lowerReason))) {
+      return cls;
+    }
   }
-  return modelClass === "thinking" ? runtime.thinkingModel : runtime.coderModel;
+  return;
 }
-function selectDispatchRuntime(role, decision2, reachable, config) {
-  if (decision2.routeKind !== "local") {
-    return { runtimeId: undefined, decision: decision2 };
+function classifyFailureForTelemetry(failureReason, failureStage) {
+  const lower = failureReason.toLowerCase();
+  if (TIMEOUT_NEEDLES.some((needle) => lower.includes(needle))) {
+    return "prompt-timeout";
   }
-  const listed = role.localRuntimes;
-  if (listed !== undefined && listed.length > 0 && reachable !== undefined) {
-    for (const runtimeId of listed) {
-      if (!reachable.has(runtimeId)) {
-        continue;
-      }
-      const runtime = configuredRuntime(runtimeId, config);
-      if (runtime === undefined) {
-        continue;
-      }
-      const model = roleLocalModel(role, runtimeId, runtime.defaultModel, runtime);
-      return {
-        runtimeId,
-        decision: { ...decision2, selected: model }
-      };
-    }
+  if (lower.includes("did not include a session id") || lower.includes("missing session")) {
+    return "create-no-id";
   }
-  const resolvedRuntimeId = runtimeIdOfModel(decision2.selected, config);
-  if (resolvedRuntimeId !== undefined) {
-    const pinned = roleLocalModel(role, resolvedRuntimeId, decision2.selected, configuredRuntime(resolvedRuntimeId, config));
-    if (pinned !== decision2.selected) {
-      return {
-        runtimeId: resolvedRuntimeId,
-        decision: { ...decision2, selected: pinned }
-      };
-    }
+  if (failureStage === "create") {
+    return "create-rejected";
   }
-  return {
-    runtimeId: resolvedRuntimeId,
-    decision: decision2
-  };
-}
-
-// src/orchestrator/subsessions.ts
-var UNKNOWN_ERROR_REASON_MAX_CHARS = 500;
-var TRUNCATED_REASON_SUFFIX = "…[truncated]";
-var MAX_SERIALIZED_ARRAY_ITEMS = 20;
-var MAX_SERIALIZED_OBJECT_PROPERTIES = 25;
-var MAX_SERIALIZED_DEPTH = 4;
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isError(value) {
-  try {
-    return value instanceof Error;
-  } catch {
-    return false;
+  const cause = matchFailureCause(lower);
+  if (cause !== undefined) {
+    return cause;
   }
-}
-function safeToString(value) {
-  try {
-    return String(value);
-  } catch {
-    return "unserializable error value";
+  if (failureStage === "prompt") {
+    return "prompt-rejected";
   }
+  return "unknown";
 }
-function safeGet(value, key) {
-  try {
-    return Reflect.get(value, key);
-  } catch {
-    return;
+function classifyOpencodeSessionError(error) {
+  if (error === undefined) {
+    return "unknown";
+  }
+  const text = `${error.name ?? ""} ${error.message ?? ""}`.trim();
+  if (text.length === 0) {
+    return "unknown";
   }
+  return classifyFailureForTelemetry(text, undefined);
 }
-function stringProperty(value, key) {
-  const candidate = safeGet(value, key);
-  return typeof candidate === "string" ? candidate : undefined;
+
+// src/console/protocol.ts
+function redactFrameText(text) {
+  return `[redacted · ${text.length} chars · ${hashPrompt(text)}]`;
 }
-function nestedMessage(value, key) {
-  const container = safeGet(value, key);
-  if (!isObject(container)) {
-    return;
-  }
-  const message = stringProperty(container, "message");
-  return message !== undefined && message.trim().length > 0 ? message : undefined;
+var MAX_INPUT_CHARS = 1e5;
+var SessionInputSchema = z7.object({
+  text: z7.string().min(1).max(MAX_INPUT_CHARS)
+}).strict();
+function parseSessionInput(raw) {
+  const result = SessionInputSchema.safeParse(raw);
+  return result.success ? result.data : undefined;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : undefined;
 }
-function functionName(value) {
-  return value.name.length > 0 ? `:${value.name}` : "";
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
 }
-function jsonCompatible(value, seen, depth) {
-  if (value === null) {
-    return null;
+function eventSessionID(event) {
+  const props = asRecord(event.properties);
+  if (props === undefined) {
+    return;
   }
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return value;
-    case "bigint":
-      return `${value.toString()}n`;
-    case "symbol":
-      return safeToString(value);
-    case "undefined":
-      return "[undefined]";
-    case "function":
-      return `[Function${functionName(value)}]`;
-    case "object":
-      break;
+  return str(props.sessionID) ?? str(asRecord(props.part)?.sessionID) ?? str(asRecord(props.info)?.sessionID);
+}
+function partToFrame(part, options) {
+  if (part.type === "text") {
+    const text = str(part.text);
+    if (text === undefined) {
+      return;
+    }
+    return options.diagnostic === true ? { kind: "text", text } : { kind: "text", text: redactFrameText(text), redacted: true };
   }
-  if (seen.has(value)) {
-    return "[Circular]";
+  if (part.type === "tool") {
+    const tool = str(part.tool) ?? "tool";
+    const status = str(asRecord(part.state)?.status) ?? "run";
+    return { kind: "tool", text: `⚙ ${tool} · ${status}` };
   }
-  if (depth >= MAX_SERIALIZED_DEPTH) {
-    return "[MaxDepth]";
+  return;
+}
+function messagesToFrames(raw, sessionID, options = {}) {
+  if (!Array.isArray(raw)) {
+    return [];
   }
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      const items = value.slice(0, MAX_SERIALIZED_ARRAY_ITEMS).map((item) => jsonCompatible(item, seen, depth + 1));
-      if (value.length > MAX_SERIALIZED_ARRAY_ITEMS) {
-        items.push(`...${value.length - MAX_SERIALIZED_ARRAY_ITEMS} more items`);
+  const frames = [];
+  for (const entry of raw) {
+    const record = asRecord(entry);
+    if (record === undefined) {
+      continue;
+    }
+    const info = asRecord(record.info);
+    const entrySession = str(info?.sessionID) ?? str(record.sessionID);
+    if (entrySession !== undefined && entrySession !== sessionID) {
+      continue;
+    }
+    const parts = record.parts;
+    if (!Array.isArray(parts)) {
+      continue;
+    }
+    for (const rawPart of parts) {
+      const part = asRecord(rawPart);
+      if (part === undefined) {
+        continue;
       }
-      return items;
-    }
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    const entries = Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable);
-    const result = {};
-    for (const [index, [key, descriptor]] of entries.entries()) {
-      if (index >= MAX_SERIALIZED_OBJECT_PROPERTIES) {
-        result["..."] = `${entries.length - MAX_SERIALIZED_OBJECT_PROPERTIES} more properties`;
-        break;
+      const frame = partToFrame(part, options);
+      if (frame !== undefined) {
+        frames.push(frame);
       }
-      result[key] = "value" in descriptor ? jsonCompatible(descriptor.value, seen, depth + 1) : "[Getter]";
     }
-    return result;
-  } catch (serializationError) {
-    return `[Unserializable object: ${safeToString(serializationError)}]`;
-  } finally {
-    seen.delete(value);
-  }
-}
-function truncateReason(reason) {
-  if (reason.length <= UNKNOWN_ERROR_REASON_MAX_CHARS) {
-    return reason;
   }
-  return `${reason.slice(0, UNKNOWN_ERROR_REASON_MAX_CHARS - TRUNCATED_REASON_SUFFIX.length)}${TRUNCATED_REASON_SUFFIX}`;
-}
-function objectReason(error) {
-  try {
-    const serialized = JSON.stringify(jsonCompatible(error, new WeakSet, 0));
-    if (serialized !== undefined && serialized !== "[object Object]") {
-      return truncateReason(serialized);
-    }
-  } catch {}
-  const fallback = safeToString(error);
-  return truncateReason(fallback === "[object Object]" ? "unserializable error object" : fallback);
+  return frames;
 }
-function errorReason(error) {
-  if (isError(error)) {
-    const message = stringProperty(error, "message");
-    if (message !== undefined) {
-      return message;
-    }
+function eventToSessionFrame(event, sessionID, options = {}) {
+  if (eventSessionID(event) !== sessionID) {
+    return;
   }
-  if (isObject(error)) {
-    const message = stringProperty(error, "message");
-    if (message !== undefined) {
-      return message;
+  const props = asRecord(event.properties) ?? {};
+  switch (event.type) {
+    case "message.part.updated": {
+      const part = asRecord(props.part);
+      return part === undefined ? undefined : partToFrame(part, options);
     }
-    const dataMessage = nestedMessage(error, "data");
-    if (dataMessage !== undefined) {
-      return dataMessage;
+    case "session.idle":
+      return { kind: "status", text: "● session ready" };
+    case "session.error": {
+      const err = asRecord(props.error);
+      const cls = classifyOpencodeSessionError(err === undefined ? undefined : { name: str(err.name), message: str(err.message) });
+      return { kind: "error", text: `✖ ${cls}` };
     }
-    const nestedErrorMessage = nestedMessage(error, "error");
-    if (nestedErrorMessage !== undefined) {
-      return nestedErrorMessage;
+    case "permission.updated": {
+      const title = str(props.title) ?? "permission requested";
+      const id = str(props.id);
+      const frame = { kind: "permission", text: `⚠ ${title}` };
+      if (id !== undefined) {
+        frame.permissionID = id;
+      }
+      return frame;
     }
-    return objectReason(error);
-  }
-  return safeToString(error);
-}
-function createArgs(req) {
-  const body = {};
-  const args = { body };
-  if (req.parentSessionID !== undefined) {
-    body.parentID = req.parentSessionID;
-  }
-  if (req.title !== undefined) {
-    body.title = req.title;
-  }
-  if (req.directory !== undefined) {
-    args.query = { directory: req.directory };
-  }
-  return args;
-}
-function promptArgs(sessionID, req) {
-  const body = {
-    model: req.model,
-    parts: [{ type: "text", text: req.prompt }]
-  };
-  if (req.agent !== undefined) {
-    body.agent = req.agent;
-  }
-  if (req.systemPrompt !== undefined) {
-    body.system = req.systemPrompt;
+    default:
+      return;
   }
-  return {
-    path: { id: sessionID },
-    body
-  };
 }
-async function withTimeout(promise, timeoutMs) {
-  if (timeoutMs === undefined) {
-    return promise;
-  }
-  let timeoutID;
-  const timeout = new Promise((_, reject) => {
-    timeoutID = setTimeout(() => {
-      reject(new Error(`prompt timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    clearTimeout(timeoutID);
-  }
+function frameToSse(frame) {
+  return `event: frame
+data: ${JSON.stringify(frame)}
+
+`;
 }
-async function runSubsession(client, req, deps = {}) {
-  let sessionID;
-  try {
-    const created = await client.session.create(createArgs(req));
-    if (created.error !== undefined) {
-      return {
-        success: false,
-        roleID: req.roleID,
-        model: req.model,
-        failureStage: "create",
-        failureReason: errorReason(created.error)
-      };
+
+// src/console/sse.ts
+function pushSse(buffer, chunk) {
+  const combined = (buffer + chunk).replace(/\r\n/g, `
+`);
+  const parts = combined.split(`
+
+`);
+  const rest = parts.pop() ?? "";
+  const messages = [];
+  for (const block of parts) {
+    if (block.length === 0) {
+      continue;
     }
-    sessionID = created.data?.id;
-    if (sessionID === undefined || sessionID.length === 0) {
-      return {
-        success: false,
-        roleID: req.roleID,
-        model: req.model,
-        failureStage: "create",
-        failureReason: "create response did not include a session id"
-      };
+    let event;
+    const dataLines = [];
+    for (const line of block.split(`
+`)) {
+      if (line.startsWith(":") || line.length === 0) {
+        continue;
+      }
+      if (line.startsWith("event:")) {
+        event = line.slice("event:".length).trimStart();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice("data:".length).replace(/^ /, ""));
+      }
     }
-  } catch (error) {
-    return {
-      success: false,
-      roleID: req.roleID,
-      model: req.model,
-      failureStage: "create",
-      failureReason: errorReason(error)
-    };
-  }
-  try {
-    const prompted = await withTimeout(client.session.prompt(promptArgs(sessionID, req)), deps.timeoutMs);
-    if (prompted.error !== undefined) {
-      return {
-        success: false,
-        sessionID,
-        roleID: req.roleID,
-        model: req.model,
-        failureStage: "prompt",
-        failureReason: errorReason(prompted.error)
-      };
+    if (dataLines.length === 0 && event === undefined) {
+      continue;
     }
-    return {
-      success: true,
-      sessionID,
-      roleID: req.roleID,
-      model: req.model,
-      response: prompted.data
-    };
-  } catch (error) {
-    return {
-      success: false,
-      sessionID,
-      roleID: req.roleID,
-      model: req.model,
-      failureStage: "prompt",
-      failureReason: errorReason(error)
-    };
+    const message = { data: dataLines.join(`
+`) };
+    if (event !== undefined) {
+      message.event = event;
+    }
+    messages.push(message);
   }
+  return { messages, rest };
 }
-
-// src/orchestrator/coordinator.ts
-function warnUnknownRole(roleID, warn, warnedRoles) {
-  if (isKnownNonWorkerRole(roleID))
+function parseEventData(data) {
+  if (data.length === 0) {
     return;
-  if (warnedRoles !== undefined) {
-    if (warnedRoles.has(roleID))
-      return;
-    warnedRoles.add(roleID);
   }
-  (warn ?? console.warn)(`[openteam] unknown roleID "${roleID}" — no matching profile in config orchestrator.roles or TEAM_ROLES. ` + `A neutral frontier-eligible profile will be used and the request will be ` + `dispatched to agent "${roleID}". If this is a custom agent in your workspace, ` + `this message is informational. To silence it, add "${roleID}" to orchestrator.roles in .opencode/openteam.json.`);
-}
-function roleFor(input) {
-  return getRoleProfile(input.roleID, input.config.orchestrator?.roles) ?? synthesiseFallbackProfile(input.roleID);
-}
-function priorityForRole(role) {
-  return role.roleID === "scribe" ? "background" : "worker";
-}
-function mandatoryLocalRuntimeMessage(roleID) {
-  return `openteam: role "${roleID}" requires a local runtime, but no local runtime is reachable. ` + `This role must run locally and will not fall back to a frontier provider. ` + `Start one of the supported local runtimes (Ollama, LM Studio, or Lemonade) and try again. ` + "Run `openteam doctor` to diagnose your local runtime configuration.";
-}
-function assertLocalRuntimeForRole(role, roleID, reachable) {
-  if (role.requiresLocalRuntime !== true) {
+  try {
+    return JSON.parse(data);
+  } catch {
     return;
   }
-  if (reachable !== true) {
-    throw new Error(mandatoryLocalRuntimeMessage(roleID));
-  }
-}
-function roleHasRuntimeList(role) {
-  return role.localRuntimes !== undefined && role.localRuntimes.length > 0;
-}
-async function resolveBatchReachability(inputs, deps) {
-  const roles = inputs.map(roleFor);
-  const anyMandatory = roles.some((role) => role.requiresLocalRuntime === true);
-  const anyList = roles.some(roleHasRuntimeList);
-  if (!anyMandatory && !anyList) {
-    return { any: undefined, set: undefined };
-  }
-  if (anyList && deps.reachableRuntimeIds !== undefined) {
-    const set = await deps.reachableRuntimeIds();
-    return { any: set.size > 0, set };
-  }
-  const any = await deps.localRuntimeReachable();
-  return { any, set: undefined };
-}
-function roleLocalReachable(role, batch) {
-  const listed = role.localRuntimes;
-  if (listed !== undefined && listed.length > 0 && batch.set !== undefined) {
-    return listed.some((id) => batch.set?.has(id) === true);
-  }
-  return batch.any;
-}
-function permissionsFor(roleID) {
-  return ROLE_PERMISSIONS[roleID] ?? [];
-}
-function roleRequiresFrontier(role, task, config) {
-  return task.explicitOverride === undefined && config.router.localOnly !== true && role.localFirst === false && role.defaultTier === "hard" && role.preferredFrontierModels.length > 0;
-}
-function roleAdjustedTask(role, input, requirement) {
-  const task = {
-    ...input.task,
-    prompt: input.task.prompt ?? input.prompt
-  };
-  if (requirement.needsTools) {
-    task.requiresTools = true;
-  }
-  if (roleRequiresFrontier(role, task, input.config)) {
-    task.explicitOverride = "alwaysFrontier";
-  }
-  return task;
-}
-function roleAdjustedTaskForRole(input) {
-  const role = roleFor(input);
-  const tier = elevateTierForPermissions(classifyHeuristic({
-    ...input.task,
-    prompt: input.task.prompt ?? input.prompt
-  }).tier, permissionsFor(role.roleID));
-  return roleAdjustedTask(role, input, roleToRequirement(role, input.task, tier));
 }
-function satisfiesRoleRequirement(requirement, profile) {
-  return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= requirement.minContextWindow && profile.reasoningTier >= requirement.minReasoningTier && profile.codeQualityTier >= requirement.minCodeQualityTier && (!requirement.needsTools || profile.supportsToolCalling) && (!requirement.needsVision || profile.supportsVision);
-}
-function roleCapableProfiles(profiles, requirement) {
-  if (profiles === undefined) {
+
+// src/console/opencodeClient.ts
+function unwrapEvent(value) {
+  if (typeof value !== "object" || value === null) {
     return;
   }
-  return profiles.filter((profile) => satisfiesRoleRequirement(requirement, profile));
-}
-function routingInput(input, role) {
-  const classifiedTier = classifyHeuristic({
-    ...input.task,
-    prompt: input.task.prompt ?? input.prompt
-  }).tier;
-  const permissionTier = elevateTierForPermissions(classifiedTier, permissionsFor(role.roleID));
-  const tier = permissionTier;
-  const requirement = roleToRequirement(role, input.task, tier);
-  const task = roleAdjustedTaskForRole(input);
-  const baseInput = {
-    config: input.config,
-    task,
-    tier
-  };
-  const profiles = roleCapableProfiles(input.profiles, requirement);
-  if (profiles !== undefined) {
-    baseInput.profiles = profiles;
-  }
-  if (input.availableModels !== undefined) {
-    baseInput.availableModels = input.availableModels;
-  }
-  if (input.budgetState !== undefined) {
-    baseInput.budgetState = input.budgetState;
-  }
-  return baseInput;
+  const record = value;
+  const payload = typeof record.payload === "object" && record.payload !== null ? record.payload : record;
+  return typeof payload.type === "string" ? payload : undefined;
 }
-function recordSessionID(input, subsession) {
-  return subsession.sessionID ?? input.parentSessionID;
-}
-function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
-  const context = {
-    ts: deps.now(),
-    promptHash: hashPrompt(input.prompt),
-    promptChars: input.task.promptChars
-  };
-  const sessionID = recordSessionID(input, subsession);
-  if (sessionID !== undefined) {
-    context.sessionID = sessionID;
-  }
-  if (input.task.estimatedInputTokens !== undefined) {
-    context.tokensIn = input.task.estimatedInputTokens;
-  }
-  if (input.task.estimatedOutputTokens !== undefined) {
-    context.tokensOut = input.task.estimatedOutputTokens;
-  }
-  const base = toCostRecord(decision2, context);
-  const record = {
-    ...base,
-    decisionID,
-    agent: input.roleID,
-    success: subsession.success
-  };
-  if (batchID !== undefined) {
-    record.batchID = batchID;
-  }
-  if (input.taskID !== undefined) {
-    record.taskID = input.taskID;
-  }
-  if (subsession.failureReason !== undefined) {
-    record.failureReason = subsession.failureReason;
-  }
-  if (subsession.failureStage !== undefined) {
-    record.failureStage = subsession.failureStage;
-  }
-  return record;
-}
-var TelemetryFailureClassSchema = z6.enum([
-  "create-rejected",
-  "create-no-id",
-  "prompt-rejected",
-  "prompt-timeout",
-  "prompt-rate-limited",
-  "prompt-auth",
-  "prompt-content-filter",
-  "prompt-context-length",
-  "prompt-validation",
-  "prompt-connection",
-  "prompt-server",
-  "unknown"
-]);
-var FAILURE_CAUSE_RULES = [
-  [
-    [
-      "rate limit",
-      "rate-limit",
-      "ratelimit",
-      /(?<!\d)429(?!\d)/,
-      "too many requests",
-      "quota exceeded"
-    ],
-    "prompt-rate-limited"
-  ],
-  [
-    [
-      "unauthorized",
-      "authentication",
-      /(?<!\d)(?:401|403)(?!\d)/,
-      "forbidden",
-      "api key",
-      "invalid key",
-      "permission denied"
-    ],
-    "prompt-auth"
-  ],
-  [
-    [
-      "content policy",
-      "content filter",
-      "content_filter",
-      "moderation",
-      "safety system",
-      "flagged by"
-    ],
-    "prompt-content-filter"
-  ],
-  [
-    [
-      "context length",
-      "context window",
-      "maximum context",
-      "too many tokens",
-      "token limit",
-      "context_length_exceeded"
-    ],
-    "prompt-context-length"
-  ],
-  [
-    [
-      "invalid request",
-      "invalid_request",
-      "validation",
-      "bad request",
-      /(?<!\d)400(?!\d)/,
-      "unprocessable",
-      "malformed"
-    ],
-    "prompt-validation"
-  ],
-  [
-    [
-      "econnrefused",
-      "econnreset",
-      "enotfound",
-      "network error",
-      "connection refused",
-      "connection reset",
-      "fetch failed",
-      "socket hang up"
-    ],
-    "prompt-connection"
-  ],
-  [
-    [
-      "internal server error",
-      /(?<!\d)(?:500|502|503|504)(?!\d)/,
-      "service unavailable",
-      "bad gateway",
-      "overloaded"
-    ],
-    "prompt-server"
-  ]
-];
-var TIMEOUT_NEEDLES = [
-  "timed out",
-  "timeout",
-  "timedout",
-  "etimedout",
-  "deadline exceeded"
-];
-function matchFailureCause(lowerReason) {
-  for (const [needles, cls] of FAILURE_CAUSE_RULES) {
-    if (needles.some((needle) => typeof needle === "string" ? lowerReason.includes(needle) : needle.test(lowerReason))) {
-      return cls;
-    }
-  }
-  return;
-}
-function classifyFailureForTelemetry(failureReason, failureStage) {
-  const lower = failureReason.toLowerCase();
-  if (TIMEOUT_NEEDLES.some((needle) => lower.includes(needle))) {
-    return "prompt-timeout";
-  }
-  if (lower.includes("did not include a session id") || lower.includes("missing session")) {
-    return "create-no-id";
-  }
-  if (failureStage === "create") {
-    return "create-rejected";
-  }
-  const cause = matchFailureCause(lower);
-  if (cause !== undefined) {
-    return cause;
-  }
-  if (failureStage === "prompt") {
-    return "prompt-rejected";
-  }
-  return "unknown";
-}
-function classifyOpencodeSessionError(error) {
-  if (error === undefined) {
-    return "unknown";
-  }
-  const text = `${error.name ?? ""} ${error.message ?? ""}`.trim();
-  if (text.length === 0) {
-    return "unknown";
-  }
-  return classifyFailureForTelemetry(text, undefined);
-}
-function correlatedCostRecordToRouteEvent(record) {
-  const event = {
-    ...costRecordToRouteEvent(record),
-    decisionID: record.decisionID,
-    agent: record.agent,
-    success: record.success
-  };
-  if (record.batchID !== undefined) {
-    event.batchID = record.batchID;
-  }
-  if (record.taskID !== undefined) {
-    event.taskID = record.taskID;
-  }
-  if (record.failureReason !== undefined) {
-    event.failureReason = classifyFailureForTelemetry(record.failureReason, record.failureStage);
-  }
-  if (record.failureStage !== undefined) {
-    event.failureStage = record.failureStage;
-  }
-  return event;
-}
-async function safeEmit(sink, event) {
-  try {
-    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);
-  }
-  const role = roleFor(input);
-  assertLocalRuntimeForRole(role, input.roleID, roleLocalReachable(role, batch));
-  const routed = chooseModel(routingInput(input, role));
-  if (routed.routeKind === "blocked") {
-    throw new Error(`openteam coordinator: request for role "${input.roleID}" blocked — ${routed.blockReason ?? "no-local-runtime-configured"}. Configure a local runtime or disable the constraint.`);
-  }
-  const selection = selectDispatchRuntime(role, routed, batch.set, input.config);
-  const decision2 = selection.decision;
-  const request = {
-    roleID: input.roleID,
-    model: decision2.selected,
-    prompt: input.prompt
-  };
-  if (input.parentSessionID !== undefined) {
-    request.parentSessionID = input.parentSessionID;
-  }
-  if (input.title !== undefined) {
-    request.title = input.title;
-  }
-  if (input.systemPrompt !== undefined) {
-    request.systemPrompt = input.systemPrompt;
-  }
-  if (input.agentOverride !== undefined) {
-    request.agent = input.agentOverride;
-  } else if (role.opencodeAgent !== undefined) {
-    request.agent = role.opencodeAgent;
-  }
-  if (input.directory !== undefined) {
-    request.directory = input.directory;
-  }
-  const subsessionDeps = deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs };
-  const runtimeId = selection.runtimeId;
-  let release;
-  let queueObservation;
-  if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
-    const limiter = deps.runtimeLimiter;
-    const priority = priorityForRole(role);
-    const dispatchRuntime = configuredRuntime(runtimeId, input.config) ?? { id: runtimeId };
-    const poolKey = slotPoolKey(withReportedModelSlots(dispatchRuntime, deps.reportedModelSlots?.(runtimeId)), decision2.selected.modelID);
-    release = limiter.tryAcquire(poolKey, priority);
-    let waitedMs = 0;
-    if (release === undefined) {
-      const acquisition = await limiter.acquire(poolKey, priority);
-      release = acquisition.release;
-      waitedMs = acquisition.waitedMs;
-    }
-    queueObservation = {
-      runtimeId,
-      waitedMs,
-      activeCount: limiter.activeCount(poolKey),
-      queuedCount: limiter.queuedCount(poolKey)
-    };
-  }
-  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?.();
-  }
-}
-async function runRoleTask(input, deps) {
-  const batch = await resolveBatchReachability([input], deps);
-  return runRoleTaskWithCorrelation(input, deps, {
-    decisionID: deps.newDecisionID()
-  }, batch);
-}
-
-// src/console/protocol.ts
-function redactFrameText(text) {
-  return `[redacted · ${text.length} chars · ${hashPrompt(text)}]`;
-}
-var MAX_INPUT_CHARS = 1e5;
-var SessionInputSchema = z7.object({
-  text: z7.string().min(1).max(MAX_INPUT_CHARS)
-}).strict();
-function parseSessionInput(raw) {
-  const result = SessionInputSchema.safeParse(raw);
-  return result.success ? result.data : undefined;
-}
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : undefined;
-}
-function str(value) {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function eventSessionID(event) {
-  const props = asRecord(event.properties);
-  if (props === undefined) {
-    return;
-  }
-  return str(props.sessionID) ?? str(asRecord(props.part)?.sessionID) ?? str(asRecord(props.info)?.sessionID);
-}
-function partToFrame(part, options) {
-  if (part.type === "text") {
-    const text = str(part.text);
-    if (text === undefined) {
-      return;
-    }
-    return options.diagnostic === true ? { kind: "text", text } : { kind: "text", text: redactFrameText(text), redacted: true };
-  }
-  if (part.type === "tool") {
-    const tool = str(part.tool) ?? "tool";
-    const status = str(asRecord(part.state)?.status) ?? "run";
-    return { kind: "tool", text: `⚙ ${tool} · ${status}` };
-  }
-  return;
-}
-function messagesToFrames(raw, sessionID, options = {}) {
-  if (!Array.isArray(raw)) {
-    return [];
-  }
-  const frames = [];
-  for (const entry of raw) {
-    const record = asRecord(entry);
-    if (record === undefined) {
-      continue;
-    }
-    const info = asRecord(record.info);
-    const entrySession = str(info?.sessionID) ?? str(record.sessionID);
-    if (entrySession !== undefined && entrySession !== sessionID) {
-      continue;
-    }
-    const parts = record.parts;
-    if (!Array.isArray(parts)) {
-      continue;
-    }
-    for (const rawPart of parts) {
-      const part = asRecord(rawPart);
-      if (part === undefined) {
-        continue;
-      }
-      const frame = partToFrame(part, options);
-      if (frame !== undefined) {
-        frames.push(frame);
-      }
-    }
-  }
-  return frames;
-}
-function eventToSessionFrame(event, sessionID, options = {}) {
-  if (eventSessionID(event) !== sessionID) {
-    return;
-  }
-  const props = asRecord(event.properties) ?? {};
-  switch (event.type) {
-    case "message.part.updated": {
-      const part = asRecord(props.part);
-      return part === undefined ? undefined : partToFrame(part, options);
-    }
-    case "session.idle":
-      return { kind: "status", text: "● session ready" };
-    case "session.error": {
-      const err = asRecord(props.error);
-      const cls = classifyOpencodeSessionError(err === undefined ? undefined : { name: str(err.name), message: str(err.message) });
-      return { kind: "error", text: `✖ ${cls}` };
-    }
-    case "permission.updated": {
-      const title = str(props.title) ?? "permission requested";
-      const id = str(props.id);
-      const frame = { kind: "permission", text: `⚠ ${title}` };
-      if (id !== undefined) {
-        frame.permissionID = id;
-      }
-      return frame;
-    }
-    default:
-      return;
-  }
-}
-function frameToSse(frame) {
-  return `event: frame
-data: ${JSON.stringify(frame)}
-
-`;
-}
-
-// src/console/sse.ts
-function pushSse(buffer, chunk) {
-  const combined = (buffer + chunk).replace(/\r\n/g, `
-`);
-  const parts = combined.split(`
-
-`);
-  const rest = parts.pop() ?? "";
-  const messages = [];
-  for (const block of parts) {
-    if (block.length === 0) {
-      continue;
-    }
-    let event;
-    const dataLines = [];
-    for (const line of block.split(`
-`)) {
-      if (line.startsWith(":") || line.length === 0) {
-        continue;
-      }
-      if (line.startsWith("event:")) {
-        event = line.slice("event:".length).trimStart();
-      } else if (line.startsWith("data:")) {
-        dataLines.push(line.slice("data:".length).replace(/^ /, ""));
-      }
-    }
-    if (dataLines.length === 0 && event === undefined) {
-      continue;
-    }
-    const message = { data: dataLines.join(`
-`) };
-    if (event !== undefined) {
-      message.event = event;
-    }
-    messages.push(message);
-  }
-  return { messages, rest };
-}
-function parseEventData(data) {
-  if (data.length === 0) {
-    return;
-  }
-  try {
-    return JSON.parse(data);
-  } catch {
-    return;
-  }
-}
-
-// src/console/opencodeClient.ts
-function unwrapEvent(value) {
-  if (typeof value !== "object" || value === null) {
-    return;
-  }
-  const record = value;
-  const payload = typeof record.payload === "object" && record.payload !== null ? record.payload : record;
-  return typeof payload.type === "string" ? payload : undefined;
-}
-function messageToFrame(message, sessionID, options = {}) {
-  const event = unwrapEvent(parseEventData(message.data));
-  return event === undefined ? undefined : eventToSessionFrame(event, sessionID, options);
+function messageToFrame(message, sessionID, options = {}) {
+  const event = unwrapEvent(parseEventData(message.data));
+  return event === undefined ? undefined : eventToSessionFrame(event, sessionID, options);
 }
 function createConsoleClient(deps) {
   const doFetch = deps.fetch ?? fetch;
@@ -3199,7 +2058,7 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
     ]
   ],
   ["graph.worktrees", ["enabled"]],
-  ["orchestrator", ["roles"]]
+  ["orchestrator", ["roles", "maxRetries"]]
 ]);
 function isUnrecognizedKeysIssue(issue) {
   return issue.code === "unrecognized_keys" && Array.isArray(issue.keys);
@@ -4322,10 +3181,10 @@ function sessionsPanel(sessions) {
     "</section>"
   ].join("");
 }
-function decisionRow(decision2) {
-  const who = decision2.agent === undefined ? "" : `<span class="who">${escapeHtml(decision2.agent)}</span> `;
-  const tags = decision2.tags === undefined || decision2.tags.length === 0 ? "" : ` ${decision2.tags.map((tag) => `<span class="tag">#${escapeHtml(tag)}</span>`).join(" ")}`;
-  return `<li class="decision"><span class="kind">decision</span> ${who}${escapeHtml(decision2.summary)}${tags}</li>`;
+function decisionRow(decision) {
+  const who = decision.agent === undefined ? "" : `<span class="who">${escapeHtml(decision.agent)}</span> `;
+  const tags = decision.tags === undefined || decision.tags.length === 0 ? "" : ` ${decision.tags.map((tag) => `<span class="tag">#${escapeHtml(tag)}</span>`).join(" ")}`;
+  return `<li class="decision"><span class="kind">decision</span> ${who}${escapeHtml(decision.summary)}${tags}</li>`;
 }
 function decisionsPanel(decisions, idSuffix) {
   const id = panelId("panel-decisions", idSuffix);
@@ -5198,14 +4057,14 @@ function isRoute(event) {
 function recentRoutes(records, limit) {
   return [...records].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit)).map(toRouteView);
 }
-function decisionToActivity(decision2) {
+function decisionToActivity(decision) {
   const entry = {
-    ts: decision2.ts,
+    ts: decision.ts,
     kind: "decision",
-    summary: decision2.summary
+    summary: decision.summary
   };
-  if (decision2.agent !== undefined) {
-    entry.agent = decision2.agent;
+  if (decision.agent !== undefined) {
+    entry.agent = decision.agent;
   }
   return entry;
 }
@@ -5243,9 +4102,9 @@ function buildSessionTabs(aggregate, costRecords, nowMs, limits, options) {
   return aggregate.sessions.map((summary) => {
     const id = summary.sessionID;
     const routes = costRecords.filter((record) => record.sessionID === id);
-    const decisions = aggregate.decisions.filter((decision2) => decision2.sessionID === id).slice(0, Math.max(0, limits.decisionsLimit));
+    const decisions = aggregate.decisions.filter((decision) => decision.sessionID === id).slice(0, Math.max(0, limits.decisionsLimit));
     const meetings = aggregate.meetings.filter((meeting) => meeting.sessionID === id).slice(0, Math.max(0, limits.meetingsLimit));
-    const activity = composeActivity(aggregate.activity.filter((view) => view.sessionID === id), aggregate.decisions.filter((decision2) => decision2.sessionID === id), aggregate.meetings.filter((meeting) => meeting.sessionID === id), limits.activityLimit);
+    const activity = composeActivity(aggregate.activity.filter((view) => view.sessionID === id), aggregate.decisions.filter((decision) => decision.sessionID === id), aggregate.meetings.filter((meeting) => meeting.sessionID === id), limits.activityLimit);
     const tab = {
       sessionID: id,
       status: deriveSessionStatus(summary.lastTs, nowMs, {
@@ -8299,11 +7158,11 @@ function toErrorOutcome(error) {
 function createGraphIngress(deps) {
   const { policy, journal, lease, effects, holder } = deps;
   function taskGate(taskID) {
-    const decision2 = decideIngress(policy, taskID);
-    return decision2.route === "legacy" ? {
+    const decision = decideIngress(policy, taskID);
+    return decision.route === "legacy" ? {
       kind: "legacy",
-      reason: decision2.reason,
-      ...decision2.gateViolations !== undefined ? { gateViolations: decision2.gateViolations } : {}
+      reason: decision.reason,
+      ...decision.gateViolations !== undefined ? { gateViolations: decision.gateViolations } : {}
     } : undefined;
   }
   function runGate() {
@@ -9049,8 +7908,8 @@ import { promisify } from "node:util";
 var ORCHESTRATOR_AGENT_PATH = ".opencode/agent/openteam.md";
 var OPENTEAM_ROSTER_PATH = ".opencode/openteam/roster.md";
 var OPENTEAM_ROSTER_FILENAME = OPENTEAM_ROSTER_PATH.split("/").pop() ?? OPENTEAM_ROSTER_PATH;
-function buildOrchestratorAgent(frontier, options = {}) {
-  const model = `${frontier.providerID}/${frontier.modelID}`;
+function buildOrchestratorAgent(model, options = {}) {
+  const modelSpec = `${model.providerID}/${model.modelID}`;
   const permissionLines = options.yolo ? ["permission:", '  "*": allow'] : [
     "permission:",
     "  read: allow",
@@ -9069,7 +7928,7 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "---",
     'description: "openteam multi-agent orchestrator: on every request it checks whether a team exists; if not, it understands the tasks and creates the team of subagents on demand, plans dependencies, parallelizes independent work and keeps the todo list attributed to the owner of each task, with local-first routing."',
     "mode: primary",
-    `model: ${model}`,
+    `model: ${modelSpec}`,
     "temperature: 0.2",
     ...permissionLines,
     "---"
@@ -9277,7 +8136,34 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "- `directory` (optional): working directory if it differs from the current one.",
     "",
     "The tool returns a per-role summary: selected model, success or",
-    "failure, and created session. If one role fails, the rest keep running.",
+    "failure, the created session, and — for each role — a `report` file path",
+    "the role was required to write its findings to. The summary carries **no**",
+    "findings text itself (privacy boundary): the actual work lives only in those",
+    "report files. A durability gate verifies in code that each report was",
+    "actually written: a role that runs but leaves no usable report is reported",
+    "as failed with reason `report-missing-or-empty`, never as a plain success.",
+    "If one role fails, the rest keep running.",
+    "",
+    "### After `openteam-orchestrate` returns — READ the reports, then report",
+    "",
+    "When the tool returns, the orchestrated work is **already finished** — the",
+    "call is synchronous and every subsession has completed (or failed) by then.",
+    "You MUST:",
+    "",
+    "1. **READ each `report` file path** the tool returned (use the `read` tool).",
+    "   That file is the only place a role's findings exist; the tool result",
+    "   deliberately omits them.",
+    "2. **Synthesise the real findings** from those files for the user: what was",
+    "   found, what changed, conclusions, risks and follow-ups.",
+    "3. **Never report the task as `in_progress`, `pending`, or “the agent is",
+    "   working on it” after the tool has returned** — it has not; it is done.",
+    "4. **Never describe, summarise, or invent work you have not read** from a",
+    "   report file. If a role is reported as failed with reason",
+    "   `report-missing-or-empty`, the durability gate ran it but its findings",
+    "   were **not preserved to disk**: tell the user plainly that this role's",
+    "   work was done but not saved and must be re-run — never fabricate what it",
+    "   might have found. If a role failed for any other reason, report the",
+    "   failure and its reason.",
     "",
     "**Use `task` directly** only for ad-hoc subagents that are not in the",
     "roster (e.g. an agent created on demand for a one-off job).",
@@ -9851,7 +8737,7 @@ async function listOpenAICompatibleModels(baseURL, fetch2) {
   return parseOpenAIModels(payload);
 }
 function parseOpenAIModels(payload) {
-  if (!isObject2(payload) || !Array.isArray(payload.data)) {
+  if (!isObject(payload) || !Array.isArray(payload.data)) {
     throw new Error("Malformed /models response: expected data array");
   }
   return payload.data.map(parseOpenAIModel);
@@ -9886,7 +8772,7 @@ async function probeOpenAICompatibleRuntime(input) {
   }
 }
 function parseOpenAIModel(value) {
-  if (!isObject2(value) || typeof value.id !== "string" || value.id.length === 0) {
+  if (!isObject(value) || typeof value.id !== "string" || value.id.length === 0) {
     throw new Error("Malformed /models response: model id must be a string");
   }
   const contextWindow = readContextWindow(value);
@@ -9932,7 +8818,7 @@ function readCapabilityBoolean(value) {
     }
     return;
   }
-  if (!isObject2(value)) {
+  if (!isObject(value)) {
     return;
   }
   return readBoolean(value, [
@@ -9956,7 +8842,7 @@ function readContextWindow(model) {
   if (direct !== undefined) {
     return direct;
   }
-  if (isObject2(model.limit)) {
+  if (isObject(model.limit)) {
     return readPositiveInteger(model.limit, ["context"]);
   }
   return;
@@ -9979,7 +8865,7 @@ function readPositiveInteger(object, keys) {
   }
   return;
 }
-function isObject2(value) {
+function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -10139,11 +9025,11 @@ async function listLemonadeModels(baseURL, fetch2) {
 }
 function readNonTextModelIDs(payload) {
   const ids = new Set;
-  if (!isObject3(payload) || !Array.isArray(payload.data)) {
+  if (!isObject2(payload) || !Array.isArray(payload.data)) {
     return ids;
   }
   for (const entry of payload.data) {
-    if (!isObject3(entry) || typeof entry.id !== "string") {
+    if (!isObject2(entry) || typeof entry.id !== "string") {
       continue;
     }
     if (isNonTextModel(entry)) {
@@ -10172,12 +9058,12 @@ async function readLoadedModels(baseURL, fetch2) {
   } catch {
     return;
   }
-  if (!isObject3(payload) || !Array.isArray(payload.all_models_loaded)) {
+  if (!isObject2(payload) || !Array.isArray(payload.all_models_loaded)) {
     return;
   }
   const loaded = new Map;
   for (const entry of payload.all_models_loaded) {
-    if (!isObject3(entry) || typeof entry.model_name !== "string") {
+    if (!isObject2(entry) || typeof entry.model_name !== "string") {
       continue;
     }
     if (entry.loaded === false) {
@@ -10192,7 +9078,7 @@ function readSlotCount(entry) {
 }
 function slotsFromLlamacppArgs(entry) {
   const options = entry.recipe_options;
-  if (!isObject3(options) || typeof options.llamacpp_args !== "string") {
+  if (!isObject2(options) || typeof options.llamacpp_args !== "string") {
     return;
   }
   const match = PARALLEL_ARG.exec(options.llamacpp_args);
@@ -10245,7 +9131,7 @@ function enrichWithLoadState(models, loaded) {
     return hit.slots === undefined ? { ...model, loaded: true } : { ...model, loaded: true, slots: hit.slots };
   });
 }
-function isObject3(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -10344,9 +9230,6 @@ class RuntimeRegistry {
     return options;
   }
 }
-function anyRuntimeReachable(snapshots) {
-  return snapshots.some((snapshot) => snapshot.reachable);
-}
 
 // src/cli/setupAdapters.ts
 class PromptCancelledError extends Error {
@@ -10441,484 +9324,253 @@ var DETECTION_RUNTIMES = [
     baseURL: LEMONADE_DEFAULT_BASE_URL,
     defaultModel: { providerID: "lemonade", modelID: "probe" }
   },
-  {
-    id: "foundry-local",
-    enabled: true,
-    discovery: "cli",
-    defaultModel: { providerID: "foundry-local", modelID: "probe" }
-  }
-];
-function createLoadFrontierProfiles() {
-  return async () => {
-    try {
-      const result = await loadCapabilityProfiles({
-        fetch: globalThis.fetch,
-        now: () => Date.now()
-      });
-      return result.profiles.length > 0 ? result.profiles : [...CURATED_FRONTIER_PROFILES];
-    } catch {
-      return [...CURATED_FRONTIER_PROFILES];
-    }
-  };
-}
-function createDetect(exec) {
-  return async () => {
-    const registry = new RuntimeRegistry({
-      fetch: globalThis.fetch,
-      clock: () => new Date().toISOString(),
-      foundryDiscovery: foundryDiscoveryFromExec(exec)
-    });
-    const snapshots = await registry.probe(DETECTION_RUNTIMES);
-    return snapshots.map((snapshot) => {
-      const detected = {
-        id: snapshot.id,
-        baseURL: snapshot.baseURL,
-        reachable: snapshot.reachable,
-        models: snapshot.models.map((model) => model.modelID)
-      };
-      if (snapshot.models.some((model) => model.loaded !== undefined)) {
-        detected.modelInfo = snapshot.models;
-      }
-      if (snapshot.error !== undefined) {
-        detected.error = snapshot.error;
-      }
-      return detected;
-    });
-  };
-}
-function createProbeRuntime(exec) {
-  return async (id, baseURL) => {
-    const registry = new RuntimeRegistry({
-      fetch: globalThis.fetch,
-      clock: () => new Date().toISOString(),
-      foundryDiscovery: foundryDiscoveryFromExec(exec)
-    });
-    const runtime = {
-      id,
-      enabled: true,
-      baseURL,
-      defaultModel: { providerID: id, modelID: "probe" }
-    };
-    const [snapshot] = await registry.probe([runtime]);
-    const detected = {
-      id,
-      baseURL: snapshot?.baseURL ?? baseURL,
-      reachable: snapshot?.reachable ?? false,
-      models: snapshot?.models.map((model) => model.modelID) ?? []
-    };
-    if (snapshot?.models.some((model) => model.loaded !== undefined) === true) {
-      detected.modelInfo = snapshot.models;
-    }
-    if (snapshot?.error !== undefined) {
-      detected.error = snapshot.error;
-    }
-    return detected;
-  };
-}
-
-// src/config/graphFeatureGate.ts
-function checkCertificate(status, name) {
-  if (status.status === "absent") {
-    return {
-      code: `${name}-certificate-absent`,
-      detail: `${name} certificate not found — run the ${name} certification suite to produce it`
-    };
-  }
-  if (status.status === "invalid") {
-    return {
-      code: `${name}-certificate-invalid`,
-      detail: `${name} certificate rejected by recomputing parser: ${status.code} — ${status.detail}`
-    };
-  }
-  return;
-}
-function evaluateGraphGate(input) {
-  const violations = [];
-  const advisories = [];
-  const shadowV = checkCertificate(input.shadow, "shadow");
-  if (shadowV !== undefined)
-    violations.push(shadowV);
-  const releaseV = checkCertificate(input.release, "release");
-  if (releaseV !== undefined)
-    violations.push(releaseV);
-  const soakV = checkCertificate(input.soak, "soak");
-  if (soakV !== undefined)
-    advisories.push(soakV);
-  if (input.migration === "pending") {
-    violations.push({
-      code: "migration-pending",
-      detail: "legacy migration has pending work — run the migration tool to completion before enabling active mode"
-    });
-  } else if (input.migration === "unknown") {
-    violations.push({
-      code: "migration-unknown",
-      detail: "could not determine migration status — check ledger readability and storage access"
-    });
-  }
-  if (!input.operatorApproval) {
-    violations.push({
-      code: "operator-approval-missing",
-      detail: "set graph.operatorApproval to true in .opencode/openteam.json after reviewing all certificates and completing migration — this is a declaration of intent, not a proof"
-    });
-  }
-  return {
-    allowed: violations.length === 0,
-    violations,
-    advisories
-  };
-}
-function isGateApplicable(mode) {
-  return mode === "active";
-}
-
-// src/messages/commands.ts
-var clearCacheMessages = {
-  header: "openteam clear-cache — frozen plugin cache entries:",
-  columns: {
-    specDir: "spec dir",
-    pinned: "spec-pinned",
-    installed: "installed",
-    mtime: "mtime"
-  },
-  reparseSkipSuffix: "  [SKIP — reparse point]",
-  deletedLabel: "deleted.",
-  lockedLabel: (message) => `[LOCKED] ${message}`,
-  pathOutsideWarning: (specDir, absolutePath) => `  ⚠ ${specDir}: path outside cacheRoot (${absolutePath}), skipped.`,
-  processed: (count) => `${count} entry(ies) processed.`,
-  found: (count) => `${count} entry(ies) found. Use --delete to remove them.`
-};
-var baselineMessages = {
-  effectiveAuto: "cheapest-capable (auto)",
-  pinnedSuffix: (ref) => `${ref} (pinned)`,
-  summary: (params) => [
-    "openteam baseline:",
-    `  mode:      ${params.mode}`,
-    `  pinned:    ${params.pinned}`,
-    `  hardDefault: ${params.hardDefault}`,
-    `  effective: ${params.effective}`
-  ],
-  invalidModel: (input) => `Invalid model "${input}". Use the provider/model format, e.g. anthropic/claude-sonnet-4-5.`,
-  pinnedTo: (ref) => `Baseline pinned to ${ref} (pinned mode).`,
-  autoMode: "Baseline set to auto mode (cheapest-capable)."
-};
-var localMessages = {
-  help: {
-    status: "  openteam local status             Show the routing mode (local-first / local-only / frontier-only)",
-    off: "  openteam local off                Use frontier models only (no local runtime)",
-    only: "  openteam local only               Use local models only (never frontier)",
-    on: "  openteam local on                 Re-enable local-first routing"
-  },
-  noRuntimes: "none",
-  modeFrontierOnly: "frontier-only (frontierOnly)",
-  modeLocalOnly: "local-only (localOnly)",
-  modeLocalFirst: "local-first",
-  summary: (params) => [
-    "openteam local:",
-    `  mode:        ${params.mode}`,
-    `  frontierOnly: ${params.frontierOnly}`,
-    `  localOnly:    ${params.localOnly}`,
-    `  privacy:     ${params.privacy}`,
-    `  runtimes:    ${params.runtimes}`
-  ],
-  frontierOnlyNoChange: "No change: already in frontier-only mode.",
-  privacyAdjustedNote: " Privacy adjusted to 'consentBeforeFrontier' (forceLocalOnSensitive requires a local runtime).",
-  frontierOnlyEnabled: "Frontier-only mode enabled (frontierOnly=true, localOnly=false).",
-  localOnlyNoRuntimes: "Cannot enable local-only mode: no enabled local runtime is configured. Run 'openteam setup' or enable a local runtime in .opencode/openteam.json first.",
-  localOnlyNoChange: "No change: already in local-only mode.",
-  localOnlyEnabled: "Local-only mode enabled (localOnly=true, frontierOnly=false).",
-  localFirstNoChange: "No change: local-first routing is already active.",
-  localFirstReEnabled: "Local-first routing re-enabled (frontierOnly=false, localOnly=false). Make sure a local runtime is reachable.",
-  unknownSubcommand: (subcommand, help) => `Unknown local subcommand: ${subcommand}
-
-${help}`
-};
-var frontierCatalogMessages = {
-  free: "free",
-  costPerMillion: (inputUSD, outputUSD) => `$${inputUSD}/$${outputUSD} per 1M`
-};
-var migrateMessages = {
-  header: "openteam migrate:",
-  nothingToMigrate: "  nothing to migrate — the P15b layout is already in place.",
-  counts: (params) => [
-    `  moved:     ${params.moved} file(s)`,
-    `  deduped:   ${params.deduped} file(s) (destination already identical)`,
-    `  conflicts: ${params.conflicts} file(s)`
-  ],
-  relocatedHeader: "  relocated:",
-  relocatedEntry: (from, to, deduped) => `    · ${from} → ${to}${deduped ? " (deduped)" : ""}`,
-  conflictsHeader: "  ⚠ left in place (destination exists with different content — no data lost):",
-  conflictEntry: (from, to) => `    · ${from} → ${to}`,
-  manualWorktreesHeader: "  ⚠ legacy git worktree(s) need a manual move (run `git worktree move`):",
-  manualWorktreeEntry: (label, from, to) => `    · ${label}: ${from} → ${to}`,
-  success: "  ✓ machine-local runtime output relocated under .opencode/openteam-local/."
-};
-var rolesInitMessages = {
-  header: "openteam roles init:",
-  title: "openteam roles init",
-  noRoster: (path) => `  ✗ no roster at ${path}.`,
-  noRosterRemedy: "    Cast the team first: run `openteam setup`, then ask the orchestrator to register the cast.",
-  unparseableRoster: (path, error) => `  ✗ ${path} is present but unparseable: ${error}`,
-  unparseableRosterRemedy: "    Run `openteam doctor` for the remedy, then re-run this command.",
-  allProfiled: (count) => `  ✓ ${count} roster role(s) checked; no unprofiled roles — every role resolves a routing profile.`,
-  whyTitle: "Why you are being asked",
-  why: (count) => [
-    `${count} roster role(s) resolve no routing profile.`,
-    "Until a profile exists they are frontier-eligible: their work can escalate",
-    "to a frontier model. A 'local only' note in the roster prose does not",
-    "prevent this — prose outside the JSON fence is never read."
-  ].join(`
-`),
-  policyQuestion: (roleID, agentName) => `Routing policy for "${roleID}" (${agentName})`,
-  localOnlyLabel: (roleID, agentName) => `Local only — ${roleID} (${agentName}) never leaves this machine`,
-  localOnlyHint: "sets requiresLocalRuntime; the role fails closed when no local runtime is reachable",
-  frontierOkLabel: "Local first, frontier allowed",
-  frontierOkHint: "records today's implicit behaviour: cheapest-capable frontier when the task warrants it",
-  skipLabel: "Skip for now",
-  skipHint: "leaves the role unprofiled, so it stays frontier-eligible and doctor keeps reporting it",
-  runtimeQuestion: (roleID) => `Preferred local runtime(s) for "${roleID}" (in failover order)`,
-  runtimeHint: "machine-local — written to the git-ignored overlay",
-  cancelled: (reason) => `  ✗ cancelled (${reason}); nothing was written.`,
-  invalidResult: (reason) => `  ✗ refusing to write: the resulting config is invalid — ${reason}`,
-  nothingWritten: (skipped) => `  · skipped ${skipped}; nothing written.`,
-  nothingToWriteOutro: "Nothing to write.",
-  pinnedLocal: (roleIDs, path) => `  ✓ pinned local-only: ${roleIDs} → ${path} (tracked, travels with the roster)`,
-  frontierAllowed: (roleIDs, path) => `  ✓ frontier allowed: ${roleIDs} → ${path} (model choice stays "auto": cheapest-capable per task)`,
-  runtimeBinding: (path) => `  ✓ runtime binding: ${path} (git-ignored, machine-local)`,
-  skippedSummary: (roleIDs) => `  · skipped: ${roleIDs} — still frontier-eligible; re-run this command to revisit.`,
-  outro: "Role policy updated."
-};
-
-// src/orchestrator/ralphLoop.ts
-var RALPH_ROLE_ID = "ralph";
-var DEFAULT_RALPH_MAX_ITERATIONS = 10;
-function ralphTaskInput(input) {
-  const task = {
-    roleID: RALPH_ROLE_ID,
-    task: input.task,
-    prompt: input.prompt,
-    config: input.config
+  {
+    id: "foundry-local",
+    enabled: true,
+    discovery: "cli",
+    defaultModel: { providerID: "foundry-local", modelID: "probe" }
+  }
+];
+function createLoadFrontierProfiles() {
+  return async () => {
+    try {
+      const result = await loadCapabilityProfiles({
+        fetch: globalThis.fetch,
+        now: () => Date.now()
+      });
+      return result.profiles.length > 0 ? result.profiles : [...CURATED_FRONTIER_PROFILES];
+    } catch {
+      return [...CURATED_FRONTIER_PROFILES];
+    }
   };
-  if (input.parentSessionID !== undefined) {
-    task.parentSessionID = input.parentSessionID;
-  }
-  return task;
-}
-async function runRalphLoop(input, deps) {
-  const cap = input.maxIterations ?? DEFAULT_RALPH_MAX_ITERATIONS;
-  if (cap < 1) {
-    throw new Error(`openteam ralph loop: maxIterations must be >= 1, got ${cap}`);
-  }
-  const results = [];
-  const taskInput = ralphTaskInput(input);
-  while (results.length < cap) {
-    const result = await runRoleTask(taskInput, deps);
-    results.push(result);
-    if (deps.isDone(result)) {
-      return {
-        iterations: results.length,
-        termination: "done",
-        decision: result.decision,
-        results
+}
+function createDetect(exec) {
+  return async () => {
+    const registry = new RuntimeRegistry({
+      fetch: globalThis.fetch,
+      clock: () => new Date().toISOString(),
+      foundryDiscovery: foundryDiscoveryFromExec(exec)
+    });
+    const snapshots = await registry.probe(DETECTION_RUNTIMES);
+    return snapshots.map((snapshot) => {
+      const detected = {
+        id: snapshot.id,
+        baseURL: snapshot.baseURL,
+        reachable: snapshot.reachable,
+        models: snapshot.models.map((model) => model.modelID)
       };
+      if (snapshot.models.some((model) => model.loaded !== undefined)) {
+        detected.modelInfo = snapshot.models;
+      }
+      if (snapshot.error !== undefined) {
+        detected.error = snapshot.error;
+      }
+      return detected;
+    });
+  };
+}
+function createProbeRuntime(exec) {
+  return async (id, baseURL) => {
+    const registry = new RuntimeRegistry({
+      fetch: globalThis.fetch,
+      clock: () => new Date().toISOString(),
+      foundryDiscovery: foundryDiscoveryFromExec(exec)
+    });
+    const runtime = {
+      id,
+      enabled: true,
+      baseURL,
+      defaultModel: { providerID: id, modelID: "probe" }
+    };
+    const [snapshot] = await registry.probe([runtime]);
+    const detected = {
+      id,
+      baseURL: snapshot?.baseURL ?? baseURL,
+      reachable: snapshot?.reachable ?? false,
+      models: snapshot?.models.map((model) => model.modelID) ?? []
+    };
+    if (snapshot?.models.some((model) => model.loaded !== undefined) === true) {
+      detected.modelInfo = snapshot.models;
     }
-  }
-  return {
-    iterations: results.length,
-    termination: "cap",
-    decision: results.at(-1)?.decision,
-    results
+    if (snapshot?.error !== undefined) {
+      detected.error = snapshot.error;
+    }
+    return detected;
   };
 }
 
-// src/orchestrator/roster.ts
-import { z as z17 } from "zod";
-var RosterEntrySchema = z17.object({
-  roleID: z17.string().min(1),
-  agentName: z17.string().min(1)
-}).strict();
-var RosterSchema = z17.object({
-  universe: z17.string().min(1),
-  entries: z17.array(RosterEntrySchema)
-}).strict();
-var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
-
-class RosterParseError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "RosterParseError";
-    this.code = code;
-  }
-}
-function parseRoster(text2) {
-  const result = parseRosterResult(text2);
-  if (!result.ok) {
-    throw result.error;
-  }
-  return result.roster;
-}
-function parseRosterResult(text2) {
-  const match = ROSTER_JSON_FENCE.exec(text2);
-  if (match === null || match[1] === undefined) {
-    return {
-      ok: false,
-      error: new RosterParseError("missing-json-block", "openteam roster: no JSON block found in roster file")
-    };
-  }
-  let data;
-  try {
-    data = JSON.parse(match[1]);
-  } catch (error) {
+// src/config/graphFeatureGate.ts
+function checkCertificate(status, name) {
+  if (status.status === "absent") {
     return {
-      ok: false,
-      error: new RosterParseError("malformed-json", `openteam roster: malformed JSON in roster file: ${String(error)}`)
+      code: `${name}-certificate-absent`,
+      detail: `${name} certificate not found — run the ${name} certification suite to produce it`
     };
   }
-  const parsed = RosterSchema.safeParse(data);
-  if (!parsed.success) {
+  if (status.status === "invalid") {
     return {
-      ok: false,
-      error: new RosterParseError("invalid-roster-schema", `openteam roster: invalid roster schema: ${parsed.error.message}`)
+      code: `${name}-certificate-invalid`,
+      detail: `${name} certificate rejected by recomputing parser: ${status.code} — ${status.detail}`
     };
   }
-  return { ok: true, roster: parsed.data };
-}
-var GUARANTEED_ROLE_IDS = [
-  "orchestrator",
-  "guardian",
-  "scribe",
-  "ralph"
-];
-var GUARANTEED_ROLE_DEFAULT_AGENT_NAMES = {
-  orchestrator: "openteam",
-  guardian: "guardian",
-  scribe: "scribe",
-  ralph: "ralph"
-};
-function defaultAgentNameForGuaranteedRole(roleID) {
-  return GUARANTEED_ROLE_DEFAULT_AGENT_NAMES[roleID];
-}
-function isGuaranteedRoleID(roleID) {
-  return GUARANTEED_ROLE_IDS.includes(roleID);
-}
-function missingGuaranteedRoles(roster) {
-  const present = new Set(roster.entries.map((entry) => entry.roleID));
-  return GUARANTEED_ROLE_IDS.filter((roleID) => !present.has(roleID));
-}
-function isRoleProfileLike(value) {
-  return typeof value === "object" && value !== null && "roleID" in value && "defaultTier" in value;
-}
-function configuredRolesFromAuditInput(input) {
-  if ("configuredRoles" in input && !isRoleProfileLike(input.configuredRoles)) {
-    return input.configuredRoles;
-  }
-  return input;
+  return;
 }
-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);
+function evaluateGraphGate(input) {
+  const violations = [];
+  const advisories = [];
+  const shadowV = checkCertificate(input.shadow, "shadow");
+  if (shadowV !== undefined)
+    violations.push(shadowV);
+  const releaseV = checkCertificate(input.release, "release");
+  if (releaseV !== undefined)
+    violations.push(releaseV);
+  const soakV = checkCertificate(input.soak, "soak");
+  if (soakV !== undefined)
+    advisories.push(soakV);
+  if (input.migration === "pending") {
+    violations.push({
+      code: "migration-pending",
+      detail: "legacy migration has pending work — run the migration tool to completion before enabling active mode"
+    });
+  } else if (input.migration === "unknown") {
+    violations.push({
+      code: "migration-unknown",
+      detail: "could not determine migration status — check ledger readability and storage access"
+    });
   }
-  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) {
-    return roster;
+  if (!input.operatorApproval) {
+    violations.push({
+      code: "operator-approval-missing",
+      detail: "set graph.operatorApproval to true in .opencode/openteam.json after reviewing all certificates and completing migration — this is a declaration of intent, not a proof"
+    });
   }
-  const added = missing.map((roleID) => ({
-    roleID,
-    agentName: defaultAgentNameForGuaranteedRole(roleID)
-  }));
-  return { universe: roster.universe, entries: [...roster.entries, ...added] };
-}
-async function generateRoster(prompt, source) {
-  const draft = await source(prompt);
-  const validated = RosterSchema.parse(draft);
-  return enforceGuaranteedRoles(validated);
+  return {
+    allowed: violations.length === 0,
+    violations,
+    advisories
+  };
 }
-function missingAgentFileMessage(agentName) {
-  return `openteam: guaranteed role agent "${agentName}" has no agent file in this workspace, ` + `so it cannot be dispatched. Run \`openteam setup\` to generate the required agent ` + `files before dispatching (see #153).`;
+function isGateApplicable(mode) {
+  return mode === "active";
 }
 
+// src/messages/commands.ts
+var clearCacheMessages = {
+  header: "openteam clear-cache — frozen plugin cache entries:",
+  columns: {
+    specDir: "spec dir",
+    pinned: "spec-pinned",
+    installed: "installed",
+    mtime: "mtime"
+  },
+  reparseSkipSuffix: "  [SKIP — reparse point]",
+  deletedLabel: "deleted.",
+  lockedLabel: (message) => `[LOCKED] ${message}`,
+  pathOutsideWarning: (specDir, absolutePath) => `  ⚠ ${specDir}: path outside cacheRoot (${absolutePath}), skipped.`,
+  processed: (count) => `${count} entry(ies) processed.`,
+  found: (count) => `${count} entry(ies) found. Use --delete to remove them.`
+};
+var baselineMessages = {
+  effectiveAuto: "cheapest-capable (auto)",
+  pinnedSuffix: (ref) => `${ref} (pinned)`,
+  summary: (params) => [
+    "openteam baseline:",
+    `  mode:      ${params.mode}`,
+    `  pinned:    ${params.pinned}`,
+    `  hardDefault: ${params.hardDefault}`,
+    `  effective: ${params.effective}`
+  ],
+  invalidModel: (input) => `Invalid model "${input}". Use the provider/model format, e.g. anthropic/claude-sonnet-4-5.`,
+  pinnedTo: (ref) => `Baseline pinned to ${ref} (pinned mode).`,
+  autoMode: "Baseline set to auto mode (cheapest-capable)."
+};
+var localMessages = {
+  help: {
+    status: "  openteam local status             Show the routing mode (local-first / local-only / frontier-only)",
+    off: "  openteam local off                Use frontier models only (no local runtime)",
+    only: "  openteam local only               Use local models only (never frontier)",
+    on: "  openteam local on                 Re-enable local-first routing"
+  },
+  noRuntimes: "none",
+  modeFrontierOnly: "frontier-only (frontierOnly)",
+  modeLocalOnly: "local-only (localOnly)",
+  modeLocalFirst: "local-first",
+  summary: (params) => [
+    "openteam local:",
+    `  mode:        ${params.mode}`,
+    `  frontierOnly: ${params.frontierOnly}`,
+    `  localOnly:    ${params.localOnly}`,
+    `  privacy:     ${params.privacy}`,
+    `  runtimes:    ${params.runtimes}`
+  ],
+  frontierOnlyNoChange: "No change: already in frontier-only mode.",
+  privacyAdjustedNote: " Privacy adjusted to 'consentBeforeFrontier' (forceLocalOnSensitive requires a local runtime).",
+  frontierOnlyEnabled: "Frontier-only mode enabled (frontierOnly=true, localOnly=false).",
+  localOnlyNoRuntimes: "Cannot enable local-only mode: no enabled local runtime is configured. Run 'openteam setup' or enable a local runtime in .opencode/openteam.json first.",
+  localOnlyNoChange: "No change: already in local-only mode.",
+  localOnlyEnabled: "Local-only mode enabled (localOnly=true, frontierOnly=false).",
+  localFirstNoChange: "No change: local-first routing is already active.",
+  localFirstReEnabled: "Local-first routing re-enabled (frontierOnly=false, localOnly=false). Make sure a local runtime is reachable.",
+  unknownSubcommand: (subcommand, help) => `Unknown local subcommand: ${subcommand}
+
+${help}`
+};
+var frontierCatalogMessages = {
+  free: "free",
+  costPerMillion: (inputUSD, outputUSD) => `$${inputUSD}/$${outputUSD} per 1M`
+};
+var migrateMessages = {
+  header: "openteam migrate:",
+  nothingToMigrate: "  nothing to migrate — the P15b layout is already in place.",
+  counts: (params) => [
+    `  moved:     ${params.moved} file(s)`,
+    `  deduped:   ${params.deduped} file(s) (destination already identical)`,
+    `  conflicts: ${params.conflicts} file(s)`
+  ],
+  relocatedHeader: "  relocated:",
+  relocatedEntry: (from, to, deduped) => `    · ${from} → ${to}${deduped ? " (deduped)" : ""}`,
+  conflictsHeader: "  ⚠ left in place (destination exists with different content — no data lost):",
+  conflictEntry: (from, to) => `    · ${from} → ${to}`,
+  manualWorktreesHeader: "  ⚠ legacy git worktree(s) need a manual move (run `git worktree move`):",
+  manualWorktreeEntry: (label, from, to) => `    · ${label}: ${from} → ${to}`,
+  success: "  ✓ machine-local runtime output relocated under .opencode/openteam-local/."
+};
+var rolesInitMessages = {
+  header: "openteam roles init:",
+  title: "openteam roles init",
+  noRoster: (path) => `  ✗ no roster at ${path}.`,
+  noRosterRemedy: "    Cast the team first: run `openteam setup`, then ask the orchestrator to register the cast.",
+  unparseableRoster: (path, error) => `  ✗ ${path} is present but unparseable: ${error}`,
+  unparseableRosterRemedy: "    Run `openteam doctor` for the remedy, then re-run this command.",
+  allProfiled: (count) => `  ✓ ${count} roster role(s) checked; no unprofiled roles — every role resolves a routing profile.`,
+  whyTitle: "Why you are being asked",
+  why: (count) => [
+    `${count} roster role(s) resolve no routing profile.`,
+    "Until a profile exists they are frontier-eligible: their work can escalate",
+    "to a frontier model. A 'local only' note in the roster prose does not",
+    "prevent this — prose outside the JSON fence is never read."
+  ].join(`
+`),
+  policyQuestion: (roleID, agentName) => `Routing policy for "${roleID}" (${agentName})`,
+  localOnlyLabel: (roleID, agentName) => `Local only — ${roleID} (${agentName}) never leaves this machine`,
+  localOnlyHint: "sets requiresLocalRuntime; the role fails closed when no local runtime is reachable",
+  frontierOkLabel: "Local first, frontier allowed",
+  frontierOkHint: "records today's implicit behaviour: cheapest-capable frontier when the task warrants it",
+  skipLabel: "Skip for now",
+  skipHint: "leaves the role unprofiled, so it stays frontier-eligible and doctor keeps reporting it",
+  runtimeQuestion: (roleID) => `Preferred local runtime(s) for "${roleID}" (in failover order)`,
+  runtimeHint: "machine-local — written to the git-ignored overlay",
+  cancelled: (reason) => `  ✗ cancelled (${reason}); nothing was written.`,
+  invalidResult: (reason) => `  ✗ refusing to write: the resulting config is invalid — ${reason}`,
+  nothingWritten: (skipped) => `  · skipped ${skipped}; nothing written.`,
+  nothingToWriteOutro: "Nothing to write.",
+  pinnedLocal: (roleIDs, path) => `  ✓ pinned local-only: ${roleIDs} → ${path} (tracked, travels with the roster)`,
+  frontierAllowed: (roleIDs, path) => `  ✓ frontier allowed: ${roleIDs} → ${path} (model choice stays "auto": cheapest-capable per task)`,
+  runtimeBinding: (path) => `  ✓ runtime binding: ${path} (git-ignored, machine-local)`,
+  skippedSummary: (roleIDs) => `  · skipped: ${roleIDs} — still frontier-eligible; re-run this command to revisit.`,
+  outro: "Role policy updated."
+};
+
 // src/orchestrator/worktreeReconciler.ts
 function planOne(wt) {
   const base = { runID: wt.runID, path: wt.path };
@@ -10973,11 +9625,11 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z18 } from "zod";
-var OtelBackendConfigSchema = z18.object({
-  backend: z18.literal("opentelemetry"),
-  connectionEnv: z18.string().min(1),
-  serviceName: z18.string().min(1).optional()
+import { z as z17 } from "zod";
+var OtelBackendConfigSchema = z17.object({
+  backend: z17.literal("opentelemetry"),
+  connectionEnv: z17.string().min(1),
+  serviceName: z17.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -11501,7 +10153,7 @@ function gitignoreSection(gitignore) {
   lines.push(`      remedy: add ${quoted} to ${gitignore.path} (or re-run \`openteam setup\`), then re-run \`openteam doctor\`.`);
   return lines;
 }
-function agentModelsSection(diagnostics, searchedPaths) {
+function agentModelsSection(diagnostics, searchedPaths, localOnly) {
   const lines = ["  agent models:"];
   if (diagnostics.length === 0) {
     lines.push("    (no agent files in .opencode/agent/)");
@@ -11515,6 +10167,13 @@ function agentModelsSection(diagnostics, searchedPaths) {
   if (broken > 0) {
     lines.push(`    ⚠ ${broken} agent model(s) will not resolve. This is an agent 'model:' declaration error, not the openteam router.`);
   }
+  const localOnlyGap = localOnly ? diagnostics.find((d) => d.mode === "primary" && d.resolution?.status === "unresolvable" && d.resolution.reason === "provider-not-configured") : undefined;
+  if (localOnlyGap?.model !== undefined) {
+    lines.push(`    ✗ local-only mode, but the primary agent '${localOnlyGap.name}' points at provider '${localOnlyGap.model.providerID}', which opencode.json does not configure.`);
+    lines.push("      cause: `openteam setup` recorded the frontier baseline placeholder as this agent's `model:`. That value is correctly inert as baseline.hardDefault while router.localOnly is true, but an agent's own `model:` is load-bearing, so opencode cannot resolve the coordinator against your local-only providers.");
+    lines.push("      consequence: opencode cannot start the openteam coordinator, so it reads no roster and splits no work — even though every subagent resolves on your local runtime.");
+    lines.push(`      remedy: re-run \`openteam setup\` and keep local-only mode to regenerate ${localOnlyGap.sourceFile} with your local thinking model, then re-run \`openteam doctor\`.`);
+  }
   lines.push("    note: 'declared' = model set in .opencode/agent/<name>.md frontmatter; 'inherited' = opencode.json default.");
   lines.push("    note: static checks are offline and deterministic; live checks need a reachable local runtime and can be inconclusive.");
   return lines;
@@ -11603,7 +10262,7 @@ function renderDoctor(input) {
     lines.push("    Run `openteam clear-cache --delete` to clean up.");
   }
   if (input.agentModels !== undefined) {
-    lines.push(...agentModelsSection(input.agentModels, input.opencodeConfigPaths ?? []));
+    lines.push(...agentModelsSection(input.agentModels, input.opencodeConfigPaths ?? [], input.config.router.localOnly));
   }
   if (input.opencodeConfigError !== undefined) {
     lines.push(`  ⚠ opencode config parse error: ${input.opencodeConfigError}`);
@@ -11914,31 +10573,31 @@ function mergeOpencodeConfigs(base, override) {
 }
 
 // src/graph/soakLedger.ts
-import { z as z19 } from "zod";
-var Sha256Schema2 = z19.string().regex(/^[0-9a-f]{64}$/);
-var SoakPlatformSchema = z19.enum(["linux", "win32", "darwin"]);
-var PrivacyPairSchema = z19.object({
-  surfacesScanned: z19.number().int().nonnegative(),
-  rawFindings: z19.number().int().nonnegative()
+import { z as z18 } from "zod";
+var Sha256Schema2 = z18.string().regex(/^[0-9a-f]{64}$/);
+var SoakPlatformSchema = z18.enum(["linux", "win32", "darwin"]);
+var PrivacyPairSchema = z18.object({
+  surfacesScanned: z18.number().int().nonnegative(),
+  rawFindings: z18.number().int().nonnegative()
 }).strict();
-var DuplicateEffectPairSchema = z19.object({
-  effectsExamined: z19.number().int().nonnegative(),
-  duplicatesFound: z19.number().int().nonnegative()
+var DuplicateEffectPairSchema = z18.object({
+  effectsExamined: z18.number().int().nonnegative(),
+  duplicatesFound: z18.number().int().nonnegative()
 }).strict();
-var ModelVerificationPairSchema = z19.object({
-  nodesChecked: z19.number().int().nonnegative(),
-  unverified: z19.number().int().nonnegative(),
-  mismatched: z19.number().int().nonnegative()
+var ModelVerificationPairSchema = z18.object({
+  nodesChecked: z18.number().int().nonnegative(),
+  unverified: z18.number().int().nonnegative(),
+  mismatched: z18.number().int().nonnegative()
 }).strict();
-var SoakObservationSchema = z19.object({
-  version: z19.literal(1),
-  seq: z19.number().int().nonnegative(),
-  timestamp: z19.string().datetime(),
+var SoakObservationSchema = z18.object({
+  version: z18.literal(1),
+  seq: z18.number().int().nonnegative(),
+  timestamp: z18.string().datetime(),
   platform: SoakPlatformSchema,
-  opencodeVersion: z19.string().min(1),
-  provenance: z19.enum(["genuine-usage", "ci-synthetic"]),
+  opencodeVersion: z18.string().min(1),
+  provenance: z18.enum(["genuine-usage", "ci-synthetic"]),
   traceDigest: Sha256Schema2,
-  criticalDivergences: z19.number().int().nonnegative().nullable(),
+  criticalDivergences: z18.number().int().nonnegative().nullable(),
   privacy: PrivacyPairSchema.nullable(),
   duplicateEffects: DuplicateEffectPairSchema.nullable(),
   modelVerification: ModelVerificationPairSchema.nullable(),
@@ -12297,7 +10956,7 @@ function buildOpenTeamConfig(answers) {
     return runtime;
   });
   const primaryLocal = firstEnabled(answers.runtimes);
-  const localDefault2 = primaryLocal !== undefined ? {
+  const localDefault = primaryLocal !== undefined ? {
     providerID: choiceProviderID(primaryLocal),
     modelID: primaryLocal.defaultModelID
   } : null;
@@ -12310,7 +10969,7 @@ function buildOpenTeamConfig(answers) {
     },
     router: {
       mode: answers.routerMode,
-      localDefault: localDefault2,
+      localDefault,
       frontierOnly: primaryLocal === undefined,
       localOnly
     },
@@ -12319,6 +10978,19 @@ function buildOpenTeamConfig(answers) {
     graph: { mode: "active" }
   });
 }
+function orchestratorAgentModel(answers) {
+  const primaryLocal = firstEnabled(answers.runtimes);
+  if (answers.localOnly === true && primaryLocal !== undefined) {
+    return {
+      providerID: choiceProviderID(primaryLocal),
+      modelID: primaryLocal.thinkingModelID ?? primaryLocal.defaultModelID
+    };
+  }
+  return {
+    providerID: answers.frontier.providerID,
+    modelID: answers.frontier.modelID
+  };
+}
 function buildOpencodeConfig(answers) {
   const provider = {};
   const providerOwner = new Map;
@@ -12849,7 +11521,7 @@ async function runSetup(deps) {
     };
     const openTeamConfig = buildOpenTeamConfig(answers);
     const opencodeConfig = buildOpencodeConfig(answers);
-    const orchestratorAgent = buildOrchestratorAgent(frontier, { yolo });
+    const orchestratorAgent = buildOrchestratorAgent(orchestratorAgentModel(answers), { yolo });
     const slashCommands = buildOpenteamCommands();
     const openTeamPath = DEFAULT_CONFIG_PATH;
     const existingOpencodePath = await deps.resolveOpencodeWriteTarget(OPENCODE_CONFIG_CANDIDATES);
@@ -13627,8 +12299,6 @@ var HELP = [
   "  openteam graph cancel <run>       Cancel an active Graph run",
   "  openteam graph recover            Recover a partial tail of the Graph journal",
   "  openteam graph worktrees          Reconcile orphaned Graph worktrees",
-  "  openteam loop                     Unattended Ralph-pattern loop over the backlog (see #152)",
-  "  openteam loop --dry-run           Preview the loop plan without dispatching anything",
   "  openteam mcp                      Read-only MCP server (team memory) over stdio",
   "  openteam report                   Cost/savings summary (telemetry)",
   "  openteam clear-cache              List the plugin's frozen cache entries",
@@ -13670,29 +12340,6 @@ var PURGE_HELP = [
   "A non-interactive terminal without --yes fails instead of hanging."
 ].join(`
 `);
-var LOOP_HELP = [
-  "openteam loop — unattended Ralph-pattern loop over the shared backlog (#152)",
-  "",
-  "Usage:",
-  "  openteam loop --dry-run   Preview the plan (iterations, prompt, stops); dispatch nothing",
-  "  openteam loop --yes       Run unattended until the backlog is empty or a stop fires",
-  "",
-  "Options:",
-  "  --max-iterations <N>    Maximum iterations (default 20)",
-  "  --budget-usd <N>        Spend ceiling",
-  "  --sleep <seconds>       Pause between iterations (default 2)",
-  "  --no-progress-limit <N> Stop after N iterations with no progress (default 2)",
-  "  --fresh-context         New context per iteration (default on — the pure Ralph pattern)",
-  "  --no-fresh-context      Keep context across iterations",
-  "  --stop-on-red-tests     Stop when the gates go red",
-  "  --backlog <path>        Backlog Markdown file (default .opencode/openteam/backlog.md)",
-  "  --dry-run               Print the plan and invoke nothing",
-  "  --yes                   Run unattended",
-  "",
-  "Stops are evaluated BEFORE each iteration spends: empty backlog, max-iterations,",
-  "budget, red tests, no-progress."
-].join(`
-`);
 var GRAPH_OPERATOR_TASK_ID = "graph-operator";
 var PURGE_FLAG_TO_CATEGORY = new Map(Object.entries(PURGE_CATEGORY_FLAG).map(([id, flag]) => [flag, id]));
 function parseArgs(argv) {
@@ -13875,8 +12522,8 @@ async function regenerateOrchestratorAgent(deps, config, enable) {
 Warning: could not regenerate ${deps.orchestratorAgentPath} (missing 'model' in opencode.json); adjust its permission by hand.`;
   }
   try {
-    const frontier = parseModelRef(model);
-    const contents = buildOrchestratorAgent(frontier, { yolo: enable });
+    const agentModel2 = parseModelRef(model);
+    const contents = buildOrchestratorAgent(agentModel2, { yolo: enable });
     await deps.writeOrchestratorAgent(contents, deps.orchestratorAgentPath);
     return `
 ${deps.orchestratorAgentPath} regenerated (permission aligned with YOLO).`;
@@ -13998,13 +12645,13 @@ async function resolveOperatorGraphPolicy(config, operator) {
   };
 }
 function checkOperatorGate(policy) {
-  const decision2 = decideIngress(policy, GRAPH_OPERATOR_TASK_ID);
-  if (decision2.route === "graph") {
+  const decision = decideIngress(policy, GRAPH_OPERATOR_TASK_ID);
+  if (decision.route === "graph") {
     return;
   }
   return {
     exitCode: 1,
-    stdout: renderLegacyGraphReason(decision2)
+    stdout: renderLegacyGraphReason(decision)
   };
 }
 async function runGraphStatus(deps, configPath, configResolution) {
@@ -14072,327 +12719,62 @@ async function runGraphRecover(deps, configPath, configResolution) {
   const operator = requireGraphOperator(deps);
   const snapshot = await deps.readGraphSnapshot(configPath, configResolution);
   const plan2 = planGraphRecover(snapshot);
-  if (plan2.kind === "none") {
-    return {
-      exitCode: 0,
-      stdout: `openteam graph recover: ${plan2.reason}`
-    };
-  }
-  if (plan2.kind === "blocked") {
-    return {
-      exitCode: 1,
-      stdout: `openteam graph recover: ${plan2.reason}`
-    };
-  }
-  const config = await deps.loadConfig(configPath, configResolution);
-  const policy = await resolveOperatorGraphPolicy(config, operator);
-  const blocked = checkOperatorGate(policy);
-  if (blocked !== undefined) {
-    return blocked;
-  }
-  const recovered = await operator.recovery.recover(config);
-  return {
-    exitCode: 0,
-    stdout: `openteam graph recover: ${recovered.reason} (${recovered.tail})`
-  };
-}
-async function runGraphWorktrees(deps, configPath, configResolution) {
-  const operator = requireGraphOperator(deps);
-  const config = await deps.loadConfig(configPath, configResolution);
-  const enabled = config.graph?.worktrees?.enabled ?? false;
-  if (!enabled) {
-    return {
-      exitCode: 0,
-      stdout: renderWorktreeReconciliation(planWorktreeReconciliation({ enabled: false, worktrees: [] }))
-    };
-  }
-  const policy = await resolveOperatorGraphPolicy(config, operator);
-  const blocked = checkOperatorGate(policy);
-  if (blocked !== undefined) {
-    return blocked;
-  }
-  const observations = await operator.worktrees.listObservations(config);
-  const report = planWorktreeReconciliation({
-    enabled,
-    worktrees: observations
-  });
-  if (report.plans.length === 0) {
-    return { exitCode: 0, stdout: renderWorktreeReconciliation(report) };
-  }
-  for (const plan2 of report.plans) {
-    if (!plan2.safe || plan2.action === "retain" || plan2.action === "block") {
-      continue;
-    }
-    await operator.worktrees.apply(plan2.action, plan2.runID);
-  }
-  return {
-    exitCode: report.blocked > 0 ? 1 : 0,
-    stdout: renderWorktreeReconciliation(report)
-  };
-}
-var DEFAULT_LOOP_MAX_ITERATIONS = 20;
-var DEFAULT_LOOP_SLEEP_SECONDS = 2;
-var DEFAULT_LOOP_NO_PROGRESS_LIMIT = 2;
-var DEFAULT_LOOP_BACKLOG_PATH = ".opencode/openteam/backlog.md";
-var BACKLOG_LINE = /^(\s*)- \[( |x|X)\]\s+(.*)$/;
-var BACKLOG_CAST = /^\[@([^\]]+)\]\s*(.*)$/;
-function parseBacklog2(text2) {
-  const items = [];
-  const lines = text2.split(/\r?\n/);
-  for (let i = 0;i < lines.length; i += 1) {
-    const match = BACKLOG_LINE.exec(lines[i] ?? "");
-    if (match === null) {
-      continue;
-    }
-    const checked = (match[2] ?? " ").toLowerCase() === "x";
-    const rest = match[3] ?? "";
-    const cast = BACKLOG_CAST.exec(rest);
-    const item = cast ? { line: i, text: (cast[2] ?? "").trim(), checked, cast: cast[1] ?? "" } : { line: i, text: rest.trim(), checked };
-    items.push(item);
-  }
-  return items;
-}
-function uncheckedBacklogItems(items) {
-  return items.filter((item) => !item.checked);
-}
-function markBacklogLineDone(text2, line) {
-  const lines = text2.split(`
-`);
-  const target = lines[line];
-  if (target === undefined) {
-    return text2;
-  }
-  lines[line] = target.replace(/- \[ \]/, "- [x]");
-  return lines.join(`
-`);
-}
-function evaluateLoopStop(state) {
-  if (state.uncheckedCount <= 0) {
-    return { stop: true, reason: "empty-backlog" };
-  }
-  if (state.iteration >= state.maxIterations) {
-    return { stop: true, reason: "max-iterations" };
-  }
-  if (state.budgetUsd !== undefined && state.spentUsd >= state.budgetUsd) {
-    return { stop: true, reason: "budget-exhausted" };
-  }
-  if (state.stopOnRedTests && state.testsRed) {
-    return { stop: true, reason: "red-tests" };
-  }
-  if (state.noProgressCount >= state.noProgressLimit) {
-    return { stop: true, reason: "no-progress" };
-  }
-  return { stop: false };
-}
-function parsePositiveNumber(raw, flag) {
-  if (raw === undefined) {
-    return { error: `Missing value for ${flag}` };
-  }
-  const value = Number(raw);
-  if (!Number.isFinite(value) || value <= 0) {
-    return { error: `${flag} expects a positive number, got "${raw}"` };
-  }
-  return { value };
-}
-function parseLoopFlags(argv) {
-  const flags = {
-    maxIterations: DEFAULT_LOOP_MAX_ITERATIONS,
-    sleepSeconds: DEFAULT_LOOP_SLEEP_SECONDS,
-    noProgressLimit: DEFAULT_LOOP_NO_PROGRESS_LIMIT,
-    freshContext: true,
-    stopOnRedTests: false,
-    dryRun: false,
-    yes: false,
-    backlogPath: DEFAULT_LOOP_BACKLOG_PATH
-  };
-  for (let i = 0;i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === "--config" || arg === "--telemetry") {
-      i += 1;
-      continue;
-    }
-    if (arg === "--dry-run") {
-      flags.dryRun = true;
-    } else if (arg === "--yes" || arg === "-y") {
-      flags.yes = true;
-    } else if (arg === "--fresh-context") {
-      flags.freshContext = true;
-    } else if (arg === "--no-fresh-context") {
-      flags.freshContext = false;
-    } else if (arg === "--stop-on-red-tests") {
-      flags.stopOnRedTests = true;
-    } else if (arg === "--max-iterations") {
-      const parsed = parsePositiveNumber(argv[i + 1], arg);
-      if ("error" in parsed)
-        return { ok: false, error: parsed.error };
-      flags.maxIterations = Math.floor(parsed.value);
-      i += 1;
-    } else if (arg === "--budget-usd") {
-      const parsed = parsePositiveNumber(argv[i + 1], arg);
-      if ("error" in parsed)
-        return { ok: false, error: parsed.error };
-      flags.budgetUsd = parsed.value;
-      i += 1;
-    } else if (arg === "--sleep") {
-      const parsed = parsePositiveNumber(argv[i + 1], arg);
-      if ("error" in parsed)
-        return { ok: false, error: parsed.error };
-      flags.sleepSeconds = parsed.value;
-      i += 1;
-    } else if (arg === "--no-progress-limit") {
-      const parsed = parsePositiveNumber(argv[i + 1], arg);
-      if ("error" in parsed)
-        return { ok: false, error: parsed.error };
-      flags.noProgressLimit = Math.floor(parsed.value);
-      i += 1;
-    } else if (arg === "--backlog") {
-      const value = argv[i + 1];
-      if (value === undefined) {
-        return { ok: false, error: "Missing value for --backlog" };
-      }
-      flags.backlogPath = value;
-      i += 1;
-    }
-  }
-  return { ok: true, flags };
-}
-var LOOP_GUARANTEED_ROLE_IDS = [RALPH_ROLE_ID, "guardian", "scribe"];
-function guaranteedAgentName(roleID) {
-  return TEAM_ROLES[roleID]?.opencodeAgent ?? roleID;
-}
-async function guaranteedAgentStatuses(runtime) {
-  const statuses = [];
-  for (const roleID of LOOP_GUARANTEED_ROLE_IDS) {
-    const agentName = guaranteedAgentName(roleID);
-    statuses.push({
-      roleID,
-      agentName,
-      exists: await runtime.agentFileExists(agentName)
-    });
-  }
-  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 = rosterPlanSummary(plan2.rosterFile);
-  const lines = [
-    "openteam loop — plan (dry run, nothing dispatched):",
-    `  backlog:       ${flags.backlogPath} (${plan2.uncheckedCount} unchecked item(s))`,
-    `  iterations:    up to ${plan2.plannedIterations} (max-iterations ${flags.maxIterations})`,
-    `  budget:        ${budget}`,
-    `  sleep:         ${flags.sleepSeconds}s between iterations`,
-    `  fresh context: ${freshContext}`,
-    `  stop before spending on: empty backlog, max-iterations${budgetStop}${redTestsStop}, no-progress (${flags.noProgressLimit})`,
-    `  roster:        ${rosterSummary}`
-  ];
-  for (const role of plan2.guaranteed) {
-    const mark = role.exists ? "✓" : "✗ missing — run 'openteam setup'";
-    lines.push(`  role ${role.roleID} → agent ${role.agentName}: ${mark}`);
-  }
-  return lines.join(`
-`);
-}
-function backlogPrompt(freshContext, items) {
-  const next = uncheckedBacklogItems(items)[0];
-  const header = freshContext ? "You are ralph, the loop driver. Fresh context each iteration." : "You are ralph, the loop driver.";
-  const focus = next !== undefined ? `Work the next backlog item to completion: ${next.text}` : "The backlog is empty.";
-  return `${header}
-${focus}`;
-}
-async function runLoop(argv, deps, configPath, configResolution) {
-  const parsed = parseLoopFlags(argv);
-  if (!parsed.ok) {
-    return { exitCode: 1, stdout: `${parsed.error}
-
-${LOOP_HELP}` };
-  }
-  const { flags } = parsed;
-  if (deps.loopRuntime === undefined) {
+  if (plan2.kind === "none") {
     return {
-      exitCode: 1,
-      stdout: "The loop runtime is not configured in this environment."
+      exitCode: 0,
+      stdout: `openteam graph recover: ${plan2.reason}`
     };
   }
-  const runtime = deps.loopRuntime;
-  const config = await deps.loadConfig(configPath, configResolution);
-  const backlogText = await runtime.readBacklog(flags.backlogPath) ?? "";
-  const items = parseBacklog2(backlogText);
-  const unchecked = uncheckedBacklogItems(items);
-  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,
-    rosterFile,
-    guaranteed
-  };
-  if (flags.dryRun) {
-    return { exitCode: 0, stdout: renderLoopPlan(plan2) };
-  }
-  if (!flags.yes) {
+  if (plan2.kind === "blocked") {
     return {
       exitCode: 1,
-      stdout: "Refusing to run unattended without confirmation. Re-run with --dry-run to preview the plan, or --yes to run."
+      stdout: `openteam graph recover: ${plan2.reason}`
     };
   }
-  const preStop = evaluateLoopStop({
-    uncheckedCount: unchecked.length,
-    iteration: 0,
-    maxIterations: flags.maxIterations,
-    ...flags.budgetUsd !== undefined ? { budgetUsd: flags.budgetUsd } : {},
-    spentUsd: 0,
-    stopOnRedTests: flags.stopOnRedTests,
-    testsRed: false,
-    noProgressCount: 0,
-    noProgressLimit: flags.noProgressLimit
-  });
-  if (preStop.stop) {
+  const config = await deps.loadConfig(configPath, configResolution);
+  const policy = await resolveOperatorGraphPolicy(config, operator);
+  const blocked = checkOperatorGate(policy);
+  if (blocked !== undefined) {
+    return blocked;
+  }
+  const recovered = await operator.recovery.recover(config);
+  return {
+    exitCode: 0,
+    stdout: `openteam graph recover: ${recovered.reason} (${recovered.tail})`
+  };
+}
+async function runGraphWorktrees(deps, configPath, configResolution) {
+  const operator = requireGraphOperator(deps);
+  const config = await deps.loadConfig(configPath, configResolution);
+  const enabled = config.graph?.worktrees?.enabled ?? false;
+  if (!enabled) {
     return {
       exitCode: 0,
-      stdout: `openteam loop: nothing to do (${preStop.reason}).`
+      stdout: renderWorktreeReconciliation(planWorktreeReconciliation({ enabled: false, worktrees: [] }))
     };
   }
-  const ralphAgent = guaranteedAgentName(RALPH_ROLE_ID);
-  if (!await runtime.agentFileExists(ralphAgent)) {
-    return { exitCode: 1, stdout: missingAgentFileMessage(ralphAgent) };
+  const policy = await resolveOperatorGraphPolicy(config, operator);
+  const blocked = checkOperatorGate(policy);
+  if (blocked !== undefined) {
+    return blocked;
   }
-  await runtime.loadOrGenerateRoster();
-  const result = await runtime.run({
-    prompt: backlogPrompt(flags.freshContext, items),
-    maxIterations: Math.max(1, plannedIterations),
-    config,
-    freshContext: flags.freshContext
+  const observations = await operator.worktrees.listObservations(config);
+  const report = planWorktreeReconciliation({
+    enabled,
+    worktrees: observations
   });
-  let updated = backlogText;
-  const completed = Math.min(result.iterations, unchecked.length);
-  for (let n = 0;n < completed; n += 1) {
-    const item = unchecked[n];
-    if (item !== undefined) {
-      updated = markBacklogLineDone(updated, item.line);
-    }
+  if (report.plans.length === 0) {
+    return { exitCode: 0, stdout: renderWorktreeReconciliation(report) };
   }
-  if (updated !== backlogText) {
-    await runtime.writeBacklog(flags.backlogPath, updated);
+  for (const plan2 of report.plans) {
+    if (!plan2.safe || plan2.action === "retain" || plan2.action === "block") {
+      continue;
+    }
+    await operator.worktrees.apply(plan2.action, plan2.runID);
   }
   return {
-    exitCode: 0,
-    stdout: `openteam loop: ${result.iterations} iteration(s), terminated on ${result.termination}; marked ${completed} backlog item(s) done.`
+    exitCode: report.blocked > 0 ? 1 : 0,
+    stdout: renderWorktreeReconciliation(report)
   };
 }
 async function runCli(argv, deps) {
@@ -14537,12 +12919,6 @@ async function runCli(argv, deps) {
     if (command === "graph") {
       return await runGraph(parsed.positionals, deps, configPath, configResolution);
     }
-    if (command === "loop") {
-      if (parsed.positionals.includes("--help") || parsed.positionals.includes("-h")) {
-        return { exitCode: 0, stdout: LOOP_HELP };
-      }
-      return await runLoop(argv, deps, configPath, configResolution);
-    }
     if (command === "console") {
       const config = await deps.loadConfig(configPath, configResolution);
       return { exitCode: 0, stdout: renderConsoleStatus(config.console) };
@@ -14620,6 +12996,167 @@ ${HELP}`
   }
 }
 
+// src/orchestrator/roster.ts
+import { z as z19 } from "zod";
+var RosterEntrySchema = z19.object({
+  roleID: z19.string().min(1),
+  agentName: z19.string().min(1)
+}).strict();
+var RosterSchema = z19.object({
+  universe: z19.string().min(1),
+  entries: z19.array(RosterEntrySchema)
+}).strict();
+var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
+
+class RosterParseError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RosterParseError";
+    this.code = code;
+  }
+}
+function parseRoster(text2) {
+  const result = parseRosterResult(text2);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.roster;
+}
+function parseRosterResult(text2) {
+  const match = ROSTER_JSON_FENCE.exec(text2);
+  if (match === null || match[1] === undefined) {
+    return {
+      ok: false,
+      error: new RosterParseError("missing-json-block", "openteam roster: no JSON block found in roster file")
+    };
+  }
+  let data;
+  try {
+    data = JSON.parse(match[1]);
+  } catch (error) {
+    return {
+      ok: false,
+      error: new RosterParseError("malformed-json", `openteam roster: malformed JSON in roster file: ${String(error)}`)
+    };
+  }
+  const parsed = RosterSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: new RosterParseError("invalid-roster-schema", `openteam roster: invalid roster schema: ${parsed.error.message}`)
+    };
+  }
+  return { ok: true, roster: parsed.data };
+}
+var GUARANTEED_ROLE_IDS = [
+  "orchestrator",
+  "guardian",
+  "scribe",
+  "ralph"
+];
+function isGuaranteedRoleID(roleID) {
+  return GUARANTEED_ROLE_IDS.includes(roleID);
+}
+function missingGuaranteedRoles(roster) {
+  const present = new Set(roster.entries.map((entry) => entry.roleID));
+  return GUARANTEED_ROLE_IDS.filter((roleID) => !present.has(roleID));
+}
+function isRoleProfileLike(value) {
+  return typeof value === "object" && value !== null && "roleID" in value && "defaultTier" in value;
+}
+function configuredRolesFromAuditInput(input) {
+  if ("configuredRoles" in input && !isRoleProfileLike(input.configuredRoles)) {
+    return input.configuredRoles;
+  }
+  return input;
+}
+function auditRoster(rosterOrText, configuredRolesOrOptions = {}) {
+  const configuredRoles = configuredRolesFromAuditInput(configuredRolesOrOptions);
+  if (typeof rosterOrText === "string") {
+    const parsed = parseRosterResult(rosterOrText);
+    if (!parsed.ok) {
+      return {
+        findings: [
+          {
+            kind: "unparseable-roster",
+            roleID: "roster",
+            code: parsed.error.code,
+            message: parsed.error.message
+          }
+        ],
+        hasAllGuaranteedRoles: false,
+        missingGuaranteedRoleIDs: [],
+        unprofiledRoleEntries: [],
+        misassignedGuaranteedRoleEntries: []
+      };
+    }
+    return auditParsedRoster(parsed.roster, configuredRoles);
+  }
+  return auditParsedRoster(rosterOrText, configuredRoles);
+}
+function auditParsedRoster(roster, configuredRoles) {
+  const missingGuaranteedRoleIDs = missingGuaranteedRoles(roster);
+  const missing = new Set(missingGuaranteedRoleIDs);
+  const findings = missingGuaranteedRoleIDs.map((roleID) => ({
+    kind: "missing-guaranteed-role",
+    roleID
+  }));
+  const unprofiledRoleEntries = [];
+  const misassignedGuaranteedRoleEntries = [];
+  roster.entries.forEach((entry) => {
+    const profile = getRoleProfile(entry.roleID, configuredRoles);
+    if (profile === undefined && !isKnownNonWorkerRole(entry.roleID)) {
+      unprofiledRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        severity: "info"
+      });
+      findings.push({
+        kind: "unresolved-role-profile",
+        roleID: entry.roleID,
+        agentName: entry.agentName
+      });
+    }
+    if (isGuaranteedRoleID(entry.agentName) && entry.roleID !== entry.agentName && missing.has(entry.agentName)) {
+      misassignedGuaranteedRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        missingRoleID: entry.agentName,
+        reason: "agentNameMatchesMissingGuaranteedRole"
+      });
+      findings.push({
+        kind: "non-canonical-role-id",
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        canonicalRoleID: entry.agentName
+      });
+      return;
+    }
+    if (profile !== undefined && isGuaranteedRoleID(profile.roleID) && profile.roleID !== entry.roleID && missing.has(profile.roleID)) {
+      misassignedGuaranteedRoleEntries.push({
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        missingRoleID: profile.roleID,
+        reason: "roleIDResolvesToMissingGuaranteedRole"
+      });
+      findings.push({
+        kind: "non-canonical-role-id",
+        roleID: entry.roleID,
+        agentName: entry.agentName,
+        canonicalRoleID: profile.roleID
+      });
+    }
+  });
+  return {
+    findings,
+    hasAllGuaranteedRoles: missingGuaranteedRoleIDs.length === 0,
+    missingGuaranteedRoleIDs,
+    unprofiledRoleEntries,
+    misassignedGuaranteedRoleEntries
+  };
+}
+
 // src/commands/rolesInit.ts
 var ROLES_INIT_LOCAL_ONLY = "local-only";
 var ROLES_INIT_FRONTIER_OK = "frontier-ok";
@@ -14957,9 +13494,6 @@ function planStartupHygieneMigration(exists) {
 // src/index.ts
 import { readFile as readFile2 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname5 } from "node:path";
-import {
-  tool as tool2
-} from "@opencode-ai/plugin";
 
 // src/graph/certificate.ts
 import { z as z20 } from "zod";
@@ -15679,58 +14213,6 @@ var realCacheAdapter = {
   isReparsePath
 };
 
-// src/orchestrator/rosterPersistence.ts
-function rosterFence(roster) {
-  const data = { universe: roster.universe, entries: roster.entries };
-  return `\`\`\`json
-${JSON.stringify(data, null, 2)}
-\`\`\``;
-}
-function serializeRoster(roster) {
-  return `# openteam roster
-
-Universe: ${roster.universe}
-
-${rosterFence(roster)}
-`;
-}
-async function persistRoster(storage, roster, path4 = OPENTEAM_ROSTER_PATH) {
-  await storage.write(path4, serializeRoster(roster));
-  return path4;
-}
-async function loadRosterFile(storage, path4 = OPENTEAM_ROSTER_PATH) {
-  const content = await storage.read(path4);
-  if (content === undefined) {
-    return { status: "absent", path: path4 };
-  }
-  const parsed = parseRosterResult(content);
-  if (!parsed.ok) {
-    return { status: "invalid", path: path4, error: parsed.error };
-  }
-  return {
-    status: "loaded",
-    path: path4,
-    roster: enforceGuaranteedRoles(parsed.roster)
-  };
-}
-async function loadOrGenerateRoster(storage, generate, path4 = OPENTEAM_ROSTER_PATH) {
-  const existing = await loadRosterFile(storage, path4);
-  if (existing.status === "loaded") {
-    return { roster: existing.roster, regenerated: false };
-  }
-  const roster = enforceGuaranteedRoles(await generate());
-  if (existing.status === "absent") {
-    await persistRoster(storage, roster, path4);
-    return { roster, regenerated: true };
-  }
-  return {
-    roster,
-    regenerated: true,
-    recoveredFromInvalidPersisted: true,
-    invalidPersistedRosterError: existing.error.message
-  };
-}
-
 // src/memory/types.ts
 import { z as z21 } from "zod";
 var SHARED_OWNER_KEY = "*";
@@ -16342,51 +14824,6 @@ async function recallMemory(deps, queryText, query) {
   return recall(recordRead.records, queryEmbedding, query, recallDeps);
 }
 
-// src/plugin/orchestrateTool.ts
-import { tool } from "@opencode-ai/plugin";
-import { z as z22 } from "zod";
-var _pluginWarnedRoles = new Set;
-var EMPTY_ROLE_ID_SET = new Set;
-var RoleAssignmentSchema = z22.object({
-  roleID: z22.string().min(1).describe("Role identifier from the roster"),
-  prompt: z22.string().min(1).describe("Work prompt for this role"),
-  title: z22.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z22.array(z22.string().min(1)).optional().describe("Role IDs this assignment depends on (DAG edges)")
-}).strict();
-var OrchestratePayloadSchema = z22.object({
-  assignments: z22.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z22.string().min(1).optional().describe("Parent session for subsessions"),
-  directory: z22.string().min(1).optional().describe("Working directory override")
-}).strict();
-function adaptSdkClient(sdk) {
-  return {
-    session: {
-      create: async (args) => {
-        const result = await sdk.session.create(args);
-        const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
-        if (result.error !== undefined) {
-          out.error = result.error;
-        }
-        return out;
-      },
-      prompt: async (args) => {
-        const result = await sdk.session.prompt(args);
-        const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
-        if (result.error !== undefined) {
-          out.error = result.error;
-        }
-        return out;
-      }
-    }
-  };
-}
-
 // src/local/embeddings.ts
 function parseEmbeddingsResponse(payload) {
   if (typeof payload !== "object" || payload === null || !Array.isArray(payload.data)) {
@@ -16550,7 +14987,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.17.5",
+  version: "0.18.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",
@@ -16898,11 +15335,11 @@ function applyLimit(list, limit) {
   return list.slice(0, limit);
 }
 function queryDecisions(memory, query = {}) {
-  const filtered = memory.decisions.filter((decision2) => {
-    if (query.agent !== undefined && decision2.agent !== query.agent) {
+  const filtered = memory.decisions.filter((decision) => {
+    if (query.agent !== undefined && decision.agent !== query.agent) {
       return false;
     }
-    if (query.tag !== undefined && !(decision2.tags ?? []).includes(query.tag)) {
+    if (query.tag !== undefined && !(decision.tags ?? []).includes(query.tag)) {
       return false;
     }
     return true;
@@ -17568,7 +16005,6 @@ var deps = {
   agentDir: AGENT_DIR2,
   cachePort: realCacheAdapter,
   purge: createCliPurgeRuntime(),
-  loopRuntime: createCliLoopRuntime(),
   loadRosterForDoctor: readStoredRosterForDoctor,
   auditRoster: auditStoredRosterForDoctor,
   readGitignore: () => storage.read(OPENCODE_GITIGNORE_PATH),
@@ -17586,71 +16022,6 @@ function createCliPurgeRuntime() {
     sessionsDir: DEFAULT_SESSIONS_DIR
   };
 }
-var fallbackRosterSource = () => ({
-  universe: "openteam",
-  entries: Object.entries(TEAM_ROLES).filter(([, profile]) => profile.opencodeAgent !== undefined).map(([roleID, profile]) => ({
-    roleID,
-    agentName: profile.opencodeAgent
-  }))
-});
-function ralphResultIsDone(result) {
-  const response2 = result.subsession.response;
-  if (typeof response2 === "string") {
-    return /\bDONE\b/i.test(response2);
-  }
-  if (response2 !== null && typeof response2 === "object") {
-    const done = response2.done;
-    if (typeof done === "boolean") {
-      return done;
-    }
-  }
-  return false;
-}
-async function runCliRalphLoop(input) {
-  const client = adaptSdkClient(createOpencodeClient());
-  const sink = createNullEventSink();
-  const registry = new RuntimeRegistry({
-    fetch: globalThis.fetch,
-    clock: () => new Date().toISOString(),
-    foundryDiscovery: foundryDiscoveryFromExec(nodeExec2)
-  });
-  const localRuntimeReachable = async () => {
-    const snapshots = await registry.probe(input.config.local.runtimes.filter((runtime) => runtime.enabled));
-    return anyRuntimeReachable(snapshots);
-  };
-  const task = {
-    promptChars: input.prompt.length,
-    hasCode: false
-  };
-  const result = await runRalphLoop({
-    task,
-    prompt: input.prompt,
-    config: input.config,
-    maxIterations: input.maxIterations
-  }, {
-    client,
-    sink,
-    now: () => Date.now(),
-    newDecisionID: () => crypto.randomUUID(),
-    localRuntimeReachable,
-    isDone: ralphResultIsDone
-  });
-  return { iterations: result.iterations, termination: result.termination };
-}
-function createCliLoopRuntime() {
-  const agentFileExists = (agentName) => storage.exists(`${AGENT_DIR2}/${agentName}.md`);
-  const generate = () => generateRoster("openteam initial roster", fallbackRosterSource);
-  return {
-    loadRosterFile: () => loadRosterFile(storage),
-    loadOrGenerateRoster: async () => (await loadOrGenerateRoster(storage, generate)).roster,
-    agentFileExists,
-    readBacklog: (path4) => storage.read(path4),
-    writeBacklog: async (path4, contents) => {
-      await storage.write(path4, contents);
-    },
-    run: (loopInput) => runCliRalphLoop(loopInput)
-  };
-}
 function createSetupDeps() {
   return {
     detect: createDetect(nodeExec2),