@jmanuelcorral/openteam 0.2.0 → 0.2.1

package/dist/index.js

@@ -692,6 +692,9 @@ function scanReferenceOnly(surfaces) {
   return { surfacesScanned: surfaces.length, rawFindings };
 }
 
+// src/contract/opencode.ts
+var SUPPORTED_OPENCODE_VERSIONS = ["1.17.13", "1.18.18"];
+
 // src/graph/soakLedger.ts
 import { z as z2 } from "zod";
 var Sha256Schema = z2.string().regex(/^[0-9a-f]{64}$/);
@@ -1138,14 +1141,14 @@ var SoakPolicySchema = z3.object({
   minimumGenuineObservations: z3.number().int().positive(),
   minimumDistinctDays: z3.number().int().positive(),
   requireGenuineUsageOnAllPlatforms: z3.boolean(),
-  supportedOpencodeVersion: z3.string().min(1),
+  supportedOpencodeVersions: z3.array(z3.string().min(1)).min(1),
   criticalDivergenceCodes: z3.array(RecomputedDivergenceCodeSchema).min(1)
 }).strict();
 var DEFAULT_SOAK_POLICY = {
   minimumGenuineObservations: 100,
   minimumDistinctDays: 14,
   requireGenuineUsageOnAllPlatforms: true,
-  supportedOpencodeVersion: "1.17.13",
+  supportedOpencodeVersions: [...SUPPORTED_OPENCODE_VERSIONS],
   criticalDivergenceCodes: ["fixes"]
 };
 var SoakPlatformEnumSchema = z3.enum(["linux", "win32", "darwin"]);
@@ -1167,6 +1170,7 @@ var SoakEvidenceSchema = z3.object({
   genuineUsageObservations: z3.number().int().nonnegative(),
   ciSyntheticObservations: z3.number().int().nonnegative(),
   recorderCount: z3.number().int().nonnegative(),
+  ineligibleObservations: z3.number().int().nonnegative(),
   firstTimestamp: z3.string().datetime().nullable(),
   lastTimestamp: z3.string().datetime().nullable(),
   distinctDays: z3.number().int().nonnegative(),
@@ -1247,7 +1251,8 @@ function evaluateSoakGates(evidence, policy) {
       failed.push("os-diversity");
     }
   }
-  if (!evidence.opencodeVersionsObserved.includes(policy.supportedOpencodeVersion)) {
+  const supported = new Set(policy.supportedOpencodeVersions);
+  if (evidence.opencodeVersionsObserved.length === 0 || !evidence.opencodeVersionsObserved.every((v) => supported.has(v))) {
     failed.push("opencode-pin");
   }
   return failed;
@@ -1263,7 +1268,7 @@ function canonicalSoakCertificate(certificate) {
       minimumGenuineObservations: pol.minimumGenuineObservations,
       minimumDistinctDays: pol.minimumDistinctDays,
       requireGenuineUsageOnAllPlatforms: pol.requireGenuineUsageOnAllPlatforms,
-      supportedOpencodeVersion: pol.supportedOpencodeVersion,
+      supportedOpencodeVersions: [...pol.supportedOpencodeVersions].sort(),
       criticalDivergenceCodes: [...pol.criticalDivergenceCodes].sort()
     },
     verdict: certificate.verdict,
@@ -1274,6 +1279,7 @@ function canonicalSoakCertificate(certificate) {
       genuineUsageObservations: ev.genuineUsageObservations,
       ciSyntheticObservations: ev.ciSyntheticObservations,
       recorderCount: ev.recorderCount,
+      ineligibleObservations: ev.ineligibleObservations,
       firstTimestamp: ev.firstTimestamp,
       lastTimestamp: ev.lastTimestamp,
       distinctDays: ev.distinctDays,
@@ -1292,7 +1298,9 @@ function sameSoakGates(a, b) {
   return a.length === b.length && a.every((gate, index) => gate === b[index]);
 }
 function sameSoakPolicy(a, b) {
-  return a.minimumGenuineObservations === b.minimumGenuineObservations && a.minimumDistinctDays === b.minimumDistinctDays && a.requireGenuineUsageOnAllPlatforms === b.requireGenuineUsageOnAllPlatforms && a.supportedOpencodeVersion === b.supportedOpencodeVersion && a.criticalDivergenceCodes.length === b.criticalDivergenceCodes.length && [...a.criticalDivergenceCodes].sort().every((code, i) => code === [...b.criticalDivergenceCodes].sort()[i]);
+  const aVersions = [...a.supportedOpencodeVersions].sort();
+  const bVersions = [...b.supportedOpencodeVersions].sort();
+  return a.minimumGenuineObservations === b.minimumGenuineObservations && a.minimumDistinctDays === b.minimumDistinctDays && a.requireGenuineUsageOnAllPlatforms === b.requireGenuineUsageOnAllPlatforms && aVersions.length === bVersions.length && aVersions.every((v, i) => v === bVersions[i]) && a.criticalDivergenceCodes.length === b.criticalDivergenceCodes.length && [...a.criticalDivergenceCodes].sort().every((code, i) => code === [...b.criticalDivergenceCodes].sort()[i]);
 }
 function parseSoakCertificate(value, expectedPolicy, expectedLedgerDigest) {
   const parsed = SoakCertificateSchema.safeParse(value);
@@ -2959,1578 +2967,1578 @@ function validateGraphSpec(spec) {
   assertConnected(spec.nodes);
 }
 
-// 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;
+// src/orchestrator/graphIngress.ts
+var ACTIVE_INGRESS_BRAND = Symbol("openteam.activeIngress");
+function gateReason(policy) {
+  if (policy.capability === undefined) {
+    return "gate-closed";
   }
-  if (override === "alwaysLocal") {
-    return -20;
+  if (policy.graph.killSwitch) {
+    return "kill-switch";
   }
-  return 0;
+  return policy.graph.configuredMode === "active" ? undefined : "graph-disabled";
 }
-function tierFromScore(score) {
-  if (score <= 15) {
-    return "trivial";
+function decideIngress(policy, taskID) {
+  const blocked = gateReason(policy);
+  if (blocked !== undefined) {
+    return { route: "legacy", reason: blocked };
   }
-  if (score <= 35) {
-    return "simple";
+  if (!policy.allowList.includes(taskID)) {
+    return { route: "legacy", reason: "not-allow-listed" };
   }
-  if (score <= 65) {
-    return "moderate";
+  return { route: "graph", taskID };
+}
+
+// src/plugin/legacyRunProducer.ts
+function toObservedNode(node) {
+  return {
+    id: node.id,
+    role: node.role,
+    model: node.model,
+    ok: node.ok,
+    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
+    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
+  };
+}
+function buildObservedRun(payload) {
+  return {
+    runID: payload.runID,
+    executed: true,
+    status: payload.status,
+    fixes: payload.fixes,
+    nodes: payload.nodes.map(toObservedNode),
+    ...payload.parentSessionRef !== undefined ? { parentSessionRef: payload.parentSessionRef } : {}
+  };
+}
+function crossVerify(payload, tracker) {
+  const unverifiedModels = [];
+  const modelMismatches = [];
+  const unknownSessions = [];
+  for (const node of payload.nodes) {
+    if (node.sessionRef !== undefined) {
+      const mv = tracker.verifyModel(node.sessionRef, node.model);
+      if (!mv.verified) {
+        unverifiedModels.push(node.id);
+      } else if (!mv.match) {
+        modelMismatches.push(node.id);
+      }
+      const sv = tracker.verifySessionRef(node.sessionRef);
+      if (sv.known === false) {
+        unknownSessions.push(node.id);
+      }
+    } else {
+      unverifiedModels.push(node.id);
+    }
   }
-  return "hard";
+  return { unverifiedModels, modelMismatches, unknownSessions };
 }
-function confidenceFromScore(score) {
-  if (score >= 75 || score <= 10) {
-    return 0.9;
+function formatWarnings(verification) {
+  const warnings = [];
+  if (verification.unverifiedModels.length > 0) {
+    warnings.push(`model not verifiable for nodes: ${verification.unverifiedModels.join(", ")}`);
   }
-  if (score >= 30 && score <= 70) {
-    return 0.58;
+  if (verification.modelMismatches.length > 0) {
+    warnings.push(`model mismatch for nodes: ${verification.modelMismatches.join(", ")}`);
   }
-  return 0.72;
-}
-function addScore(condition, amount, reason, state) {
-  if (condition) {
-    state.score += amount;
-    state.reasons.push(reason);
+  if (verification.unknownSessions.length > 0) {
+    warnings.push(`unknown sessionRef for nodes: ${verification.unknownSessions.join(", ")}`);
   }
+  return warnings;
 }
-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
-  };
+function formatResponse(response) {
+  const parts = [`report-run: ${response.result}`];
+  if (response.detail !== undefined) {
+    parts.push(response.detail);
+  }
+  if (response.warnings !== undefined && response.warnings.length > 0) {
+    parts.push(`warnings: ${response.warnings.join("; ")}`);
+  }
+  return parts.join(" — ");
 }
 
-// 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;
+// src/plugin/reportRunSchema.ts
+import { z as z9 } from "zod";
+
+// src/plugin/graphShadowIngress.ts
+import { z as z8 } from "zod";
+var LEGACY_EXECUTION_TRACE_VERSION = 1;
+var LegacyExecutionStatusSchema = z8.enum([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var LegacyReviewOutcomeSchema = z8.enum([
+  "approved",
+  "rejected",
+  "inconclusive"
+]);
+var LegacyTraceNodeV1Schema = z8.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  model: z8.string().min(1),
+  sessionRef: z8.string().min(1).optional(),
+  errorClass: ErrorClassSchema.optional()
+}).strict();
+var LegacyExecutionTraceV1Schema = z8.object({
+  version: z8.literal(LEGACY_EXECUTION_TRACE_VERSION),
+  runID: NodeIDSchema,
+  status: LegacyExecutionStatusSchema,
+  outcome: LegacyReviewOutcomeSchema,
+  fixes: z8.number().int().nonnegative(),
+  nodes: z8.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z8.string().min(1).optional()
+}).strict();
+function gateReason2(gate) {
+  if (gate === undefined || gate.mode === "off") {
+    return "graph-disabled";
+  }
+  if (gate.killSwitch) {
+    return "kill-switch";
+  }
+  return;
 }
-function budgetNearLimit(projected, limit) {
-  return limit !== undefined && projected >= limit * WARNING_UTILIZATION && projected < limit;
+function deriveOutcome(nodes) {
+  for (let index = nodes.length - 1;index >= 0; index -= 1) {
+    const node = nodes[index];
+    if (node !== undefined && node.role === "reviewer") {
+      return node.ok ? "approved" : "rejected";
+    }
+  }
+  return "inconclusive";
 }
-function exhaustedDecision(budgets, reason) {
+function toTraceNode(node) {
   return {
-    action: budgets.hardStopOnBudgetExhaustion ? "blockFrontier" : "forceLocal",
-    reason
+    id: node.id,
+    role: node.role,
+    model: node.model,
+    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
+    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
   };
 }
-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");
+function ingestLegacyExecution(observation, gate) {
+  const gated = gateReason2(gate);
+  if (gated !== undefined) {
+    return { eligible: false, reason: gated };
   }
-  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
-    return { action: "warn", reason: "session-budget-near-limit" };
+  if (!observation.executed) {
+    return { eligible: false, reason: "not-executed" };
   }
-  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
-    return { action: "warn", reason: "monthly-budget-near-limit" };
+  if (observation.nodes.length === 0) {
+    return { eligible: false, reason: "no-observation" };
   }
-  return { action: "ok" };
+  const trace = {
+    version: LEGACY_EXECUTION_TRACE_VERSION,
+    runID: observation.runID,
+    status: observation.status,
+    outcome: deriveOutcome(observation.nodes),
+    fixes: Math.max(0, Math.trunc(observation.fixes)),
+    nodes: observation.nodes.map(toTraceNode),
+    ...observation.parentSessionRef !== undefined ? { parentSessionRef: observation.parentSessionRef } : {}
+  };
+  assertReferenceOnly(trace);
+  return { eligible: true, trace };
 }
 
-// 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));
+class LegacyTraceError extends Error {
+  code = "invalid-legacy-trace";
+  issues;
+  constructor(error) {
+    super(`invalid-legacy-trace: ${error.issues.map((issue) => issue.message).join("; ")}`);
+    this.name = "LegacyTraceError";
+    this.issues = error.issues.map((issue) => issue.message);
+  }
 }
-function uniqueModelSelections(models) {
-  const byKey = new Map;
-  for (const model of models) {
-    byKey.set(modelKey2(model), model);
+function parseLegacyExecutionTrace(input) {
+  const result = LegacyExecutionTraceV1Schema.safeParse(input);
+  if (!result.success) {
+    throw new LegacyTraceError(result.error);
   }
-  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 compareAvailableModels2(left, right) {
-  return compareModels(left, right);
-}
-function defaultAvailableModels2(config) {
-  return [
-    {
-      ...localDefault(config),
-      kind: "local",
-      available: true
-    },
-    {
-      ...resolveConfiguredFrontierBaseline(config),
-      kind: "frontier",
-      available: true
-    }
-  ].sort(compareAvailableModels2);
-}
-function availableModels(input) {
-  return (input.availableModels ?? defaultAvailableModels2(input.config)).slice().sort(compareAvailableModels2);
-}
-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
-  })));
+  return result.data;
 }
 
-// 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;
+// src/plugin/reportRunSchema.ts
+var ReportRunNodeSchema = z9.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  model: z9.string().min(1),
+  ok: z9.boolean(),
+  sessionRef: z9.string().min(1).optional(),
+  errorClass: ErrorClassSchema.optional()
+}).strict();
+var ReportRunPayloadSchema = z9.object({
+  runID: NodeIDSchema,
+  status: LegacyExecutionStatusSchema,
+  fixes: z9.number().int().nonnegative(),
+  nodes: z9.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z9.string().min(1).optional()
+}).strict();
+
+// src/graph/types.ts
+var TERMINAL_NODE_STATUSES = new Set([
+  "succeeded",
+  "cancelled"
+]);
+var TERMINAL_RUN_STATUSES = new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+
+// src/graph/reducer.ts
+class ReducerError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ReducerError";
+    this.code = code;
+    this.detail = detail;
   }
-  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;
+function initialState(spec) {
+  const nodes = {};
+  for (const node of spec.nodes) {
+    nodes[node.id] = { status: "pending", attempts: 0 };
+  }
+  return { runID: spec.runID, status: "running", seq: -1, nodes };
 }
-
-// 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;
+function withNode(state, nodeID, next) {
   return {
-    minReasoningTier: base.reasoning,
-    minCodeQualityTier: Math.min(5, base.code + codeBump),
-    minContextWindow,
-    needsTools: task.requiresTools === true,
-    needsVision: task.requiresVision === true
+    ...state,
+    nodes: { ...state.nodes, [nodeID]: next },
+    seq: state.seq
   };
 }
-function blendedCostPer1M(profile) {
-  return profile.costPer1M.inputUSD * BLENDED_COST_INPUT_WEIGHT + profile.costPer1M.outputUSD * BLENDED_COST_OUTPUT_WEIGHT;
-}
-function modelKey3(profile) {
-  return `${profile.ref.providerID}/${profile.ref.modelID}`;
+function specNode(spec, nodeID) {
+  return spec.nodes.find((node) => node.id === nodeID);
 }
-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;
+function applyRunStarted(state, seq, specDigest) {
+  if (state.specDigest !== undefined) {
+    if (state.specDigest === specDigest) {
+      return state;
+    }
+    throw new ReducerError("run-started-conflict", specDigest);
   }
-  return modelKey3(left).localeCompare(modelKey3(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;
+  return { ...state, specDigest, seq };
 }
-
-// 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: [] };
+function applyDispatched(spec, state, event) {
+  const node = specNode(spec, event.nodeID);
+  const current = state.nodes[event.nodeID];
+  if (node === undefined || current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
   }
-  if (input.profiles !== undefined) {
-    const selected = selectCheapestCapableFrontier(deriveRequirement(tier, input.task), input.profiles);
-    if (selected !== null) {
-      return {
-        model: selected,
-        rationale: ["auto-cheapest-capable-frontier"]
-      };
+  for (const dep of node.dependsOn) {
+    if (state.nodes[dep]?.status !== "succeeded") {
+      throw new ReducerError("dependency-not-satisfied", `${event.nodeID} <- ${dep}`);
     }
-    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
+  const running = {
+    status: "running",
+    attempts: current.attempts + 1,
+    operationID: event.operationID,
+    attemptID: event.attemptID
   };
-}
-function buildFallbackChain(input, selected, frontier, allowFrontier) {
-  const chain = availableLocalFallbacks(input, selected);
-  if (allowFrontier && !sameModel(frontier, selected) && frontierAvailable(input, frontier)) {
-    chain.push(frontier);
+  if (current.status === "pending") {
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
   }
-  return chain;
-}
-function inferRouteKind(config, selected, listed) {
-  if (listed !== undefined) {
-    return listed.kind;
+  if (current.status === "failed") {
+    if (current.operationID !== event.operationID) {
+      throw new ReducerError("dispatch-conflict", event.nodeID);
+    }
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
   }
-  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
-  };
+  if (current.status === "running") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("dispatch-conflict", event.nodeID);
+  }
+  throw new ReducerError("illegal-transition", `dispatch ${current.status}`);
 }
-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));
+function applySucceeded(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
   }
-  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 (current.status === "succeeded") {
+    if (current.operationID === event.operationID && current.artifactSha256 === event.artifact.sha256) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
   }
-  if (!options.allowFrontier) {
-    return decision(primary, "local", [...options.baseRationale, fallbackReason, options.noLocalRationale], []);
+  if (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `succeed ${current.status}`);
   }
-  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));
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
   }
-  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;
-  return {
-    ...core,
-    tier,
-    rationale: [...frontier.rationale, ...core.rationale],
-    estimatedCostUSD: roundUSD(selectedCostUSD),
-    baselineCostUSD: roundUSD(baselineCostUSD),
-    estimatedSavingsUSD: roundUSD(savingsUSD),
-    budgetAction
-  };
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "succeeded",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID,
+    artifactSha256: event.artifact.sha256
+  });
 }
-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") {
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["privacy-force-local"],
-      allowFrontier: false,
-      noLocalRationale: "privacy-force-local-unavailable"
-    }));
+function applyFailed(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
   }
-  if (budgetAction.action === "forceLocal" || budgetAction.action === "blockFrontier") {
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: [`budget-${budgetAction.action}`],
-      allowFrontier: false,
-      noLocalRationale: "budget-local-unavailable"
-    }));
+  if (current.status === "failed") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
   }
-  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 (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `fail ${current.status}`);
   }
