opencode-agent-skill 10.0.0 → 12.0.0-beta.0

package/lib/context-engine-v11.mjs

@@ -0,0 +1,150 @@
+import { buildContextManifest } from "./context-manifest.mjs"
+import { planEvidenceBudget, evidenceValueScore } from "./evidence-budget.mjs"
+import { putEvidence } from "./evidence-store.mjs"
+import { inferTaskCapabilities } from "./capability-registry.mjs"
+import { buildPromptEnvelope, comparePromptEnvelopes } from "./prompt-cache.mjs"
+import { measureContextQuality } from "./context-quality.mjs"
+
+function taskText(task = {}) {
+  return [
+    task.title,
+    task.summary,
+    ...(task.acceptance || []),
+    ...(task.verification || []),
+  ].filter(Boolean).join(" ")
+}
+
+function rankExcerpt(item = {}, task = {}) {
+  const text = taskText(task).toLowerCase()
+  const pathValue = String(item.path || "").toLowerCase()
+  const declared = item.role === "declared" ? 1 : 0
+  const test = item.role === "test" ? 0.9 : 0
+  const instruction = item.role === "instruction" ? 0.85 : 0
+  const pathMatch = text && pathValue
+    ? text.split(/[^a-z0-9_$.-]+/i).filter((term) => term.length >= 4 && pathValue.includes(term.toLowerCase())).length
+    : 0
+  const relevance = Math.min(1, declared + test + instruction + pathMatch * 0.15)
+  return evidenceValueScore({
+    relevance,
+    freshness: 1,
+    confidence: item.role === "reference" ? 0.7 : 1,
+    chars: String(item.text || "").length || 1,
+  })
+}
+
+export async function externalizeContextExcerpts(root, manifest, options = {}) {
+  if (!manifest) return { manifest: null, externalized: [], externalizedBytes: 0 }
+  const threshold = Math.max(512, Number(options.threshold || 2_500))
+  const keepInline = Math.max(256, Number(options.inlineChars || 1_200))
+  const externalized = []
+  let externalizedBytes = 0
+  const excerpts = []
+
+  for (const item of manifest.excerpts || []) {
+    const text = String(item.text || "")
+    if (text.length <= threshold) {
+      excerpts.push(item)
+      continue
+    }
+
+    const stored = await putEvidence(root, text, {
+      kind: "context-excerpt",
+      source: item.path || null,
+      summary: `Externalized ${item.role || "reference"} context excerpt for ${item.path || "unknown"}`,
+    })
+    externalized.push({
+      ref: stored.ref,
+      path: item.path || null,
+      role: item.role || null,
+      bytes: stored.bytes,
+      score: Number(rankExcerpt(item, options.task).toFixed(8)),
+    })
+    externalizedBytes += stored.bytes
+    excerpts.push({
+      ...item,
+      text: text.slice(0, keepInline) + "\n...[externalized: " + stored.ref + "]",
+      evidenceRef: stored.ref,
+      originalChars: text.length,
+      externalized: true,
+    })
+  }
+
+  return {
+    manifest: {
+      ...manifest,
+      schemaVersion: Math.max(5, Number(manifest.schemaVersion || 0)),
+      excerpts,
+      evidencePointers: externalized,
+    },
+    externalized,
+    externalizedBytes,
+  }
+}
+
+export async function buildAdaptiveTaskContext(root, task, options = {}) {
+  const policy = options.policy || {}
+  const capabilities = options.capabilities || inferTaskCapabilities(taskText(task), options.facts || {})
+  const evidenceBudget = options.evidenceBudget || planEvidenceBudget(policy, task, capabilities.required)
+  const manifest = await buildContextManifest(root, task, {
+    budget: evidenceBudget.total,
+    evidenceBudget,
+    strategy: options.strategy || policy?.profile?.contextStrategy || "incremental-semantic+git",
+    semanticMaxFiles: options.semanticMaxFiles,
+    maxFiles: options.maxFiles,
+  })
+
+  const externalized = await externalizeContextExcerpts(root, manifest, {
+    task,
+    threshold: options.externalizeThreshold,
+    inlineChars: options.inlineChars,
+  })
+
+  const promptEnvelope = buildPromptEnvelope({
+    invariants: options.invariants || "evidence-first; scoped edits; fresh verification; no unsupported completion claims",
+    role: options.role || "executor",
+    skills: options.skills || policy.domains || [],
+    projectFacts: {
+      strategy: externalized.manifest?.strategy || null,
+      instructions: externalized.manifest?.instructions || [],
+      ...(options.projectFacts || {}),
+    },
+    task,
+    evidence: [
+      ...(externalized.externalized || []).map((item) => item.ref),
+      ...(externalized.manifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
+      ...(options.evidence || []),
+    ],
+    recentFailure: options.recentFailure || null,
+    nextAction: options.nextAction || null,
+    recentMessages: options.recentMessages || [],
+  })
+
+  const contextQuality = measureContextQuality(task, externalized.manifest, { minRequiredRecall: options.minRequiredRecall })
+
+  const cache = options.previousPromptEnvelope
+    ? comparePromptEnvelopes(options.previousPromptEnvelope, promptEnvelope)
+    : null
+
+  return {
+    schemaVersion: 1,
+    contextSchemaVersion: 6,
+    capabilities,
+    evidenceBudget,
+    contextManifest: externalized.manifest,
+    contextQuality,
+    evidenceStore: {
+      refs: externalized.externalized.length,
+      externalizedBytes: externalized.externalizedBytes,
+      entries: externalized.externalized,
+    },
+    promptEnvelope,
+    promptCache: {
+      stablePrefixHash: promptEnvelope.stablePrefixHash,
+      dynamicHash: promptEnvelope.dynamicHash,
+      stableChars: promptEnvelope.stableChars,
+      dynamicChars: promptEnvelope.dynamicChars,
+      cacheableRatio: promptEnvelope.cacheableRatio,
+      ...(cache || {}),
+    },
+  }
+}

package/lib/context-manifest.mjs

@@ -243,7 +243,8 @@ async function rankedReferences(root, nodes, terms, declared, changed, limit = 2
 
 export async function buildContextManifest(root, task, options = {}) {
   root = path.resolve(root)
-  const budget = Math.max(4_000, Number(options.budget ?? 24_000))
+  const budget = Math.max(4_000, Number(options.evidenceBudget?.total ?? options.budget ?? 24_000))
+  const evidenceBudget = options.evidenceBudget || null
   const declared = taskFiles(task)
   const terms = taskTerms(task)
   const changed = gitChangedFiles(root)
@@ -331,20 +332,30 @@ export async function buildContextManifest(root, task, options = {}) {
   }
 
   let remaining = budget
+  const categoryRemaining = {
+    declared: evidenceBudget?.buckets?.declared ?? Math.round(budget * 0.42),
+    test: evidenceBudget?.buckets?.tests ?? Math.round(budget * 0.20),
+    instruction: evidenceBudget?.buckets?.instructions ?? Math.round(budget * 0.12),
+    reference: evidenceBudget?.buckets?.references ?? Math.round(budget * 0.26),
+  }
   const excerpts = []
   for (const file of priority) {
     if (remaining <= 0) break
     const isDeclared = declared.includes(file)
     const isTest = tests.includes(file)
     const isInstruction = instructions.includes(file)
+    const role = isDeclared ? "declared" : isTest ? "test" : isInstruction ? "instruction" : "reference"
     const desired = isDeclared ? 6_000 : isTest ? 4_000 : isInstruction ? 3_000 : 2_500
-    const perFile = Math.min(desired, remaining)
+    const category = Math.max(0, Number(categoryRemaining[role] || 0))
+    if (category <= 0) continue
+    const perFile = Math.min(desired, remaining, category)
     const item = await excerpt(root, file, perFile, terms)
     if (!item) continue
     remaining -= item.text.length
+    categoryRemaining[role] = Math.max(0, categoryRemaining[role] - item.text.length)
     excerpts.push({
       ...item,
-      role: isDeclared ? "declared" : isTest ? "test" : isInstruction ? "instruction" : "reference",
+      role,
     })
   }
 
@@ -373,6 +384,8 @@ export async function buildContextManifest(root, task, options = {}) {
       hotspots: graph.hotspots.slice(0, 12),
     },
     budget,
+    evidenceBudget,
+    categoryRemaining,
     used: budget - remaining,
   }
 }

package/lib/context-quality.mjs

@@ -0,0 +1,59 @@
+function normalizePath(value) {
+  return String(value || "").replaceAll("\\", "/").replace(/^\.\//, "")
+}
+
+function declaredTaskFiles(task = {}) {
+  const files = task.files
+  const values = []
+  if (Array.isArray(files)) values.push(...files)
+  else if (files && typeof files === "object") {
+    for (const [kind, list] of Object.entries(files)) {
+      if (kind === "create") continue
+      if (Array.isArray(list)) values.push(...list)
+      else if (typeof list === "string") values.push(list)
+    }
+  }
+  if (Array.isArray(task.requiredFiles)) values.push(...task.requiredFiles)
+  return [...new Set(values.map(normalizePath).filter(Boolean))]
+}
+
+function manifestPaths(manifest = {}) {
+  const values = []
+  for (const item of manifest.excerpts || []) if (item?.path) values.push(item.path)
+  for (const item of manifest.rankedReferences || []) if (item?.path) values.push(item.path)
+  for (const item of manifest.instructions || []) {
+    if (typeof item === "string") values.push(item)
+    else if (item?.path) values.push(item.path)
+  }
+  return [...new Set(values.map(normalizePath).filter(Boolean))]
+}
+
+export function measureContextQuality(task = {}, manifest = {}, options = {}) {
+  const required = declaredTaskFiles(task)
+  const included = manifestPaths(manifest)
+  const includedSet = new Set(included)
+  const hits = required.filter((file) => includedSet.has(file))
+  const requiredFileRecall = required.length ? hits.length / required.length : null
+  const relevant = new Set(required)
+  for (const item of manifest.instructions || []) {
+    if (typeof item === "string") relevant.add(normalizePath(item))
+    else if (item?.path) relevant.add(normalizePath(item.path))
+  }
+  for (const item of manifest.excerpts || []) {
+    if (["declared", "test", "instruction"].includes(item?.role) && item?.path) relevant.add(normalizePath(item.path))
+  }
+  const irrelevant = included.filter((file) => !relevant.has(file))
+  const irrelevantRatio = included.length ? irrelevant.length / included.length : 0
+  const minRequiredRecall = Number.isFinite(Number(options.minRequiredRecall))
+    ? Math.max(0, Math.min(1, Number(options.minRequiredRecall))) : 1
+  return {
+    schemaVersion: 1,
+    requiredFiles: required,
+    includedFiles: included,
+    requiredFileHits: hits,
+    requiredFileRecall,
+    irrelevantFiles: irrelevant,
+    irrelevantRatio,
+    checks: { requiredRecallAcceptable: requiredFileRecall == null ? true : requiredFileRecall >= minRequiredRecall },
+  }
+}

package/lib/control-center.mjs

@@ -3,6 +3,7 @@ import { mkdir, readFile, readdir, writeFile } from "node:fs/promises"
 import path from "node:path"
 import { readLearningState } from "./learning-engine.mjs"
 import { readRuntimeEvents } from "./runtime-events.mjs"
+import { evidenceStoreStatus } from "./evidence-store.mjs"
 
 function escapeHtml(value) {
   return String(value ?? "")
@@ -64,18 +65,23 @@ async function collectEvalSummary(root) {
 
 export async function collectControlCenterData(root = process.cwd()) {
   root = path.resolve(root)
-  const [work, learning, evals] = await Promise.all([
+  const [work, learning, evals, evidenceStore] = await Promise.all([
     collectWork(root),
     readLearningState(root),
     collectEvalSummary(root),
+    evidenceStoreStatus(root),
   ])
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     generatedAt: new Date().toISOString(),
     root,
     work,
     learning,
     evals,
+    v11: {
+      evidenceStore,
+      runtime: "perception-adaptive-execution",
+    },
   }
 }
 
@@ -103,6 +109,7 @@ details{margin-top:10px;border-top:1px solid #243049;padding-top:8px}summary{cur
 <div class="top"><div><h1>UES Control Center</h1><div class="muted" id="root"></div></div><div class="muted" id="generated"></div></div>
 <div class="section"><h2>Long-horizon work</h2><div class="grid" id="work"></div></div>
 <div class="section"><h2>Learning loop</h2><div class="grid" id="learning"></div></div>
+<div class="section"><h2>V11 runtime efficiency</h2><div class="grid" id="v11"></div></div>
 <div class="section"><h2>Recent runtime events</h2><div class="card"><table><thead><tr><th>Work</th><th>Event</th><th>Task</th><th>Time</th></tr></thead><tbody id="events"></tbody></table></div></div>
 <div class="section"><h2>Recent evaluations</h2><div class="card"><table><thead><tr><th>Suite</th><th>Model</th><th>Baseline</th><th>UES</th></tr></thead><tbody id="evals"></tbody></table></div></div>
 </div>
@@ -126,6 +133,9 @@ function render(next){
  if(!data.work.length) work.innerHTML='<div class="card muted">No .ues-work items found.</div>';
  const learning=document.querySelector("#learning");
  learning.innerHTML='<div class="card"><h3>Accepted lessons</h3><strong>'+data.learning.accepted.length+'</strong></div><div class="card"><h3>Proposals</h3><strong>'+data.learning.proposals.length+'</strong></div>';
+ const v11=document.querySelector("#v11");
+ const store=data.v11?.evidenceStore||{};
+ v11.innerHTML='<div class="card"><h3>Evidence store</h3><strong>'+esc(store.entries||0)+'</strong><div class="muted">'+esc(store.bytes||0)+' bytes externalized</div></div><div class="card"><h3>Runtime</h3><strong>V11</strong><div class="muted">'+esc(data.v11?.runtime||'adaptive')+'</div></div>';
  const eventBody=document.querySelector("#events");
  eventBody.innerHTML="";
  for(const item of data.work){

package/lib/decision-policy.mjs

@@ -0,0 +1,23 @@
+const HIGH_RISK = /(npm publish|publish package|deploy|production|git push|force push|reset --hard|git clean|delete branch|drop table|truncate|rotate secret|credential|api key|purchase|payment|irreversible|public api break)/i
+const MEDIUM_RISK = /(migration|schema|dependency upgrade|lockfile|generated code|shared config|auth|permission|security)/i
+const REVERSIBLE = /(local|test|rename|format|refactor|temporary|fixture|internal|reversible)/i
+
+export function classifyDecisionPolicy(text = "", facts = {}) {
+  const value = String(text || "").trim()
+  const explicitlyIrreversible = facts.irreversible === true
+  const externalSideEffect = facts.externalSideEffect === true
+  const destructive = facts.destructive === true || HIGH_RISK.test(value)
+  const medium = MEDIUM_RISK.test(value)
+  const reversible = facts.reversible === true || (!destructive && REVERSIBLE.test(value))
+  const risk = destructive || explicitlyIrreversible || externalSideEffect ? "high" : medium ? "medium" : "low"
+  const requiresUser = risk === "high" || facts.productDecision === true
+  return {
+    schemaVersion: 1, risk, reversible, destructive, externalSideEffect, requiresUser,
+    autoResolvable: !requiresUser && (reversible || risk === "low"),
+    reason: requiresUser ? "human-approval-required" : reversible ? "reversible-local-decision" : "bounded-engineering-decision",
+  }
+}
+
+export function canAutoResolveDecision(text = "", facts = {}) {
+  return classifyDecisionPolicy(text, facts).autoResolvable
+}

package/lib/dynamic-workflow.mjs

@@ -0,0 +1,179 @@
+function taskFiles(task = {}) {
+  if (Array.isArray(task.files)) return task.files
+  const files = task.files && typeof task.files === "object" ? task.files : {}
+  return [...new Set(["create","modify","test","delete"].flatMap((key) => Array.isArray(files[key]) ? files[key] : []))]
+}
+
+function writes(task = {}) {
+  const files = task.files && typeof task.files === "object" && !Array.isArray(task.files) ? task.files : null
+  if (!files) return Array.isArray(task.files) && task.files.length > 0
+  return ["create","modify","delete"].some((key) => Array.isArray(files[key]) && files[key].length > 0)
+}
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.round(parsed)))
+}
+
+export function classifyWorkflowTask(task = {}) {
+  const text = [task.title, task.summary, ...(task.acceptance || [])].filter(Boolean).join(" ").toLowerCase()
+  const visual = /(visual|screenshot|pixel|figma|layout|giao diện|ảnh mẫu|image reference)/.test(text)
+  const deterministic = task.deterministic === true || /(run test|typecheck|lint|format|generate manifest|build index|verify command|compile|unit test)/.test(text)
+  const kind = deterministic ? "deterministic" : visual ? "vision" : "llm"
+  const fileCount = taskFiles(task).length
+  const acceptanceCount = Array.isArray(task.acceptance) ? task.acceptance.length : 0
+  const verificationCount = Array.isArray(task.verification) ? task.verification.length : 0
+  const estimatedCost = kind === "deterministic"
+    ? 1
+    : Math.max(
+        2,
+        Math.min(
+          12,
+          2 + fileCount + Math.min(3, acceptanceCount) + Math.min(2, verificationCount) + (task.risk === "high" ? 3 : 0),
+        ),
+      )
+  return {
+    kind,
+    estimatedCost,
+    writes: writes(task),
+    files: taskFiles(task),
+    risk: task.risk || "medium",
+  }
+}
+
+function conflict(a, b) {
+  if (!a.writes && !b.writes) return false
+  const aa = new Set(a.files)
+  return b.files.some((file) => aa.has(file))
+}
+
+function executionMode(classification, options) {
+  if (classification.kind === "deterministic") return "deterministic"
+  if (classification.kind === "vision") {
+    return classification.estimatedCost >= options.minVisionAgentCost ? "agent" : "inline"
+  }
+  return classification.estimatedCost >= options.minAgentCost ? "agent" : "inline"
+}
+
+function kindCapacity(selected, classification, options) {
+  if (classification.kind === "vision") {
+    return selected.filter((item) => item.classification.kind === "vision" && item.execution === "agent").length < options.maxVisionConcurrent
+  }
+  if (classification.kind === "llm") {
+    return selected.filter((item) => item.classification.kind === "llm" && item.execution === "agent").length < options.maxLLMConcurrent
+  }
+  return true
+}
+
+function readyTasks(remaining, byID, complete) {
+  return [...remaining]
+    .map((id) => byID.get(id))
+    .filter((task) => (task.dependsOn || task.dependencies || []).every((dep) => complete.has(dep)))
+}
+
+export function planDynamicWorkflow(tasks = [], inputOptions = {}) {
+  const options = {
+    maxConcurrent: clampInt(inputOptions.maxConcurrent, 4, 1, 16),
+    maxLLMConcurrent: clampInt(inputOptions.maxLLMConcurrent, inputOptions.maxConcurrent || 4, 1, 16),
+    maxVisionConcurrent: clampInt(inputOptions.maxVisionConcurrent, 2, 1, 8),
+    maxWaveCost: clampInt(inputOptions.maxWaveCost, 24, 1, 128),
+    minAgentCost: clampInt(inputOptions.minAgentCost, 5, 2, 12),
+    minVisionAgentCost: clampInt(inputOptions.minVisionAgentCost, 4, 2, 12),
+    deterministicFirst: inputOptions.deterministicFirst !== false,
+  }
+
+  const byID = new Map(tasks.map((task) => [task.id, task]))
+  if (byID.size !== tasks.length || tasks.some((task) => !task?.id)) {
+    throw new Error("Workflow tasks require unique non-empty ids")
+  }
+  for (const task of tasks) {
+    for (const dep of task.dependsOn || task.dependencies || []) {
+      if (!byID.has(dep)) throw new Error("Workflow contains a missing dependency: " + dep)
+    }
+  }
+
+  const remaining = new Set(tasks.map((task) => task.id))
+  const complete = new Set()
+  const waves = []
+  let waveIndex = 0
+
+  while (remaining.size) {
+    const ready = readyTasks(remaining, byID, complete)
+    if (!ready.length) throw new Error("Workflow contains a dependency cycle or missing dependency")
+
+    const deterministicReady = ready.filter((task) => classifyWorkflowTask(task).kind === "deterministic")
+    const candidates = options.deterministicFirst && deterministicReady.length
+      ? deterministicReady
+      : ready
+
+    const classified = candidates
+      .map((task) => {
+        const classification = classifyWorkflowTask(task)
+        return { task, classification, execution: executionMode(classification, options) }
+      })
+      .sort((a, b) => {
+        const order = { deterministic: 0, inline: 1, agent: 2 }
+        return order[a.execution] - order[b.execution] ||
+          a.classification.estimatedCost - b.classification.estimatedCost ||
+          a.task.id.localeCompare(b.task.id)
+      })
+
+    const selected = []
+    let waveCost = 0
+    for (const item of classified) {
+      if (selected.length >= options.maxConcurrent) break
+      if (selected.some((existing) => conflict(item.classification, existing.classification))) continue
+      if (!kindCapacity(selected, item.classification, options)) continue
+      if (selected.length && waveCost + item.classification.estimatedCost > options.maxWaveCost) continue
+      selected.push(item)
+      waveCost += item.classification.estimatedCost
+    }
+
+    if (!selected.length) selected.push(classified[0])
+
+    const tasksInWave = selected.map(({ task, classification, execution }) => ({
+      id: task.id,
+      kind: classification.kind,
+      execution,
+      estimatedCost: classification.estimatedCost,
+      writes: classification.writes,
+      files: classification.files,
+      spawnAgent: execution === "agent",
+      rationale:
+        execution === "deterministic"
+          ? "deterministic tool/script work should not consume an agent slot"
+          : execution === "inline"
+            ? "coordination cost exceeds expected benefit for this bounded unit"
+            : classification.kind === "vision"
+              ? "visual judgment requires a bounded vision worker"
+              : "independent task size justifies isolated agent execution",
+    }))
+
+    waves.push({
+      index: waveIndex++,
+      tasks: tasksInWave,
+      totalEstimatedCost: tasksInWave.reduce((sum, item) => sum + item.estimatedCost, 0),
+      agentSlots: tasksInWave.filter((item) => item.spawnAgent).length,
+      visionAgentSlots: tasksInWave.filter((item) => item.spawnAgent && item.kind === "vision").length,
+    })
+
+    for (const { task } of selected) {
+      remaining.delete(task.id)
+      complete.add(task.id)
+    }
+  }
+
+  const flat = waves.flatMap((wave) => wave.tasks)
+  return {
+    schemaVersion: 2,
+    options,
+    waves,
+    taskCount: tasks.length,
+    agentTaskCount: flat.filter((task) => task.spawnAgent).length,
+    inlineTaskCount: flat.filter((task) => task.execution === "inline").length,
+    deterministicTaskCount: flat.filter((task) => task.execution === "deterministic").length,
+    visionAgentTaskCount: flat.filter((task) => task.spawnAgent && task.kind === "vision").length,
+    estimatedCoordinationSaved: flat.filter((task) => task.execution !== "agent").reduce((sum, task) => sum + task.estimatedCost, 0),
+  }
+}

package/lib/eval-ablation.mjs

@@ -27,6 +27,9 @@ export function compareEvalSummaries(reference, candidate, options = {}) {
   const minInitialInputReduction = Math.max(0, Number(options.minInitialInputReduction ?? 0.10))
   const maxTotalTokenRatio = Math.max(0.01, Number(options.maxTotalTokenRatio || 1.05))
   const maxDurationRatio = Math.max(0.01, Number(options.maxDurationRatio || 1.10))
+  const minCacheableRatio = options.minCacheableRatio == null ? null : Math.max(0, Math.min(1, Number(options.minCacheableRatio)))
+  const minEvidenceReuseRatio = options.minEvidenceReuseRatio == null ? null : Math.max(0, Math.min(1, Number(options.minEvidenceReuseRatio)))
+  const maxRepeatedStableRatio = options.maxRepeatedStableRatio == null ? null : Math.max(0, Number(options.maxRepeatedStableRatio))
 
   const referencePassRate = finite(ref.passRate)
   const candidatePassRate = finite(next.passRate)
@@ -36,6 +39,13 @@ export function compareEvalSummaries(reference, candidate, options = {}) {
   const candidateTokens = finite(next.avgTokens)
   const referenceDuration = finite(ref.avgDurationMs)
   const candidateDuration = finite(next.avgDurationMs)
+  const referenceCacheableRatio = finite(ref.avgCacheableRatio)
+  const candidateCacheableRatio = finite(next.avgCacheableRatio)
+  const referenceEvidenceReuseRatio = finite(ref.avgEvidenceReuseRatio)
+  const candidateEvidenceReuseRatio = finite(next.avgEvidenceReuseRatio)
+  const candidateRepeatedStableChars = finite(next.avgRepeatedStableChars)
+  const referenceRepeatedStableRatio = finite(ref.avgRepeatedStableRatio)
+  const candidateRepeatedStableRatio = finite(next.avgRepeatedStableRatio)
 
   const initialInputRatio = ratio(candidateInitialInput, referenceInitialInput)
   const tokenRatio = ratio(candidateTokens, referenceTokens)
@@ -54,6 +64,18 @@ export function compareEvalSummaries(reference, candidate, options = {}) {
       tokenRatio == null ? null : tokenRatio <= maxTotalTokenRatio,
     durationBounded:
       durationRatio == null ? null : durationRatio <= maxDurationRatio,
+    cacheableRatioTarget:
+      minCacheableRatio == null ? null :
+      candidateCacheableRatio == null ? false :
+      candidateCacheableRatio >= minCacheableRatio,
+    evidenceReuseTarget:
+      minEvidenceReuseRatio == null ? null :
+      candidateEvidenceReuseRatio == null ? false :
+      candidateEvidenceReuseRatio >= minEvidenceReuseRatio,
+    repeatedStableTarget:
+      maxRepeatedStableRatio == null ? null :
+      candidateRepeatedStableRatio == null ? false :
+      candidateRepeatedStableRatio <= maxRepeatedStableRatio,
   }
 
   const efficiencyEvidence = [
@@ -70,24 +92,37 @@ export function compareEvalSummaries(reference, candidate, options = {}) {
       minInitialInputReduction,
       maxTotalTokenRatio,
       maxDurationRatio,
+      minCacheableRatio,
+      minEvidenceReuseRatio,
+      maxRepeatedStableRatio,
     },
     reference: {
       passRate: referencePassRate,
       avgInitialInputTokens: referenceInitialInput,
       avgTokens: referenceTokens,
       avgDurationMs: referenceDuration,
+      avgCacheableRatio: referenceCacheableRatio,
+      avgEvidenceReuseRatio: referenceEvidenceReuseRatio,
+      avgRepeatedStableRatio: referenceRepeatedStableRatio,
     },
     candidate: {
       passRate: candidatePassRate,
       avgInitialInputTokens: candidateInitialInput,
       avgTokens: candidateTokens,
       avgDurationMs: candidateDuration,
+      avgCacheableRatio: candidateCacheableRatio,
+      avgEvidenceReuseRatio: candidateEvidenceReuseRatio,
+      avgRepeatedStableChars: candidateRepeatedStableChars,
+      avgRepeatedStableRatio: candidateRepeatedStableRatio,
     },
     delta: {
       passRate: delta(candidatePassRate, referencePassRate),
       avgInitialInputTokens: delta(candidateInitialInput, referenceInitialInput),
       avgTokens: delta(candidateTokens, referenceTokens),
       avgDurationMs: delta(candidateDuration, referenceDuration),
+      avgCacheableRatio: delta(candidateCacheableRatio, referenceCacheableRatio),
+      avgEvidenceReuseRatio: delta(candidateEvidenceReuseRatio, referenceEvidenceReuseRatio),
+      avgRepeatedStableRatio: delta(candidateRepeatedStableRatio, referenceRepeatedStableRatio),
     },
     ratios: {
       initialInput: initialInputRatio,
@@ -96,9 +131,16 @@ export function compareEvalSummaries(reference, candidate, options = {}) {
     },
     checks,
     telemetrySufficient: checks.initialInputReduced !== null,
+    optionalTargetsSatisfied:
+      (checks.cacheableRatioTarget == null || checks.cacheableRatioTarget === true) &&
+      (checks.evidenceReuseTarget == null || checks.evidenceReuseTarget === true) &&
+      (checks.repeatedStableTarget == null || checks.repeatedStableTarget === true),
     gateEligible:
       checks.passRatePreserved === true &&
       checks.initialInputReduced === true &&
-      efficiencyEvidence.every((value) => value === true),
+      efficiencyEvidence.every((value) => value === true) &&
+      (checks.cacheableRatioTarget == null || checks.cacheableRatioTarget === true) &&
+      (checks.evidenceReuseTarget == null || checks.evidenceReuseTarget === true) &&
+      (checks.repeatedStableTarget == null || checks.repeatedStableTarget === true),
   }
 }