opencode-agent-skill 9.0.0 → 11.0.0

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/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

@@ -0,0 +1,146 @@
+function finite(value) {
+  if (value === null || value === undefined || value === "") return null
+  const number = Number(value)
+  return Number.isFinite(number) ? number : null
+}
+
+function modeSummary(value) {
+  return value?.summary?.modes?.ues || value?.modes?.ues || null
+}
+
+function ratio(candidate, reference) {
+  return candidate != null && reference != null && reference > 0
+    ? candidate / reference
+    : null
+}
+
+function delta(candidate, reference) {
+  return candidate != null && reference != null ? candidate - reference : null
+}
+
+export function compareEvalSummaries(reference, candidate, options = {}) {
+  const ref = modeSummary(reference)
+  const next = modeSummary(candidate)
+  if (!ref || !next) throw new Error("reference and candidate must contain a UES mode summary")
+
+  const passRateTolerance = Math.max(0, Number(options.passRateTolerance || 0))
+  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)
+  const referenceInitialInput = finite(ref.avgInitialInputTokens)
+  const candidateInitialInput = finite(next.avgInitialInputTokens)
+  const referenceTokens = finite(ref.avgTokens)
+  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)
+  const durationRatio = ratio(candidateDuration, referenceDuration)
+
+  const checks = {
+    passRatePreserved:
+      referencePassRate != null &&
+      candidatePassRate != null &&
+      candidatePassRate >= referencePassRate - passRateTolerance,
+    initialInputReduced:
+      initialInputRatio == null
+        ? null
+        : initialInputRatio <= 1 - minInitialInputReduction,
+    totalTokensBounded:
+      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 = [
+    checks.initialInputReduced,
+    checks.totalTokensBounded,
+    checks.durationBounded,
+  ].filter((value) => value !== null)
+
+  return {
+    schemaVersion: 1,
+    kind: "ues-eval-ablation",
+    thresholds: {
+      passRateTolerance,
+      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,
+      totalTokens: tokenRatio,
+      duration: durationRatio,
+    },
+    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) &&
+      (checks.cacheableRatioTarget == null || checks.cacheableRatioTarget === true) &&
+      (checks.evidenceReuseTarget == null || checks.evidenceReuseTarget === true) &&
+      (checks.repeatedStableTarget == null || checks.repeatedStableTarget === true),
+  }
+}

package/lib/eval-report.mjs

@@ -10,8 +10,24 @@ export function summarizeEvalResults(results) {
       toolSamples: 0,
       tokens: 0,
       tokenSamples: 0,
+      initialInputTokens: 0,
+      initialInputSamples: 0,
       cost: 0,
       costSamples: 0,
+      cacheableRatio: 0,
+      cacheableRatioSamples: 0,
+      repeatedStableChars: 0,
+      repeatedStableSamples: 0,
+      repeatedStableRatio: 0,
+      repeatedStableRatioSamples: 0,
+      evidenceReuseRatio: 0,
+      evidenceReuseSamples: 0,
+      visualRepairAttempts: 0,
+      visualRepairSamples: 0,
+      contextExpansions: 0,
+      contextExpansionSamples: 0,
+      modelEscalations: 0,
+      modelEscalationSamples: 0,
     }
     bucket.total += 1
     if (item.passed) bucket.passed += 1
@@ -25,10 +41,45 @@ export function summarizeEvalResults(results) {
       bucket.tokens += Number(item.telemetry?.tokens?.total) || 0
       bucket.tokenSamples += 1
     }
+    const initialInput = Number(item.telemetry?.firstUsage?.input)
+    if (Number.isFinite(initialInput)) {
+      bucket.initialInputTokens += initialInput
+      bucket.initialInputSamples += 1
+    }
     if ((item.telemetry?.costSamples || 0) > 0) {
       bucket.cost += Number(item.telemetry?.cost) || 0
       bucket.costSamples += 1
     }