-  if (override === "alwaysLocal") {
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["explicit-always-local"],
-      allowFrontier: false,
-      noLocalRationale: "forced-local-unavailable"
-    }));
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
   }
-  if (override === "alwaysFrontier") {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "failed",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID
+  });
+}
+function applyCancelled(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
   }
-  if (input.config.router.frontierOnly) {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["router-frontier-only"], []));
+  if (current.status === "cancelled") {
+    return state;
   }
-  const shortEnoughForLocal = input.task.promptChars <= input.config.router.trivialPromptMaxChars;
-  const largeEnoughForFrontier = input.task.promptChars >= input.config.router.frontierPromptMinChars;
-  if (!input.task.hasCode && shortEnoughForLocal && !largeEnoughForFrontier) {
-    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
-      baseRationale: ["trivial-short-no-code"],
-      allowFrontier: true,
-      noLocalRationale: "forced-local-unavailable"
-    }));
+  if (current.status === "succeeded") {
+    throw new ReducerError("illegal-transition", "cancel succeeded");
   }
-  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) {
-  return decision2.routeKind === "local" ? "local" : "frontier";
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    ...current,
+    status: "cancelled"
+  });
 }
-function budgetAction(decision2) {
-  const reason = decision2.budgetAction.reason;
-  return reason === undefined ? decision2.budgetAction.action : `${decision2.budgetAction.action}:${reason}`;
+function applyRunCompleted(state, seq) {
+  for (const node of Object.values(state.nodes)) {
+    if (node.status !== "succeeded" && node.status !== "cancelled") {
+      throw new ReducerError("incomplete-run", node.status);
+    }
+  }
+  return { ...state, status: "completed", seq };
 }
-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;
+function applyEvent(spec, state, event) {
+  if (event.runID !== state.runID) {
+    throw new ReducerError("run-mismatch", event.runID);
   }
-  if (context.tokensIn !== undefined) {
-    record.tokensIn = context.tokensIn;
+  if (TERMINAL_RUN_STATUSES.has(state.status)) {
+    if (event.type === "run.completed" && state.status === "completed" || event.type === "run.failed" && state.status === "failed" || event.type === "run.cancelled" && state.status === "cancelled") {
+      return state;
+    }
+    throw new ReducerError("post-terminal", event.type);
   }
-  if (context.tokensOut !== undefined) {
-    record.tokensOut = context.tokensOut;
+  switch (event.type) {
+    case "run.started":
+      return applyRunStarted(state, event.seq, event.specDigest);
+    case "node.dispatched":
+      return applyDispatched(spec, state, event);
+    case "node.succeeded":
+      return applySucceeded(state, event);
+    case "node.failed":
+      return applyFailed(state, event);
+    case "node.cancelled":
+      return applyCancelled(state, event);
+    case "run.completed":
+      return applyRunCompleted(state, event.seq);
+    case "run.failed":
+      return { ...state, status: "failed", seq: event.seq };
+    case "run.cancelled":
+      return { ...state, status: "cancelled", seq: event.seq };
   }
-  return record;
 }
 
-// src/telemetry/types.ts
-import { z as z8 } from "zod";
-var CostRecordSchema = z8.object({
-  ts: z8.number().finite(),
-  sessionID: z8.string().min(1).optional(),
-  promptHash: z8.string().min(1),
-  promptChars: z8.number().int().min(0),
-  tier: ComplexityTierSchema,
-  routeKind: z8.enum(["local", "frontier"]),
-  selected: ModelRefSchema,
-  rationale: z8.string(),
-  estimatedCostUSD: z8.number().finite().min(0),
-  baselineCostUSD: z8.number().finite().min(0),
-  estimatedSavingsUSD: z8.number().finite(),
-  budgetAction: z8.string().min(1),
-  tokensIn: z8.number().int().min(0).optional(),
-  tokensOut: z8.number().int().min(0).optional()
-});
-
-// src/telemetry/read.ts
-var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
-function parseCostRecordsJsonl(text) {
-  const records = [];
-  for (const line of text.split(`
-`)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    let candidate;
-    try {
-      candidate = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    const parsed = CostRecordSchema.safeParse(candidate);
-    if (parsed.success) {
-      records.push(parsed.data);
-    }
+// src/orchestrator/graphShadow.ts
+class ShadowMirrorError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ShadowMirrorError";
+    this.code = code;
+    this.detail = detail;
   }
-  return records;
 }
-
-// src/telemetry/eventLog.ts
-var DEFAULT_SESSIONS_DIR = ".opencode/openteam/sessions";
-var LEGACY_SESSION_ID = "legacy";
-function sessionFileName(sessionID) {
-  const safe = sessionID.replace(/[^A-Za-z0-9._-]/g, "_");
-  return `${safe}.jsonl`;
+function traceAnchorDigest(trace) {
+  return sha256Hex(JSON.stringify({
+    version: trace.version,
+    runID: trace.runID,
+    nodes: trace.nodes.map((node) => [node.id, node.role])
+  }));
 }
-function createEventLogSink(deps) {
-  return {
-    emit: async (event) => {
-      try {
-        const parsed = OpenTeamEventSchema.parse(event);
-        const path = joinVirtualPath(deps.dir, sessionFileName(parsed.sessionID));
-        await deps.storage.append(path, `${JSON.stringify(parsed)}
-`);
-      } catch (error) {
-        deps.onError?.(error);
-      }
+function compileShadowSpec(trace) {
+  const anchor = { taskID: trace.runID, specDigest: traceAnchorDigest(trace) };
+  const nodes = [];
+  let previousID;
+  let lastImplementerID;
+  for (const node of trace.nodes) {
+    const dependsOn = previousID === undefined ? [] : [previousID];
+    if (node.role === "implementer") {
+      nodes.push({ id: node.id, role: "implementer", dependsOn, anchor });
+      lastImplementerID = node.id;
+    } else {
+      nodes.push({
+        id: node.id,
+        role: "reviewer",
+        dependsOn,
+        anchor,
+        ...lastImplementerID === undefined ? {} : { reviews: lastImplementerID }
+      });
     }
-  };
-}
-function createNullEventSink() {
-  return { emit: () => {} };
-}
-function parseEventsJsonl(text) {
-  const events = [];
-  for (const line of text.split(`
-`)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
+    previousID = node.id;
+  }
+  let spec;
+  try {
+    spec = GraphSpecV1Schema.parse({ version: 1, runID: trace.runID, nodes });
+    validateGraphSpec(spec);
+  } catch (error) {
+    throw new ShadowMirrorError("invalid-spec", error instanceof Error ? error.message : String(error));
+  }
+  assertReferenceOnly(spec);
+  return spec;
+}
+var TERMINAL_EVENT = {
+  completed: "run.completed",
+  failed: "run.failed",
+  cancelled: "run.cancelled"
+};
+function shadowArtifact(runID, nodeID) {
+  return {
+    uri: `shadow://${runID}/${nodeID}`,
+    sha256: sha256Hex(`shadow-artifact\x00${runID}\x00${nodeID}`),
+    bytes: 0
+  };
+}
+function mirrorJournal(spec, trace) {
+  const runID = trace.runID;
+  const events = [
+    {
+      v: 1,
+      seq: 0,
+      runID,
+      type: "run.started",
+      specDigest: graphSpecDigest(spec)
     }
-    let candidate;
-    try {
-      candidate = JSON.parse(trimmed);
-    } catch {
+  ];
+  for (const node of trace.nodes) {
+    const operation = operationID(runID, node.id);
+    const attempt = attemptID(operation, 0);
+    events.push({
+      v: 1,
+      seq: events.length,
+      runID,
+      type: "node.dispatched",
+      nodeID: node.id,
+      operationID: operation,
+      attemptID: attempt
+    });
+    if (node.errorClass === undefined) {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.succeeded",
+        nodeID: node.id,
+        operationID: operation,
+        attemptID: attempt,
+        artifact: shadowArtifact(runID, node.id)
+      });
       continue;
     }
-    const parsed = OpenTeamEventSchema.safeParse(candidate);
-    if (parsed.success) {
-      events.push(parsed.data);
+    if (node.errorClass === "cancelled") {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.cancelled",
+        nodeID: node.id
+      });
+      continue;
     }
+    events.push({
+      v: 1,
+      seq: events.length,
+      runID,
+      type: "node.failed",
+      nodeID: node.id,
+      operationID: operation,
+      attemptID: attempt,
+      errorClass: node.errorClass
+    });
   }
+  events.push({
+    v: 1,
+    seq: events.length,
+    runID,
+    type: TERMINAL_EVENT[trace.status]
+  });
   return events;
 }
-function costRecordToRouteEvent(record) {
-  const event = {
-    v: EVENT_SCHEMA_VERSION,
-    type: "route",
-    ts: record.ts,
-    sessionID: record.sessionID ?? LEGACY_SESSION_ID,
-    promptHash: record.promptHash,
-    promptChars: record.promptChars,
-    tier: record.tier,
-    routeKind: record.routeKind,
-    selected: record.selected,
-    rationale: record.rationale,
-    estimatedCostUSD: record.estimatedCostUSD,
-    baselineCostUSD: record.baselineCostUSD,
-    estimatedSavingsUSD: record.estimatedSavingsUSD,
-    budgetAction: record.budgetAction
-  };
-  if (record.tokensIn !== undefined) {
-    event.tokensIn = record.tokensIn;
-  }
-  if (record.tokensOut !== undefined) {
-    event.tokensOut = record.tokensOut;
+function reduceMirror(spec, journal) {
+  let state = initialState(spec);
+  try {
+    for (const event of journal) {
+      state = applyEvent(spec, state, event);
+    }
+  } catch (error) {
+    throw new ShadowMirrorError("illegal-sequence", error instanceof ReducerError ? `${error.code}: ${error.detail}` : String(error));
   }
-  return event;
+  return state;
 }
-function routeEventToCostRecord(event) {
-  const record = {
-    ts: event.ts,
-    sessionID: event.sessionID,
-    promptHash: event.promptHash,
-    promptChars: event.promptChars,
-    tier: event.tier,
-    routeKind: event.routeKind,
-    selected: event.selected,
-    rationale: event.rationale,
-    estimatedCostUSD: event.estimatedCostUSD,
-    baselineCostUSD: event.baselineCostUSD,
-    estimatedSavingsUSD: event.estimatedSavingsUSD,
-    budgetAction: event.budgetAction
+function projectLegacySummary(trace) {
+  return {
+    runID: trace.runID,
+    status: trace.status,
+    outcome: trace.outcome,
+    fixes: trace.fixes,
+    nodes: trace.nodes.map((node) => ({
+      id: node.id,
+      role: node.role,
+      model: node.model
+    }))
   };
-  if (event.tokensIn !== undefined) {
-    record.tokensIn = event.tokensIn;
-  }
-  if (event.tokensOut !== undefined) {
-    record.tokensOut = event.tokensOut;
-  }
-  return record;
 }
-async function readRouteCostRecords(dir, deps) {
-  const events = await readSessionEvents(dir, deps);
-  const records = [];
-  for (const event of events) {
-    if (event.type === "route") {
-      records.push(routeEventToCostRecord(event));
-    }
-  }
-  return records;
+function projectShadowSummary(spec, trace) {
+  const implementers = spec.nodes.filter((node) => node.role === "implementer").length;
+  return {
+    runID: spec.runID,
+    status: trace.status,
+    outcome: trace.outcome,
+    fixes: implementers - 1,
+    nodes: spec.nodes.map((node, index) => ({
+      id: node.id,
+      role: node.role,
+      model: trace.nodes[index].model
+    }))
+  };
 }
-async function readSessionEvents(dir, deps) {
-  const files = (await deps.storage.list(dir)).filter((file) => file.endsWith(".jsonl"));
-  const perFile = await Promise.all(files.map(async (file) => {
-    const text = await deps.storage.read(joinVirtualPath(dir, file));
-    return text === undefined ? [] : parseEventsJsonl(text);
-  }));
-  const events = perFile.flat();
-  if (deps.legacyTelemetryPath !== undefined) {
-    const legacyText = await deps.storage.read(deps.legacyTelemetryPath);
-    if (legacyText !== undefined) {
-      for (const record of parseCostRecordsJsonl(legacyText)) {
-        events.push(costRecordToRouteEvent(record));
-      }
+function mirrorLegacyExecution(trace) {
+  const spec = compileShadowSpec(trace);
+  const journal = mirrorJournal(spec, trace);
+  const state = reduceMirror(spec, journal);
+  const summary = projectShadowSummary(spec, trace);
+  assertReferenceOnly(summary);
+  return {
+    spec,
+    specDigest: graphSpecDigest(spec),
+    journal,
+    state,
+    summary
+  };
+}
+
+// src/orchestrator/graphFacade.ts
+function mirrorLegacyTrace(trace) {
+  try {
+    return {
+      ok: true,
+      mirror: mirrorLegacyExecution(parseLegacyExecutionTrace(trace))
+    };
+  } catch (error) {
+    if (error instanceof ShadowMirrorError) {
+      return { ok: false, code: error.code, detail: error.detail };
+    }
+    if (error instanceof LegacyTraceError) {
+      return {
+        ok: false,
+        code: "invalid-trace",
+        detail: error.issues.join("; ")
+      };
     }
+    return {
+      ok: false,
+      code: "mirror-error",
+      detail: error instanceof Error ? error.message : String(error)
+    };
   }
-  return events.sort((a, b) => a.ts - b.ts);
 }
 
-// src/telemetry/hash.ts
-var FNV_OFFSET_BASIS = 2166136261;
-var FNV_PRIME = 16777619;
-function hashPrompt(prompt) {
-  let hash = FNV_OFFSET_BASIS;
-  for (let index = 0;index < prompt.length; index += 1) {
-    hash ^= prompt.charCodeAt(index);
-    hash = Math.imul(hash, FNV_PRIME);
+// src/orchestrator/shadowComparator.ts
+function sequenceEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
   }
-  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+  return a.every((value, index) => value === b[index]);
 }
-
-// src/orchestrator/graphIngress.ts
-var ACTIVE_INGRESS_BRAND = Symbol("openteam.activeIngress");
-function gateReason(policy) {
-  if (policy.capability === undefined) {
-    return "gate-closed";
+function compareShadowRun(legacy, shadow) {
+  if (legacy === undefined || shadow === undefined) {
+    return { verdict: "inconclusive", divergences: [] };
   }
-  if (policy.graph.killSwitch) {
-    return "kill-switch";
+  const divergences = [];
+  if (legacy.status !== shadow.status) {
+    divergences.push("status");
   }
-  return policy.graph.configuredMode === "active" ? undefined : "graph-disabled";
-}
-function decideIngress(policy, taskID) {
-  const blocked = gateReason(policy);
-  if (blocked !== undefined) {
-    return { route: "legacy", reason: blocked };
+  if (!sequenceEqual(legacy.nodes.map((node) => node.id), shadow.nodes.map((node) => node.id))) {
+    divergences.push("order");
   }
-  if (!policy.allowList.includes(taskID)) {
-    return { route: "legacy", reason: "not-allow-listed" };
+  if (!sequenceEqual(legacy.nodes.map((node) => node.role), shadow.nodes.map((node) => node.role))) {
+    divergences.push("roles");
+  }
+  if (!sequenceEqual(legacy.nodes.map((node) => node.model), shadow.nodes.map((node) => node.model))) {
+    divergences.push("models");
+  }
+  if (legacy.fixes !== shadow.fixes) {
+    divergences.push("fixes");
+  }
+  if (legacy.outcome !== shadow.outcome) {
+    divergences.push("outcome");
   }
-  return { route: "graph", taskID };
-}
-
-// src/plugin/legacyRunProducer.ts
-function toObservedNode(node) {
-  return {
-    id: node.id,
-    role: node.role,
-    model: node.model,
-    ok: node.ok,
-    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
-    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
-  };
-}
-function buildObservedRun(payload) {
   return {
-    runID: payload.runID,
-    executed: true,
-    status: payload.status,
-    fixes: payload.fixes,
-    nodes: payload.nodes.map(toObservedNode),
-    ...payload.parentSessionRef !== undefined ? { parentSessionRef: payload.parentSessionRef } : {}
+    verdict: divergences.length === 0 ? "match" : "divergent",
+    divergences
   };
 }
-function crossVerify(payload, tracker) {
-  const unverifiedModels = [];
-  const modelMismatches = [];
-  const unknownSessions = [];
-  for (const node of payload.nodes) {
-    if (node.sessionRef !== undefined) {
-      const mv = tracker.verifyModel(node.sessionRef, node.model);
-      if (!mv.verified) {
-        unverifiedModels.push(node.id);
-      } else if (!mv.match) {
-        modelMismatches.push(node.id);
-      }
-      const sv = tracker.verifySessionRef(node.sessionRef);
-      if (sv.known === false) {
-        unknownSessions.push(node.id);
-      }
-    } else {
-      unverifiedModels.push(node.id);
+
+// src/storage/graph/soakRecorder.ts
+async function ensureRecorderId(ports, basePath) {
+  const idPath = `${basePath}/soak-recorder-id`;
+  if (await ports.fs.exists(idPath)) {
+    const id = (await ports.fs.readFile(idPath)).trim();
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
+      return id;
     }
   }
-  return { unverifiedModels, modelMismatches, unknownSessions };
+  const newId = ports.id.randomUUID();
+  await ports.fs.writeFile(idPath, newId);
+  return newId;
 }
-function formatWarnings(verification) {
-  const warnings = [];
-  if (verification.unverifiedModels.length > 0) {
-    warnings.push(`model not verifiable for nodes: ${verification.unverifiedModels.join(", ")}`);
-  }
-  if (verification.modelMismatches.length > 0) {
-    warnings.push(`model mismatch for nodes: ${verification.modelMismatches.join(", ")}`);
+async function readAllChains(ports, evidenceDir) {
+  if (!await ports.fs.exists(evidenceDir)) {
+    return [];
   }
-  if (verification.unknownSessions.length > 0) {
-    warnings.push(`unknown sessionRef for nodes: ${verification.unknownSessions.join(", ")}`);
+  const files = await ports.fs.readDir(evidenceDir);
+  const chains = [];
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) {
+      continue;
+    }
+    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    const observations = [];
+    for (const line of lines) {
+      const parsed = SoakObservationSchema.safeParse(JSON.parse(line));
+      if (parsed.success) {
+        observations.push(parsed.data);
+      }
+    }
+    if (observations.length > 0) {
+      chains.push(observations);
+    }
   }
-  return warnings;
+  return chains;
 }
-function formatResponse(response) {
-  const parts = [`report-run: ${response.result}`];
-  if (response.detail !== undefined) {
-    parts.push(response.detail);
+function canonicalObservationPreimage2(obs) {
+  return JSON.stringify({
+    version: obs.version,
+    seq: obs.seq,
+    timestamp: obs.timestamp,
+    platform: obs.platform,
+    opencodeVersion: obs.opencodeVersion,
+    provenance: obs.provenance,
+    traceDigest: obs.traceDigest,
+    criticalDivergences: obs.criticalDivergences,
+    privacy: obs.privacy,
+    duplicateEffects: obs.duplicateEffects,
+    modelVerification: obs.modelVerification
+  });
+}
+async function appendObservation(ports, evidenceDir, recorderId, input) {
+  await ports.fs.mkdir(evidenceDir);
+  const chainPath = `${evidenceDir}/${recorderId}.jsonl`;
+  let seq = 0;
+  let prevChainDigest = "0".repeat(64);
+  if (await ports.fs.exists(chainPath)) {
+    const content = await ports.fs.readFile(chainPath);
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    if (lines.length > 0) {
+      const lastLine = lines[lines.length - 1];
+      let rawParsed;
+      try {
+        rawParsed = JSON.parse(lastLine);
+      } catch {
+        throw new Error("corrupt chain tail: invalid JSON");
+      }
+      const parsed = SoakObservationSchema.safeParse(rawParsed);
+      if (!parsed.success) {
+        const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+        throw new Error(`corrupt chain tail: ${detail}`);
+      }
+      seq = parsed.data.seq + 1;
+      prevChainDigest = parsed.data.chainDigest;
+    }
   }
-  if (response.warnings !== undefined && response.warnings.length > 0) {
-    parts.push(`warnings: ${response.warnings.join("; ")}`);
+  const timestamp = ports.clock.now();
+  const base = {
+    version: 1,
+    seq,
+    timestamp,
+    platform: input.platform,
+    opencodeVersion: input.opencodeVersion,
+    provenance: input.provenance,
+    traceDigest: input.traceDigest,
+    criticalDivergences: input.criticalDivergences,
+    privacy: input.privacy,
+    duplicateEffects: input.duplicateEffects,
+    modelVerification: input.modelVerification
+  };
+  const preimage = canonicalObservationPreimage2(base);
+  const chainDigest = sha256Hex(prevChainDigest + preimage);
+  const observation = { ...base, chainDigest };
+  assertReferenceOnly(observation);
+  const line = JSON.stringify(observation);
+  if (await ports.fs.exists(chainPath)) {
+    const existing = await ports.fs.readFile(chainPath);
+    await ports.fs.writeFile(chainPath, `${existing}
+${line}`);
+  } else {
+    await ports.fs.writeFile(chainPath, line);
   }
-  return parts.join(" — ");
+  return observation;
 }
 
-// src/plugin/reportRunSchema.ts
-import { z as z10 } from "zod";
-
-// src/plugin/graphShadowIngress.ts
-import { z as z9 } from "zod";
-var LEGACY_EXECUTION_TRACE_VERSION = 1;
-var LegacyExecutionStatusSchema = z9.enum([
-  "completed",
-  "failed",
-  "cancelled"
-]);
-var LegacyReviewOutcomeSchema = z9.enum([
-  "approved",
-  "rejected",
-  "inconclusive"
-]);
-var LegacyTraceNodeV1Schema = z9.object({
-  id: NodeIDSchema,
-  role: NodeRoleSchema,
-  model: z9.string().min(1),
-  sessionRef: z9.string().min(1).optional(),
-  errorClass: ErrorClassSchema.optional()
-}).strict();
-var LegacyExecutionTraceV1Schema = z9.object({
-  version: z9.literal(LEGACY_EXECUTION_TRACE_VERSION),
-  runID: NodeIDSchema,
-  status: LegacyExecutionStatusSchema,
-  outcome: LegacyReviewOutcomeSchema,
-  fixes: z9.number().int().nonnegative(),
-  nodes: z9.array(LegacyTraceNodeV1Schema).min(1),
-  parentSessionRef: z9.string().min(1).optional()
-}).strict();
-function gateReason2(gate) {
-  if (gate === undefined || gate.mode === "off") {
-    return "graph-disabled";
-  }
-  if (gate.killSwitch) {
-    return "kill-switch";
-  }
-  return;
+// src/plugin/soakObserver.ts
+function resolvePlatform(platform) {
+  if (platform === "win32")
+    return "win32";
+  if (platform === "darwin")
+    return "darwin";
+  if (platform === "linux")
+    return "linux";
+  return null;
 }
-function deriveOutcome(nodes) {
-  for (let index = nodes.length - 1;index >= 0; index -= 1) {
-    const node = nodes[index];
-    if (node !== undefined && node.role === "reviewer") {
-      return node.ok ? "approved" : "rejected";
-    }
-  }
-  return "inconclusive";
+function countCriticalDivergences(parity, criticalCodes) {
+  if (parity === undefined)
+    return null;
+  if (criticalCodes.length === 0)
+    return null;
+  const criticalSet = new Set(criticalCodes);
+  return parity.divergences.filter((code) => criticalSet.has(code)).length;
 }
-function toTraceNode(node) {
+function scanTracePrivacy(trace) {
+  const result = scanReferenceOnly([trace]);
   return {
-    id: node.id,
-    role: node.role,
-    model: node.model,
-    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
-    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
+    surfacesScanned: result.surfacesScanned,
+    rawFindings: result.rawFindings
   };
 }
-function ingestLegacyExecution(observation, gate) {
-  const gated = gateReason2(gate);
-  if (gated !== undefined) {
-    return { eligible: false, reason: gated };
-  }
-  if (!observation.executed) {
-    return { eligible: false, reason: "not-executed" };
-  }
-  if (observation.nodes.length === 0) {
-    return { eligible: false, reason: "no-observation" };
+function detectDuplicateEffects(trace) {
+  const nodes = trace.nodes;
+  if (nodes.length === 0)
+    return null;
+  const seen = new Set;
+  let duplicates = 0;
+  for (const node of nodes) {
+    if (seen.has(node.id)) {
+      duplicates++;
+    } else {
+      seen.add(node.id);
+    }
   }
-  const trace = {
-    version: LEGACY_EXECUTION_TRACE_VERSION,
-    runID: observation.runID,
-    status: observation.status,
-    outcome: deriveOutcome(observation.nodes),
-    fixes: Math.max(0, Math.trunc(observation.fixes)),
-    nodes: observation.nodes.map(toTraceNode),
-    ...observation.parentSessionRef !== undefined ? { parentSessionRef: observation.parentSessionRef } : {}
-  };
-  assertReferenceOnly(trace);
-  return { eligible: true, trace };
+  return { effectsExamined: nodes.length, duplicatesFound: duplicates };
 }
-
-class LegacyTraceError extends Error {
-  code = "invalid-legacy-trace";
-  issues;
-  constructor(error) {
-    super(`invalid-legacy-trace: ${error.issues.map((issue) => issue.message).join("; ")}`);
-    this.name = "LegacyTraceError";
-    this.issues = error.issues.map((issue) => issue.message);
-  }
+function traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
+  const platform = resolvePlatform(platformOverride ?? process.platform);
+  if (platform === null)
+    return null;
+  const traceDigest = sha256Hex(JSON.stringify(trace));
+  return {
+    platform,
+    opencodeVersion,
+    provenance: "genuine-usage",
+    traceDigest,
+    criticalDivergences: countCriticalDivergences(parity, criticalCodes),
+    privacy: scanTracePrivacy(trace),
+    duplicateEffects: detectDuplicateEffects(trace),
+    modelVerification
+  };
 }
-function parseLegacyExecutionTrace(input) {
-  const result = LegacyExecutionTraceV1Schema.safeParse(input);
-  if (!result.success) {
-    throw new LegacyTraceError(result.error);
-  }
-  return result.data;
+async function recordSoakObservation(ports, evidenceDir, recorderId, trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
+  const input = traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride);
+  if (input === null)
+    return false;
+  await appendObservation(ports, evidenceDir, recorderId, input);
+  return true;
 }
 
-// src/plugin/reportRunSchema.ts
-var ReportRunNodeSchema = z10.object({
-  id: NodeIDSchema,
-  role: NodeRoleSchema,
-  model: z10.string().min(1),
-  ok: z10.boolean(),
-  sessionRef: z10.string().min(1).optional(),
-  errorClass: ErrorClassSchema.optional()
-}).strict();
-var ReportRunPayloadSchema = z10.object({
-  runID: NodeIDSchema,
-  status: LegacyExecutionStatusSchema,
-  fixes: z10.number().int().nonnegative(),
-  nodes: z10.array(ReportRunNodeSchema).min(1),
-  parentSessionRef: z10.string().min(1).optional()
-}).strict();
-
-// src/graph/types.ts
-var TERMINAL_NODE_STATUSES = new Set([
-  "succeeded",
-  "cancelled"
-]);
-var TERMINAL_RUN_STATUSES = new Set([
-  "completed",
-  "failed",
-  "cancelled"
-]);
+// src/plugin/shadowPipeline.ts
+function createShadowPipeline(deps) {
+  return async (observation, modelVerification) => {
+    try {
+      const ingested = ingestLegacyExecution(observation, deps.gate);
+      if (!ingested.eligible) {
+        return { kind: "ineligible", reason: ingested.reason };
+      }
+      const mirror = mirrorLegacyTrace(ingested.trace);
+      let parity;
+      if (mirror.ok) {
+        const legacySummary = projectLegacySummary(ingested.trace);
+        const report = compareShadowRun(legacySummary, mirror.mirror.summary);
+        parity = { divergences: [...report.divergences] };
+      }
+      const recorded = await recordSoakObservation(deps.ports, deps.evidenceDir, deps.recorderId, ingested.trace, deps.opencodeVersion, parity, deps.criticalCodes, modelVerification ?? null, deps.platformOverride);
+      if (!recorded) {
+        return {
+          kind: "observation-rejected",
+          reason: "unrecognized-platform"
+        };
+      }
+      return { kind: "observed" };
+    } catch (error) {
+      return {
+        kind: "contained-failure",
+        detail: error instanceof Error ? error.message : String(error)
+      };
+    }
+  };
+}
 
-// src/graph/reducer.ts
-class ReducerError extends Error {
-  code;
-  detail;
-  constructor(code, detail) {
-    super(`${code}: ${detail}`);
-    this.name = "ReducerError";
-    this.code = code;
-    this.detail = detail;
+// src/plugin/graphTool.ts
+function describeDecision(decision) {
+  if (decision.route === "graph") {
+    return `graph: la tarea ${decision.taskID} se enrutaría al runtime activo.`;
   }
-}
-function initialState(spec) {
-  const nodes = {};
-  for (const node of spec.nodes) {
-    nodes[node.id] = { status: "pending", attempts: 0 };
+  switch (decision.reason) {
+    case "gate-closed":
+      return "legacy: gate-closed — el ingress activo no es alcanzable por configuración en esta versión.";
+    case "kill-switch":
+      return "legacy: kill-switch — apagado de emergencia activo.";
+    case "graph-disabled":
+      return "legacy: graph-disabled — graph.mode no es 'active'.";
+    case "not-allow-listed":
+      return "legacy: not-allow-listed — la tarea no está en la allow-list del ingress.";
   }
-  return { runID: spec.runID, status: "running", seq: -1, nodes };
 }
-function withNode(state, nodeID, next) {
-  return {
-    ...state,
-    nodes: { ...state.nodes, [nodeID]: next },
-    seq: state.seq
-  };
+function describeOutcome(outcome) {
+  switch (outcome.kind) {
+    case "legacy":
+      return describeDecision({ route: "legacy", reason: outcome.reason });
+    case "accepted":
+      return `accepted: run ${outcome.runID}, paso ${outcome.step.kind}.`;
+    case "revision":
+      return `revision: run ${outcome.runID}, plan ${outcome.plan.kind}.`;
+    case "reassigned":
+      return `reassigned: run ${outcome.runID}, reviewer ${outcome.reviewerID}.`;
+    case "cancelled":
+      return `cancelled: run ${outcome.runID}, ${outcome.cancelledNodeIDs.length} nodo(s) cancelado(s).`;
+    case "error":
+      return `error: ${outcome.code}.`;
+  }
 }
-function specNode(spec, nodeID) {
-  return spec.nodes.find((node) => node.id === nodeID);
+function unavailableReason(deps, taskID) {
+  const decision = decideIngress(deps.policy, taskID);
+  return decision.route === "legacy" ? describeDecision(decision) : "unavailable: el ejecutor de efectos del runtime activo no está enchufado.";
 }
-function applyRunStarted(state, seq, specDigest) {
-  if (state.specDigest !== undefined) {
-    if (state.specDigest === specDigest) {
-      return state;
+function createGraphTool(deps) {
+  const observe = deps.shadow !== undefined ? createShadowPipeline(deps.shadow) : async () => ({
+    kind: "ineligible",
+    reason: "shadow-not-configured"
+  });
+  const definition = tool2({
+    description: "Ingress activo de SDD de openteam (GE-050). En esta versión la puerta interna está cerrada: informa del estado de enrutado y no ejecuta runs. La acción report-run registra una observación shadow de la ejecución legacy.",
+    args: {
+      action: tool2.schema.enum(["status", "start", "cancel", "report-run"]).describe("Acción a ejecutar"),
+      taskID: tool2.schema.string().optional().describe("Identificador de la tarea SDD"),
+      runID: tool2.schema.string().optional().describe("Identificador del run (para action=cancel o report-run)"),
+      status: tool2.schema.enum(["completed", "failed", "cancelled"]).optional().describe("Estado terminal del run (solo action=report-run)"),
+      fixes: tool2.schema.number().optional().describe("Número de iteraciones de fix (solo action=report-run)"),
+      nodes: tool2.schema.array(tool2.schema.object({
+        id: tool2.schema.string().describe("ID del nodo"),
+        role: tool2.schema.enum(["implementer", "reviewer"]).describe("Rol del nodo"),
+        model: tool2.schema.string().describe("Modelo utilizado por el nodo"),
+        ok: tool2.schema.boolean().describe("Éxito terminal del nodo"),
+        sessionRef: tool2.schema.string().optional().describe("ID de sesión de opencode del nodo"),
+        errorClass: tool2.schema.enum(["transient", "permanent", "exhausted"]).optional().describe("Clase de error si el nodo falló")
+      })).optional().describe("Nodos de la ejecución (solo action=report-run)"),
+      parentSessionRef: tool2.schema.string().optional().describe("Sesión padre del run (solo action=report-run)")
+    },
+    async execute(args) {
+      if (args.action === "report-run") {
+        return handleReportRun(args, observe, deps.tracker);
+      }
+      const taskID = args.taskID ?? "";
+      if (args.action === "status") {
+        return describeDecision(decideIngress(deps.policy, taskID));
+      }
+      const ingress = deps.ingress;
+      if (ingress === undefined) {
+        return unavailableReason(deps, taskID);
+      }
+      if (args.action === "cancel") {
+        return describeOutcome(await ingress.cancel(args.runID ?? ""));
+      }
+      return describeOutcome(await ingress.start({
+        id: taskID,
+        implementerRoleID: "linus",
+        title: taskID,
+        brief: taskID,
+        task: {
+          promptChars: 0,
+          hasCode: false,
+          estimatedInputTokens: 0,
+          estimatedOutputTokens: 0
+        }
+      }));
     }
-    throw new ReducerError("run-started-conflict", specDigest);
-  }
-  return { ...state, specDigest, seq };
+  });
+  return { definition, observeLegacyExecution: observe };
 }
-function applyDispatched(spec, state, event) {
-  const node = specNode(spec, event.nodeID);
-  const current = state.nodes[event.nodeID];
-  if (node === undefined || current === undefined) {
-    throw new ReducerError("unknown-node", event.nodeID);
-  }
-  for (const dep of node.dependsOn) {
-    if (state.nodes[dep]?.status !== "succeeded") {
-      throw new ReducerError("dependency-not-satisfied", `${event.nodeID} <- ${dep}`);
-    }
+async function handleReportRun(args, observe, tracker) {
+  const parsed = ReportRunPayloadSchema.safeParse({
+    runID: args.runID,
+    status: args.status,
+    fixes: args.fixes,
+    nodes: args.nodes,
+    ...args.parentSessionRef !== undefined ? { parentSessionRef: args.parentSessionRef } : {}
+  });
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    return formatResponse({
+      result: "ineligible",
+      detail: `validation: ${issues}`
+    });
   }
-  const running = {
-    status: "running",
-    attempts: current.attempts + 1,
-    operationID: event.operationID,
-    attemptID: event.attemptID
+  const verification = crossVerify(parsed.data, tracker);
+  const warnings = formatWarnings(verification);
+  const verificationPair = {
+    nodesChecked: parsed.data.nodes.length,
+    unverified: verification.unverifiedModels.length,
+    mismatched: verification.modelMismatches.length
   };
-  if (current.status === "pending") {
-    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
-  }
-  if (current.status === "failed") {
-    if (current.operationID !== event.operationID) {
-      throw new ReducerError("dispatch-conflict", event.nodeID);
-    }
-    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
-  }
-  if (current.status === "running") {
-    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
-      return state;
-    }
-    throw new ReducerError("dispatch-conflict", event.nodeID);
+  const run = buildObservedRun(parsed.data);
+  try {
+    const result = await observe(run, verificationPair);
+    const base = { result: result.kind };
+    const detail = result.kind === "ineligible" ? result.reason : result.kind === "observation-rejected" ? result.reason : result.kind === "contained-failure" ? result.detail : null;
+    return formatResponse({
+      ...base,
+      ...detail !== null ? { detail } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    });
+  } catch (error) {
+    return formatResponse({
+      result: "contained-failure",
+      detail: error instanceof Error ? error.message : String(error)
+    });
   }
-  throw new ReducerError("illegal-transition", `dispatch ${current.status}`);
 }
-function applySucceeded(state, event) {
-  const current = state.nodes[event.nodeID];
-  if (current === undefined) {
-    throw new ReducerError("unknown-node", event.nodeID);
-  }
-  if (current.status === "succeeded") {
-    if (current.operationID === event.operationID && current.artifactSha256 === event.artifact.sha256) {
-      return state;
-    }
-    throw new ReducerError("receipt-conflict", event.nodeID);
+
+// 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 (current.status !== "running") {
-    throw new ReducerError("illegal-transition", `succeed ${current.status}`);
+  if (budgetExceeded(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return exhaustedDecision(budgets, "monthly-budget-exhausted");
   }
-  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
-    throw new ReducerError("receipt-conflict", event.nodeID);
+  if (state.frontierTokens !== undefined && budgets.frontierTokensPerSession !== undefined && state.frontierTokens >= budgets.frontierTokensPerSession) {
+    return exhaustedDecision(budgets, "frontier-token-budget-exhausted");
   }
-  return withNode({ ...state, seq: event.seq }, event.nodeID, {
-    status: "succeeded",
-    attempts: current.attempts,
-    operationID: event.operationID,
-    attemptID: event.attemptID,
-    artifactSha256: event.artifact.sha256
-  });
-}
-function applyFailed(state, event) {
-  const current = state.nodes[event.nodeID];
-  if (current === undefined) {
-    throw new ReducerError("unknown-node", event.nodeID);
+  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
+    return { action: "warn", reason: "session-budget-near-limit" };
   }
-  if (current.status === "failed") {
-    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
-      return state;
-    }
-    throw new ReducerError("receipt-conflict", event.nodeID);
+  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return { action: "warn", reason: "monthly-budget-near-limit" };
   }
-  if (current.status !== "running") {
-    throw new ReducerError("illegal-transition", `fail ${current.status}`);
+  return { action: "ok" };
+}
+
+// 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 (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
-    throw new ReducerError("receipt-conflict", event.nodeID);
+  if (override === "alwaysLocal") {
+    return -20;
   }
-  return withNode({ ...state, seq: event.seq }, event.nodeID, {
-    status: "failed",
-    attempts: current.attempts,
-    operationID: event.operationID,
-    attemptID: event.attemptID
-  });
+  return 0;
 }
-function applyCancelled(state, event) {
-  const current = state.nodes[event.nodeID];
-  if (current === undefined) {
-    throw new ReducerError("unknown-node", event.nodeID);
-  }
-  if (current.status === "cancelled") {
-    return state;
+function tierFromScore(score) {
+  if (score <= 15) {
+    return "trivial";
   }
-  if (current.status === "succeeded") {
-    throw new ReducerError("illegal-transition", "cancel succeeded");
+  if (score <= 35) {
+    return "simple";
   }
-  return withNode({ ...state, seq: event.seq }, event.nodeID, {
-    ...current,
-    status: "cancelled"
-  });
-}
-function applyRunCompleted(state, seq) {
-  for (const node of Object.values(state.nodes)) {
-    if (node.status !== "succeeded" && node.status !== "cancelled") {
-      throw new ReducerError("incomplete-run", node.status);
-    }
+  if (score <= 65) {
+    return "moderate";
   }
-  return { ...state, status: "completed", seq };
+  return "hard";
 }
-function applyEvent(spec, state, event) {
-  if (event.runID !== state.runID) {
-    throw new ReducerError("run-mismatch", event.runID);
+function confidenceFromScore(score) {
+  if (score >= 75 || score <= 10) {
+    return 0.9;
   }
-  if (TERMINAL_RUN_STATUSES.has(state.status)) {
-    if (event.type === "run.completed" && state.status === "completed" || event.type === "run.failed" && state.status === "failed" || event.type === "run.cancelled" && state.status === "cancelled") {
-      return state;
-    }
-    throw new ReducerError("post-terminal", event.type);
+  if (score >= 30 && score <= 70) {
+    return 0.58;
   }
-  switch (event.type) {
-    case "run.started":
-      return applyRunStarted(state, event.seq, event.specDigest);
-    case "node.dispatched":
-      return applyDispatched(spec, state, event);
-    case "node.succeeded":
-      return applySucceeded(state, event);
-    case "node.failed":
-      return applyFailed(state, event);
-    case "node.cancelled":
-      return applyCancelled(state, event);
-    case "run.completed":
-      return applyRunCompleted(state, event.seq);
-    case "run.failed":
-      return { ...state, status: "failed", seq: event.seq };
-    case "run.cancelled":
-      return { ...state, status: "cancelled", seq: event.seq };
+  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/orchestrator/graphShadow.ts
-class ShadowMirrorError extends Error {
-  code;
-  detail;
-  constructor(code, detail) {
-    super(`${code}: ${detail}`);
-    this.name = "ShadowMirrorError";
-    this.code = code;
-    this.detail = detail;
-  }
+// src/router/modelSelection.ts
+function modelKey2(model) {
+  return `${model.providerID}/${model.modelID}`;
 }
-function traceAnchorDigest(trace) {
-  return sha256Hex(JSON.stringify({
-    version: trace.version,
-    runID: trace.runID,
-    nodes: trace.nodes.map((node) => [node.id, node.role])
-  }));
+function sameModel(left, right) {
+  return left.providerID === right.providerID && left.modelID === right.modelID;
 }
-function compileShadowSpec(trace) {
-  const anchor = { taskID: trace.runID, specDigest: traceAnchorDigest(trace) };
-  const nodes = [];
-  let previousID;
-  let lastImplementerID;
-  for (const node of trace.nodes) {
-    const dependsOn = previousID === undefined ? [] : [previousID];
-    if (node.role === "implementer") {
-      nodes.push({ id: node.id, role: "implementer", dependsOn, anchor });
-      lastImplementerID = node.id;
-    } else {
-      nodes.push({
-        id: node.id,
-        role: "reviewer",
-        dependsOn,
-        anchor,
-        ...lastImplementerID === undefined ? {} : { reviews: lastImplementerID }
-      });
-    }
-    previousID = node.id;
+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);
   }
-  let spec;
-  try {
-    spec = GraphSpecV1Schema.parse({ version: 1, runID: trace.runID, nodes });
-    validateGraphSpec(spec);
-  } catch (error) {
-    throw new ShadowMirrorError("invalid-spec", error instanceof Error ? error.message : String(error));
+  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;
   }
-  assertReferenceOnly(spec);
-  return spec;
+  return config.baseline.hardDefault;
 }
-var TERMINAL_EVENT = {
-  completed: "run.completed",
-  failed: "run.failed",
-  cancelled: "run.cancelled"
-};
-function shadowArtifact(runID, nodeID) {
-  return {
-    uri: `shadow://${runID}/${nodeID}`,
-    sha256: sha256Hex(`shadow-artifact\x00${runID}\x00${nodeID}`),
-    bytes: 0
-  };
+function compareAvailableModels2(left, right) {
+  return compareModels(left, right);
 }
-function mirrorJournal(spec, trace) {
-  const runID = trace.runID;
-  const events = [
+function defaultAvailableModels2(config) {
+  return [
     {
-      v: 1,
-      seq: 0,
-      runID,
-      type: "run.started",
-      specDigest: graphSpecDigest(spec)
-    }
-  ];
-  for (const node of trace.nodes) {
-    const operation = operationID(runID, node.id);
-    const attempt = attemptID(operation, 0);
-    events.push({
-      v: 1,
-      seq: events.length,
-      runID,
-      type: "node.dispatched",
-      nodeID: node.id,
-      operationID: operation,
-      attemptID: attempt
-    });
-    if (node.errorClass === undefined) {
-      events.push({
-        v: 1,
-        seq: events.length,
-        runID,
-        type: "node.succeeded",
-        nodeID: node.id,
-        operationID: operation,
-        attemptID: attempt,
-        artifact: shadowArtifact(runID, node.id)
-      });
-      continue;
-    }
-    if (node.errorClass === "cancelled") {
-      events.push({
-        v: 1,
-        seq: events.length,
-        runID,
-        type: "node.cancelled",
-        nodeID: node.id
-      });
-      continue;
+      ...localDefault(config),
+      kind: "local",
+      available: true
+    },
+    {
+      ...resolveConfiguredFrontierBaseline(config),
+      kind: "frontier",
+      available: true
     }
-    events.push({
-      v: 1,
-      seq: events.length,
-      runID,
-      type: "node.failed",
-      nodeID: node.id,
-      operationID: operation,
-      attemptID: attempt,
-      errorClass: node.errorClass
-    });
-  }
-  events.push({
-    v: 1,
-    seq: events.length,
-    runID,
-    type: TERMINAL_EVENT[trace.status]
-  });
-  return events;
+  ].sort(compareAvailableModels2);
+}
+function availableModels(input) {
+  return (input.availableModels ?? defaultAvailableModels2(input.config)).slice().sort(compareAvailableModels2);
+}
+function listedModel(input, model) {
+  return availableModels(input).find((candidate) => sameModel(candidate, model));
 }
-function reduceMirror(spec, journal) {
-  let state = initialState(spec);
-  try {
-    for (const event of journal) {
-      state = applyEvent(spec, state, event);
-    }
-  } catch (error) {
-    throw new ShadowMirrorError("illegal-sequence", error instanceof ReducerError ? `${error.code}: ${error.detail}` : String(error));
+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;
   }
-  return state;
+  const inputTokens = input.task.estimatedInputTokens ?? 0;
+  const outputTokens = input.task.estimatedOutputTokens ?? 0;
+  return inputTokens / 1e6 * profile.costPer1M.inputUSD + outputTokens / 1e6 * profile.costPer1M.outputUSD;
 }
-function projectLegacySummary(trace) {
-  return {
-    runID: trace.runID,
-    status: trace.status,
-    outcome: trace.outcome,
-    fixes: trace.fixes,
-    nodes: trace.nodes.map((node) => ({
-      id: node.id,
-      role: node.role,
-      model: node.model
-    }))
-  };
+function roundUSD(value) {
+  return Math.round(value * 1000000000000) / 1000000000000;
 }
-function projectShadowSummary(spec, trace) {
-  const implementers = spec.nodes.filter((node) => node.role === "implementer").length;
+
+// 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 {
-    runID: spec.runID,
-    status: trace.status,
-    outcome: trace.outcome,
-    fixes: implementers - 1,
-    nodes: spec.nodes.map((node, index) => ({
-      id: node.id,
-      role: node.role,
-      model: trace.nodes[index].model
-    }))
+    minReasoningTier: base.reasoning,
+    minCodeQualityTier: Math.min(5, base.code + codeBump),
+    minContextWindow,
+    needsTools: task.requiresTools === true,
+    needsVision: task.requiresVision === true
   };
 }
-function mirrorLegacyExecution(trace) {
-  const spec = compileShadowSpec(trace);
-  const journal = mirrorJournal(spec, trace);
-  const state = reduceMirror(spec, journal);
-  const summary = projectShadowSummary(spec, trace);
-  assertReferenceOnly(summary);
-  return {
-    spec,
-    specDigest: graphSpecDigest(spec),
-    journal,
-    state,
-    summary
-  };
+function blendedCostPer1M(profile) {
+  return profile.costPer1M.inputUSD * BLENDED_COST_INPUT_WEIGHT + profile.costPer1M.outputUSD * BLENDED_COST_OUTPUT_WEIGHT;
+}
+function modelKey3(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 modelKey3(left).localeCompare(modelKey3(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/graphFacade.ts
-function mirrorLegacyTrace(trace) {
-  try {
-    return {
-      ok: true,
-      mirror: mirrorLegacyExecution(parseLegacyExecutionTrace(trace))
-    };
-  } catch (error) {
-    if (error instanceof ShadowMirrorError) {
-      return { ok: false, code: error.code, detail: error.detail };
-    }
-    if (error instanceof LegacyTraceError) {
+// 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 {
-        ok: false,
-        code: "invalid-trace",
-        detail: error.issues.join("; ")
+        model: selected,
+        rationale: ["auto-cheapest-capable-frontier"]
       };
     }
     return {
-      ok: false,
-      code: "mirror-error",
-      detail: error instanceof Error ? error.message : String(error)
+      model: input.config.baseline.hardDefault,
+      rationale: ["auto-cheapest-capable-unavailable-hard-default"]
     };
   }
+  return { model: input.config.baseline.hardDefault, rationale: [] };
 }
 
-// src/orchestrator/shadowComparator.ts
-function sequenceEqual(a, b) {
-  if (a.length !== b.length) {
-    return false;
+// 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 a.every((value, index) => value === b[index]);
+  return chain;
 }
-function compareShadowRun(legacy, shadow) {
-  if (legacy === undefined || shadow === undefined) {
-    return { verdict: "inconclusive", divergences: [] };
+function inferRouteKind(config, selected, listed) {
+  if (listed !== undefined) {
+    return listed.kind;
   }
-  const divergences = [];
-  if (legacy.status !== shadow.status) {
-    divergences.push("status");
+  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 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;
+  return {
+    ...core,
+    tier,
+    rationale: [...frontier.rationale, ...core.rationale],
+    estimatedCostUSD: roundUSD(selectedCostUSD),
+    baselineCostUSD: roundUSD(baselineCostUSD),
+    estimatedSavingsUSD: roundUSD(savingsUSD),
+    budgetAction
+  };
+}
+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") {
+    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") {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: [`budget-${budgetAction.action}`],
+      allowFrontier: false,
+      noLocalRationale: "budget-local-unavailable"
+    }));
   }
-  if (!sequenceEqual(legacy.nodes.map((node) => node.id), shadow.nodes.map((node) => node.id))) {
-    divergences.push("order");
+  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 (!sequenceEqual(legacy.nodes.map((node) => node.role), shadow.nodes.map((node) => node.role))) {
-    divergences.push("roles");
+  if (override === "alwaysLocal") {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: ["explicit-always-local"],
+      allowFrontier: false,
+      noLocalRationale: "forced-local-unavailable"
+    }));
   }
-  if (!sequenceEqual(legacy.nodes.map((node) => node.model), shadow.nodes.map((node) => node.model))) {
-    divergences.push("models");
+  if (override === "alwaysFrontier") {
+    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
   }
-  if (legacy.fixes !== shadow.fixes) {
-    divergences.push("fixes");
+  if (input.config.router.frontierOnly) {
+    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["router-frontier-only"], []));
   }
-  if (legacy.outcome !== shadow.outcome) {
-    divergences.push("outcome");
+  const shortEnoughForLocal = input.task.promptChars <= input.config.router.trivialPromptMaxChars;
+  const largeEnoughForFrontier = input.task.promptChars >= input.config.router.frontierPromptMinChars;
+  if (!input.task.hasCode && shortEnoughForLocal && !largeEnoughForFrontier) {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: ["trivial-short-no-code"],
+      allowFrontier: true,
+      noLocalRationale: "forced-local-unavailable"
+    }));
   }
-  return {
-    verdict: divergences.length === 0 ? "match" : "divergent",
-    divergences
-  };
+  return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
+    input.task.hasCode ? "code-detected" : "large-or-nontrivial-prompt"
+  ]));
 }
 
-// src/storage/graph/soakRecorder.ts
-async function ensureRecorderId(ports, basePath) {
-  const idPath = `${basePath}/soak-recorder-id`;
-  if (await ports.fs.exists(idPath)) {
-    const id = (await ports.fs.readFile(idPath)).trim();
-    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
-      return id;
-    }
-  }
-  const newId = ports.id.randomUUID();
-  await ports.fs.writeFile(idPath, newId);
-  return newId;
+// src/telemetry/cost.ts
+function routeKind(decision2) {
+  return decision2.routeKind === "local" ? "local" : "frontier";
 }
-async function readAllChains(ports, evidenceDir) {
-  if (!await ports.fs.exists(evidenceDir)) {
-    return [];
+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;
   }
-  const files = await ports.fs.readDir(evidenceDir);
-  const chains = [];
-  for (const file of files) {
-    if (!file.endsWith(".jsonl")) {
+  if (context.tokensIn !== undefined) {
+    record.tokensIn = context.tokensIn;
+  }
+  if (context.tokensOut !== undefined) {
+    record.tokensOut = context.tokensOut;
+  }
+  return record;
+}
+
+// src/telemetry/types.ts
+import { z as z10 } from "zod";
+var CostRecordSchema = z10.object({
+  ts: z10.number().finite(),
+  sessionID: z10.string().min(1).optional(),
+  promptHash: z10.string().min(1),
+  promptChars: z10.number().int().min(0),
+  tier: ComplexityTierSchema,
+  routeKind: z10.enum(["local", "frontier"]),
+  selected: ModelRefSchema,
+  rationale: z10.string(),
+  estimatedCostUSD: z10.number().finite().min(0),
+  baselineCostUSD: z10.number().finite().min(0),
+  estimatedSavingsUSD: z10.number().finite(),
+  budgetAction: z10.string().min(1),
+  tokensIn: z10.number().int().min(0).optional(),
+  tokensOut: z10.number().int().min(0).optional()
+});
+
+// src/telemetry/read.ts
+var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
+function parseCostRecordsJsonl(text) {
+  const records = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
       continue;
     }
-    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
-    const lines = content.split(`
-`).filter((l) => l.trim().length > 0);
-    const observations = [];
-    for (const line of lines) {
-      const parsed = SoakObservationSchema.safeParse(JSON.parse(line));
-      if (parsed.success) {
-        observations.push(parsed.data);
-      }
-    }
-    if (observations.length > 0) {
-      chains.push(observations);
+    let candidate;
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
     }
-  }
-  return chains;
-}
-function canonicalObservationPreimage2(obs) {
-  return JSON.stringify({
-    version: obs.version,
-    seq: obs.seq,
-    timestamp: obs.timestamp,
-    platform: obs.platform,
-    opencodeVersion: obs.opencodeVersion,
-    provenance: obs.provenance,
-    traceDigest: obs.traceDigest,
-    criticalDivergences: obs.criticalDivergences,
-    privacy: obs.privacy,
-    duplicateEffects: obs.duplicateEffects,
-    modelVerification: obs.modelVerification
-  });
-}
-async function appendObservation(ports, evidenceDir, recorderId, input) {
-  await ports.fs.mkdir(evidenceDir);
-  const chainPath = `${evidenceDir}/${recorderId}.jsonl`;
-  let seq = 0;
-  let prevChainDigest = "0".repeat(64);
-  if (await ports.fs.exists(chainPath)) {
-    const content = await ports.fs.readFile(chainPath);
-    const lines = content.split(`
-`).filter((l) => l.trim().length > 0);
-    if (lines.length > 0) {
-      const lastLine = lines[lines.length - 1];
-      let rawParsed;
-      try {
-        rawParsed = JSON.parse(lastLine);
-      } catch {
-        throw new Error("corrupt chain tail: invalid JSON");
-      }
-      const parsed = SoakObservationSchema.safeParse(rawParsed);
-      if (!parsed.success) {
-        const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
-        throw new Error(`corrupt chain tail: ${detail}`);
-      }
-      seq = parsed.data.seq + 1;
-      prevChainDigest = parsed.data.chainDigest;
+    const parsed = CostRecordSchema.safeParse(candidate);
+    if (parsed.success) {
+      records.push(parsed.data);
     }
   }
-  const timestamp = ports.clock.now();
-  const base = {
-    version: 1,
-    seq,
-    timestamp,
-    platform: input.platform,
-    opencodeVersion: input.opencodeVersion,
-    provenance: input.provenance,
-    traceDigest: input.traceDigest,
-    criticalDivergences: input.criticalDivergences,
-    privacy: input.privacy,
-    duplicateEffects: input.duplicateEffects,
-    modelVerification: input.modelVerification
-  };
-  const preimage = canonicalObservationPreimage2(base);
-  const chainDigest = sha256Hex(prevChainDigest + preimage);
-  const observation = { ...base, chainDigest };
-  assertReferenceOnly(observation);
-  const line = JSON.stringify(observation);
-  if (await ports.fs.exists(chainPath)) {
-    const existing = await ports.fs.readFile(chainPath);
-    await ports.fs.writeFile(chainPath, `${existing}
-${line}`);
-  } else {
-    await ports.fs.writeFile(chainPath, line);
-  }
-  return observation;
+  return records;
 }
 
-// src/plugin/soakObserver.ts
-function resolvePlatform(platform) {
-  if (platform === "win32")
-    return "win32";
-  if (platform === "darwin")
-    return "darwin";
-  if (platform === "linux")
-    return "linux";
-  return null;
-}
-function countCriticalDivergences(parity, criticalCodes) {
-  if (parity === undefined)
-    return null;
-  if (criticalCodes.length === 0)
-    return null;
-  const criticalSet = new Set(criticalCodes);
-  return parity.divergences.filter((code) => criticalSet.has(code)).length;
-}
-function scanTracePrivacy(trace) {
-  const result = scanReferenceOnly([trace]);
-  return {
-    surfacesScanned: result.surfacesScanned,
-    rawFindings: result.rawFindings
-  };
-}
-function detectDuplicateEffects(trace) {
-  const nodes = trace.nodes;
-  if (nodes.length === 0)
-    return null;
-  const seen = new Set;
-  let duplicates = 0;
-  for (const node of nodes) {
-    if (seen.has(node.id)) {
-      duplicates++;
-    } else {
-      seen.add(node.id);
-    }
-  }
-  return { effectsExamined: nodes.length, duplicatesFound: duplicates };
+// src/telemetry/eventLog.ts
+var DEFAULT_SESSIONS_DIR = ".opencode/openteam/sessions";
+var LEGACY_SESSION_ID = "legacy";
+function sessionFileName(sessionID) {
+  const safe = sessionID.replace(/[^A-Za-z0-9._-]/g, "_");
+  return `${safe}.jsonl`;
 }
-function traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
-  const platform = resolvePlatform(platformOverride ?? process.platform);
-  if (platform === null)
-    return null;
-  const traceDigest = sha256Hex(JSON.stringify(trace));
-  return {
-    platform,
-    opencodeVersion,
-    provenance: "genuine-usage",
-    traceDigest,
-    criticalDivergences: countCriticalDivergences(parity, criticalCodes),
-    privacy: scanTracePrivacy(trace),
-    duplicateEffects: detectDuplicateEffects(trace),
-    modelVerification
+function createEventLogSink(deps) {
+  return {
+    emit: async (event) => {
+      try {
+        const parsed = OpenTeamEventSchema.parse(event);
+        const path = joinVirtualPath(deps.dir, sessionFileName(parsed.sessionID));
+        await deps.storage.append(path, `${JSON.stringify(parsed)}
+`);
+      } catch (error) {
+        deps.onError?.(error);
+      }
+    }
   };
 }
-async function recordSoakObservation(ports, evidenceDir, recorderId, trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
-  const input = traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride);
-  if (input === null)
-    return false;
-  await appendObservation(ports, evidenceDir, recorderId, input);
-  return true;
+function createNullEventSink() {
+  return { emit: () => {} };
 }
-
-// src/plugin/shadowPipeline.ts
-function createShadowPipeline(deps) {
-  return async (observation, modelVerification) => {
+function parseEventsJsonl(text) {
+  const events = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let candidate;
     try {
-      const ingested = ingestLegacyExecution(observation, deps.gate);
-      if (!ingested.eligible) {
-        return { kind: "ineligible", reason: ingested.reason };
-      }
-      const mirror = mirrorLegacyTrace(ingested.trace);
-      let parity;
-      if (mirror.ok) {
-        const legacySummary = projectLegacySummary(ingested.trace);
-        const report = compareShadowRun(legacySummary, mirror.mirror.summary);
-        parity = { divergences: [...report.divergences] };
-      }
-      const recorded = await recordSoakObservation(deps.ports, deps.evidenceDir, deps.recorderId, ingested.trace, deps.opencodeVersion, parity, deps.criticalCodes, modelVerification ?? null, deps.platformOverride);
-      if (!recorded) {
-        return {
-          kind: "observation-rejected",
-          reason: "unrecognized-platform"
-        };
-      }
-      return { kind: "observed" };
-    } catch (error) {
-      return {
-        kind: "contained-failure",
-        detail: error instanceof Error ? error.message : String(error)
-      };
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
     }
-  };
+    const parsed = OpenTeamEventSchema.safeParse(candidate);
+    if (parsed.success) {
+      events.push(parsed.data);
+    }
+  }
+  return events;
 }
-
-// src/plugin/graphTool.ts
-function describeDecision(decision2) {
-  if (decision2.route === "graph") {
-    return `graph: la tarea ${decision2.taskID} se enrutaría al runtime activo.`;
+function costRecordToRouteEvent(record) {
+  const event = {
+    v: EVENT_SCHEMA_VERSION,
+    type: "route",
+    ts: record.ts,
+    sessionID: record.sessionID ?? LEGACY_SESSION_ID,
+    promptHash: record.promptHash,
+    promptChars: record.promptChars,
+    tier: record.tier,
+    routeKind: record.routeKind,
+    selected: record.selected,
+    rationale: record.rationale,
+    estimatedCostUSD: record.estimatedCostUSD,
+    baselineCostUSD: record.baselineCostUSD,
+    estimatedSavingsUSD: record.estimatedSavingsUSD,
+    budgetAction: record.budgetAction
+  };
+  if (record.tokensIn !== undefined) {
+    event.tokensIn = record.tokensIn;
   }
-  switch (decision2.reason) {
-    case "gate-closed":
-      return "legacy: gate-closed — el ingress activo no es alcanzable por configuración en esta versión.";
-    case "kill-switch":
-      return "legacy: kill-switch — apagado de emergencia activo.";
-    case "graph-disabled":
-      return "legacy: graph-disabled — graph.mode no es 'active'.";
-    case "not-allow-listed":
-      return "legacy: not-allow-listed — la tarea no está en la allow-list del ingress.";
+  if (record.tokensOut !== undefined) {
+    event.tokensOut = record.tokensOut;
   }
+  return event;
 }
-function describeOutcome(outcome) {
-  switch (outcome.kind) {
-    case "legacy":
-      return describeDecision({ route: "legacy", reason: outcome.reason });
-    case "accepted":
-      return `accepted: run ${outcome.runID}, paso ${outcome.step.kind}.`;
-    case "revision":
-      return `revision: run ${outcome.runID}, plan ${outcome.plan.kind}.`;
-    case "reassigned":
-      return `reassigned: run ${outcome.runID}, reviewer ${outcome.reviewerID}.`;
-    case "cancelled":
-      return `cancelled: run ${outcome.runID}, ${outcome.cancelledNodeIDs.length} nodo(s) cancelado(s).`;
-    case "error":
-      return `error: ${outcome.code}.`;
+function routeEventToCostRecord(event) {
+  const record = {
+    ts: event.ts,
+    sessionID: event.sessionID,
+    promptHash: event.promptHash,
+    promptChars: event.promptChars,
+    tier: event.tier,
+    routeKind: event.routeKind,
+    selected: event.selected,
+    rationale: event.rationale,
+    estimatedCostUSD: event.estimatedCostUSD,
+    baselineCostUSD: event.baselineCostUSD,
+    estimatedSavingsUSD: event.estimatedSavingsUSD,
+    budgetAction: event.budgetAction
+  };
+  if (event.tokensIn !== undefined) {
+    record.tokensIn = event.tokensIn;
+  }
+  if (event.tokensOut !== undefined) {
+    record.tokensOut = event.tokensOut;
   }
+  return record;
 }
-function unavailableReason(deps, taskID) {
-  const decision2 = decideIngress(deps.policy, taskID);
-  return decision2.route === "legacy" ? describeDecision(decision2) : "unavailable: el ejecutor de efectos del runtime activo no está enchufado.";
+async function readRouteCostRecords(dir, deps) {
+  const events = await readSessionEvents(dir, deps);
+  const records = [];
+  for (const event of events) {
+    if (event.type === "route") {
+      records.push(routeEventToCostRecord(event));
+    }
+  }
+  return records;
 }
-function createGraphTool(deps) {
-  const observe = deps.shadow !== undefined ? createShadowPipeline(deps.shadow) : async () => ({
-    kind: "ineligible",
-    reason: "shadow-not-configured"
-  });
-  const definition = tool2({
-    description: "Ingress activo de SDD de openteam (GE-050). En esta versión la puerta interna está cerrada: informa del estado de enrutado y no ejecuta runs. La acción report-run registra una observación shadow de la ejecución legacy.",
-    args: {
-      action: tool2.schema.enum(["status", "start", "cancel", "report-run"]).describe("Acción a ejecutar"),
-      taskID: tool2.schema.string().optional().describe("Identificador de la tarea SDD"),
-      runID: tool2.schema.string().optional().describe("Identificador del run (para action=cancel o report-run)"),
-      status: tool2.schema.enum(["completed", "failed", "cancelled"]).optional().describe("Estado terminal del run (solo action=report-run)"),
-      fixes: tool2.schema.number().optional().describe("Número de iteraciones de fix (solo action=report-run)"),
-      nodes: tool2.schema.array(tool2.schema.object({
-        id: tool2.schema.string().describe("ID del nodo"),
-        role: tool2.schema.enum(["implementer", "reviewer"]).describe("Rol del nodo"),
-        model: tool2.schema.string().describe("Modelo utilizado por el nodo"),
-        ok: tool2.schema.boolean().describe("Éxito terminal del nodo"),
-        sessionRef: tool2.schema.string().optional().describe("ID de sesión de opencode del nodo"),
-        errorClass: tool2.schema.enum(["transient", "permanent", "exhausted"]).optional().describe("Clase de error si el nodo falló")
-      })).optional().describe("Nodos de la ejecución (solo action=report-run)"),
-      parentSessionRef: tool2.schema.string().optional().describe("Sesión padre del run (solo action=report-run)")
-    },
-    async execute(args) {
-      if (args.action === "report-run") {
-        return handleReportRun(args, observe, deps.tracker);
-      }
-      const taskID = args.taskID ?? "";
-      if (args.action === "status") {
-        return describeDecision(decideIngress(deps.policy, taskID));
-      }
-      const ingress = deps.ingress;
-      if (ingress === undefined) {
-        return unavailableReason(deps, taskID);
-      }
-      if (args.action === "cancel") {
-        return describeOutcome(await ingress.cancel(args.runID ?? ""));
+async function readSessionEvents(dir, deps) {
+  const files = (await deps.storage.list(dir)).filter((file) => file.endsWith(".jsonl"));
+  const perFile = await Promise.all(files.map(async (file) => {
+    const text = await deps.storage.read(joinVirtualPath(dir, file));
+    return text === undefined ? [] : parseEventsJsonl(text);
+  }));
+  const events = perFile.flat();
+  if (deps.legacyTelemetryPath !== undefined) {
+    const legacyText = await deps.storage.read(deps.legacyTelemetryPath);
+    if (legacyText !== undefined) {
+      for (const record of parseCostRecordsJsonl(legacyText)) {
+        events.push(costRecordToRouteEvent(record));
       }
-      return describeOutcome(await ingress.start({
-        id: taskID,
-        implementerRoleID: "linus",
-        title: taskID,
-        brief: taskID,
-        task: {
-          promptChars: 0,
-          hasCode: false,
-          estimatedInputTokens: 0,
-          estimatedOutputTokens: 0
-        }
-      }));
     }
-  });
-  return { definition, observeLegacyExecution: observe };
-}
-async function handleReportRun(args, observe, tracker) {
-  const parsed = ReportRunPayloadSchema.safeParse({
-    runID: args.runID,
-    status: args.status,
-    fixes: args.fixes,
-    nodes: args.nodes,
-    ...args.parentSessionRef !== undefined ? { parentSessionRef: args.parentSessionRef } : {}
-  });
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
-    return formatResponse({
-      result: "ineligible",
-      detail: `validation: ${issues}`
-    });
   }
-  const verification = crossVerify(parsed.data, tracker);
-  const warnings = formatWarnings(verification);
-  const verificationPair = {
-    nodesChecked: parsed.data.nodes.length,
-    unverified: verification.unverifiedModels.length,
-    mismatched: verification.modelMismatches.length
-  };
-  const run = buildObservedRun(parsed.data);
-  try {
-    const result = await observe(run, verificationPair);
-    const base = { result: result.kind };
-    const detail = result.kind === "ineligible" ? result.reason : result.kind === "observation-rejected" ? result.reason : result.kind === "contained-failure" ? result.detail : null;
-    return formatResponse({
-      ...base,
-      ...detail !== null ? { detail } : {},
-      ...warnings.length > 0 ? { warnings } : {}
-    });
-  } catch (error) {
-    return formatResponse({
-      result: "contained-failure",
-      detail: error instanceof Error ? error.message : String(error)
-    });
+  return events.sort((a, b) => a.ts - b.ts);
+}
+
+// src/telemetry/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+function hashPrompt(prompt) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let index = 0;index < prompt.length; index += 1) {
+    hash ^= prompt.charCodeAt(index);
+    hash = Math.imul(hash, FNV_PRIME);
   }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
 
 // src/plugin/hooks.ts