+
+    const v11 = item.telemetry?.v11 || {}
+    if (Number.isFinite(Number(v11.avgCacheableRatio))) {
+      bucket.cacheableRatio += Number(v11.avgCacheableRatio)
+      bucket.cacheableRatioSamples += 1
+    }
+    if (Number.isFinite(Number(v11.repeatedStableChars))) {
+      bucket.repeatedStableChars += Number(v11.repeatedStableChars)
+      bucket.repeatedStableSamples += 1
+    }
+    if (Number.isFinite(Number(v11.repeatedStableRatio))) {
+      bucket.repeatedStableRatio += Number(v11.repeatedStableRatio)
+      bucket.repeatedStableRatioSamples += 1
+    }
+    if (Number.isFinite(Number(v11.evidenceReuseRatio))) {
+      bucket.evidenceReuseRatio += Number(v11.evidenceReuseRatio)
+      bucket.evidenceReuseSamples += 1
+    }
+    if (Number.isFinite(Number(v11.visualRepairAttempts))) {
+      bucket.visualRepairAttempts += Number(v11.visualRepairAttempts)
+      bucket.visualRepairSamples += 1
+    }
+    if (Number.isFinite(Number(v11.contextExpansions))) {
+      bucket.contextExpansions += Number(v11.contextExpansions)
+      bucket.contextExpansionSamples += 1
+    }
+    if (Number.isFinite(Number(v11.modelEscalations))) {
+      bucket.modelEscalations += Number(v11.modelEscalations)
+      bucket.modelEscalationSamples += 1
+    }
   }
 
   for (const bucket of Object.values(modes)) {
@@ -36,19 +87,51 @@ export function summarizeEvalResults(results) {
     bucket.avgDurationMs = bucket.total ? bucket.durationMs / bucket.total : 0
     bucket.avgToolCalls = bucket.toolSamples ? bucket.toolCalls / bucket.toolSamples : null
     bucket.avgTokens = bucket.tokenSamples ? bucket.tokens / bucket.tokenSamples : null
+    bucket.avgInitialInputTokens = bucket.initialInputSamples ? bucket.initialInputTokens / bucket.initialInputSamples : null
     bucket.avgCost = bucket.costSamples ? bucket.cost / bucket.costSamples : null
+    bucket.avgCacheableRatio = bucket.cacheableRatioSamples ? bucket.cacheableRatio / bucket.cacheableRatioSamples : null
+    bucket.avgRepeatedStableChars = bucket.repeatedStableSamples ? bucket.repeatedStableChars / bucket.repeatedStableSamples : null
+    bucket.avgRepeatedStableRatio = bucket.repeatedStableRatioSamples ? bucket.repeatedStableRatio / bucket.repeatedStableRatioSamples : null
+    bucket.avgEvidenceReuseRatio = bucket.evidenceReuseSamples ? bucket.evidenceReuseRatio / bucket.evidenceReuseSamples : null
+    bucket.avgVisualRepairAttempts = bucket.visualRepairSamples ? bucket.visualRepairAttempts / bucket.visualRepairSamples : null
+    bucket.avgContextExpansions = bucket.contextExpansionSamples ? bucket.contextExpansions / bucket.contextExpansionSamples : null
+    bucket.avgModelEscalations = bucket.modelEscalationSamples ? bucket.modelEscalations / bucket.modelEscalationSamples : null
     bucket.telemetryCoverage = {
       tools: bucket.total ? bucket.toolSamples / bucket.total : 0,
       tokens: bucket.total ? bucket.tokenSamples / bucket.total : 0,
+      initialInputTokens: bucket.total ? bucket.initialInputSamples / bucket.total : 0,
       cost: bucket.total ? bucket.costSamples / bucket.total : 0,
+      cacheableRatio: bucket.total ? bucket.cacheableRatioSamples / bucket.total : 0,
+      repeatedStableChars: bucket.total ? bucket.repeatedStableSamples / bucket.total : 0,
+      repeatedStableRatio: bucket.total ? bucket.repeatedStableRatioSamples / bucket.total : 0,
+      evidenceReuseRatio: bucket.total ? bucket.evidenceReuseSamples / bucket.total : 0,
+      visualRepairAttempts: bucket.total ? bucket.visualRepairSamples / bucket.total : 0,
+      contextExpansions: bucket.total ? bucket.contextExpansionSamples / bucket.total : 0,
+      modelEscalations: bucket.total ? bucket.modelEscalationSamples / bucket.total : 0,
     }
     delete bucket.durationMs
     delete bucket.toolCalls
     delete bucket.toolSamples
     delete bucket.tokens
     delete bucket.tokenSamples
+    delete bucket.initialInputTokens
+    delete bucket.initialInputSamples
     delete bucket.cost
     delete bucket.costSamples
+    delete bucket.cacheableRatio
+    delete bucket.cacheableRatioSamples
+    delete bucket.repeatedStableChars
+    delete bucket.repeatedStableSamples
+    delete bucket.repeatedStableRatio
+    delete bucket.repeatedStableRatioSamples
+    delete bucket.evidenceReuseRatio
+    delete bucket.evidenceReuseSamples
+    delete bucket.visualRepairAttempts
+    delete bucket.visualRepairSamples
+    delete bucket.contextExpansions
+    delete bucket.contextExpansionSamples
+    delete bucket.modelEscalations
+    delete bucket.modelEscalationSamples
   }
 
   const byTaskMap = new Map()

package/lib/eval-telemetry.mjs

@@ -92,6 +92,19 @@ export function parseOpenCodeTelemetry(stdout) {
   let cost = 0
   let usageSamples = 0
   let costSamples = 0
+  let firstUsage = null
+  const v11 = {
+    promptCacheSamples: 0,
+    cacheableRatioSum: 0,
+    stableChars: 0,
+    dynamicChars: 0,
+    repeatedStableChars: 0,
+    evidenceRefs: new Set(),
+    evidenceRefOccurrences: 0,
+    visualRepairAttempts: 0,
+    contextExpansions: 0,
+    modelEscalations: 0,
+  }
 
   parsed.forEach((event, eventIndex) => {
     let eventUsage = null
@@ -119,6 +132,39 @@ export function parseOpenCodeTelemetry(stdout) {
       }
 
       if (!eventUsage) eventUsage = usageFromObject(object)
+
+      const promptCache = object.promptCache && typeof object.promptCache === "object" ? object.promptCache : null
+      if (promptCache) {
+        const ratio = Number(promptCache.cacheableRatio)
+        if (Number.isFinite(ratio)) {
+          v11.promptCacheSamples += 1
+          v11.cacheableRatioSum += ratio
+        }
+        const stableChars = Number(promptCache.stableChars)
+        if (Number.isFinite(stableChars) && stableChars >= 0) v11.stableChars += stableChars
+        const dynamicChars = Number(promptCache.dynamicChars)
+        if (Number.isFinite(dynamicChars) && dynamicChars >= 0) v11.dynamicChars += dynamicChars
+        const repeated = Number(promptCache.repeatedStableChars)
+        if (Number.isFinite(repeated) && repeated >= 0) v11.repeatedStableChars += repeated
+      }
+
+      const scanRefs = (value) => {
+        if (typeof value === "string" && /^evidence:sha256:[a-f0-9]{64}$/i.test(value)) {
+          v11.evidenceRefOccurrences += 1
+          v11.evidenceRefs.add(value.toLowerCase())
+        } else if (Array.isArray(value)) {
+          for (const item of value) scanRefs(item)
+        } else if (value && typeof value === "object") {
+          for (const child of Object.values(value)) scanRefs(child)
+        }
+      }
+      scanRefs(object.evidencePointers)
+      scanRefs(object.evidence)
+
+      const eventName = String(object.type || object.event || object.kind || "").toLowerCase()
+      if (eventName.includes("visual") && eventName.includes("repair")) v11.visualRepairAttempts += 1
+      if (eventName.includes("context") && (eventName.includes("expand") || eventName.includes("recovery"))) v11.contextExpansions += 1
+      if (eventName.includes("model") && eventName.includes("escalat")) v11.modelEscalations += 1
       if (eventCost === null) {
         for (const key of ["cost", "totalCost", "total_cost"]) {
           if (typeof object[key] === "number" && Number.isFinite(object[key])) {
@@ -130,6 +176,7 @@ export function parseOpenCodeTelemetry(stdout) {
     })
 
     if (eventUsage) {
+      if (!firstUsage && eventUsage.input > 0) firstUsage = { ...eventUsage }
       usageSamples += 1
       tokens.input += eventUsage.input
       tokens.output += eventUsage.output
@@ -151,8 +198,25 @@ export function parseOpenCodeTelemetry(stdout) {
     skillsLoaded: [...skills].sort(),
     subagents: [...subagents].sort(),
     tokens,
+    firstUsage,
     usageSamples,
     cost,
     costSamples,
+    v11: {
+      promptCacheSamples: v11.promptCacheSamples,
+      avgCacheableRatio: v11.promptCacheSamples ? v11.cacheableRatioSum / v11.promptCacheSamples : null,
+      avgStableChars: v11.promptCacheSamples ? v11.stableChars / v11.promptCacheSamples : null,
+      avgDynamicChars: v11.promptCacheSamples ? v11.dynamicChars / v11.promptCacheSamples : null,
+      repeatedStableChars: v11.promptCacheSamples ? v11.repeatedStableChars : null,
+      repeatedStableRatio: v11.stableChars > 0 ? v11.repeatedStableChars / v11.stableChars : null,
+      evidenceRefOccurrences: v11.evidenceRefOccurrences || null,
+      uniqueEvidenceRefs: v11.evidenceRefs.size || null,
+      evidenceReuseRatio: v11.evidenceRefOccurrences
+        ? 1 - (v11.evidenceRefs.size / v11.evidenceRefOccurrences)
+        : null,
+      visualRepairAttempts: v11.visualRepairAttempts || null,
+      contextExpansions: v11.contextExpansions || null,
+      modelEscalations: v11.modelEscalations || null,
+    },
   }
 }

package/lib/evidence-budget.mjs

@@ -0,0 +1,84 @@
+const DEFAULT_WEIGHTS = {
+  instructions: 0.10,
+  task: 0.08,
+  declared: 0.34,
+  tests: 0.15,
+  references: 0.20,
+  history: 0.05,
+  tools: 0.08,
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value))
+}
+
+function normalizeWeights(weights) {
+  const total = Object.values(weights).reduce((sum, value) => sum + Math.max(0, Number(value) || 0), 0) || 1
+  return Object.fromEntries(Object.entries(weights).map(([key, value]) => [key, Math.max(0, Number(value) || 0) / total]))
+}
+
+export function planEvidenceBudget(taskPolicy = {}, task = {}, signals = {}) {
+  const base = clamp(
+    Number(taskPolicy.contextBudget ?? taskPolicy.profile?.contextBudget ?? signals.contextBudget ?? 20_000),
+    4_000,
+    48_000,
+  )
+  const text = [task?.title, task?.summary, ...(task?.acceptance || [])].filter(Boolean).join(" ").toLowerCase()
+  const visual = signals.visual === true || signals.vision === true || /(screenshot|figma|visual|pixel|layout|giao diện|hình ảnh|ảnh mẫu)/i.test(text)
+  const browser = signals.browser === true || /(browser|playwright|e2e|click|navigation|trình duyệt)/i.test(text)
+  const debugging = signals.debugging === true || /(fix|bug|error|regression|debug|lỗi)/i.test(text)
+  const highRisk = taskPolicy.risk === "high"
+
+  const weights = { ...DEFAULT_WEIGHTS }
+  if (debugging) {
+    weights.tests += 0.07
+    weights.references -= 0.04
+    weights.history += 0.02
+    weights.declared -= 0.05
+  }
+  if (highRisk) {
+    weights.tests += 0.06
+    weights.references += 0.04
+    weights.tools -= 0.03
+    weights.declared -= 0.05
+    weights.task -= 0.02
+  }
+  if (visual || browser) {
+    weights.tools += 0.08
+    weights.references -= 0.04
+    weights.declared -= 0.04
+  }
+
+  const normalized = normalizeWeights(weights)
+  const buckets = Object.fromEntries(
+    Object.entries(normalized).map(([key, weight]) => [key, Math.max(256, Math.round(base * weight))]),
+  )
+  const allocated = Object.values(buckets).reduce((sum, value) => sum + value, 0)
+  const drift = base - allocated
+  buckets.declared = Math.max(256, buckets.declared + drift)
+
+  return {
+    schemaVersion: 1,
+    total: base,
+    unit: "characters",
+    buckets,
+    signals: { visual, browser, debugging, highRisk },
+    expansion: {
+      initial: base,
+      diagnose: Math.min(48_000, Math.max(base, Math.round(base * 1.35))),
+      deepRecovery: Math.min(48_000, Math.max(20_000, Math.round(base * 1.75))),
+    },
+  }
+}
+
+export function bucketLimit(plan, role, remaining = Infinity) {
+  const limit = Number(plan?.buckets?.[role] || 0)
+  return Math.max(0, Math.min(limit, Number.isFinite(remaining) ? remaining : limit))
+}
+
+export function evidenceValueScore({ relevance = 0, freshness = 0, confidence = 0, chars = 1 } = {}) {
+  const signal = Math.max(0, Number(relevance)) * 0.55 +
+    Math.max(0, Number(freshness)) * 0.20 +
+    Math.max(0, Number(confidence)) * 0.25
+  return signal / Math.max(1, Number(chars))
+}