opencode-agent-skill 9.0.0 → 10.0.0

package/lib/orchestrator-policy.mjs

@@ -13,8 +13,9 @@ function profileFor(mode, risk) {
     return {
       name: "fast",
       maxSkills: 2,
-      contextBudget: 12_000,
+      contextBudget: 8_000,
       contextStrategy: "incremental-semantic",
+      skillLoading: "direct-only",
       durableState: false,
       worktree: "off",
       critic: "off",
@@ -29,6 +30,7 @@ function profileFor(mode, risk) {
       maxSkills: 5,
       contextBudget: 48_000,
       contextStrategy: "semantic+graph+git",
+      skillLoading: "orchestrated",
       durableState: true,
       worktree: "auto-writers",
       critic: "required-for-high-risk-or-final",
@@ -40,8 +42,9 @@ function profileFor(mode, risk) {
   return {
     name: "standard",
     maxSkills: 4,
-    contextBudget: 24_000,
+    contextBudget: 20_000,
     contextStrategy: "incremental-semantic+git",
+    skillLoading: "selective",
     durableState: false,
     worktree: "auto-on-conflict",
     critic: "on-failure-or-elevated-risk",
@@ -51,12 +54,97 @@ function profileFor(mode, risk) {
   }
 }
 
+function boundedInt(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(max, Math.max(min, Math.round(parsed)))
+}
+
+export function recoveryPolicyForAttempt(taskPolicy = {}, attempt = 1) {
+  const normalizedAttempt = boundedInt(attempt, 1, 1, 99)
+  const baseBudget = boundedInt(
+    taskPolicy.contextBudget ?? taskPolicy.profile?.contextBudget,
+    20_000,
+    4_000,
+    48_000,
+  )
+  const baseSkills = boundedInt(
+    taskPolicy.maxSkills ?? taskPolicy.profile?.maxSkills,
+    4,
+    1,
+    5,
+  )
+  const baseStrategy = taskPolicy.profile?.contextStrategy || "incremental-semantic+git"
+
+  if (normalizedAttempt <= 1) {
+    return {
+      schemaVersion: 1,
+      stage: "initial",
+      attempt: normalizedAttempt,
+      contextBudget: baseBudget,
+      maxSkills: baseSkills,
+      contextStrategy: baseStrategy,
+      requireDiagnosis: false,
+      requireCritic: false,
+      modelEscalation: false,
+      directives: [],
+    }
+  }
+
+  if (normalizedAttempt === 2) {
+    return {
+      schemaVersion: 1,
+      stage: "diagnose",
+      attempt: normalizedAttempt,
+      contextBudget: Math.min(48_000, Math.max(baseBudget, Math.round(baseBudget * 1.35))),
+      maxSkills: Math.min(5, baseSkills + 1),
+      contextStrategy:
+        taskPolicy.executionProfile === "fast"
+          ? "incremental-semantic+git"
+          : baseStrategy,
+      requireDiagnosis: true,
+      requireCritic: false,
+      modelEscalation: true,
+      directives: [
+        "reproduce or capture the exact previous failure before editing",
+        "inspect the direct caller, nearest test and failure-adjacent evidence",
+        "do not stack another speculative patch on top of the failed attempt",
+      ],
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    stage: "deep-recovery",
+    attempt: normalizedAttempt,
+    contextBudget: Math.min(48_000, Math.max(20_000, Math.round(baseBudget * 1.75))),
+    maxSkills: Math.min(5, baseSkills + 2),
+    contextStrategy: "semantic+graph+git",
+    requireDiagnosis: true,
+    requireCritic: true,
+    modelEscalation: true,
+    directives: [
+      "re-investigate from fresh evidence and explicitly reject the failed hypothesis",
+      "expand to callers, dependencies, tests and boundary contracts before editing",
+      "challenge the architecture or coupling if repeated fixes expose a wider problem",
+      "run an independent critic or review pass before accepting the recovery",
+    ],
+  }
+}
+
 export function classifyEngineeringTask(text, facts = {}) {
   const value = String(text || "")
   const declaredHighRisk =
     ["high", "critical"].includes(String(facts.risk || "").toLowerCase()) ||
-    /\b(?:risk|rủi ro)\s*[:=-]?\s*(?:high|critical|cao|nghiêm trọng)\b/i.test(value)
-  const explicitLongHorizon = LONG.test(value)
+    /\b(?:risk|rủi ro)\s*[:=\/-]?\s*(?:high|critical|cao|nghiêm trọng)\b/i.test(value) ||
+    /\b(?:high|critical)[-\s]?(?:risk|rủi ro)\b/i.test(value)
+  const declaredLongHorizon =
+    facts.longHorizon === true ||
+    ["long", "long-horizon", "deep"].includes(String(facts.mode || "").toLowerCase())
+  const compoundLongRisk =
+    /\blong\s*[/|,+]\s*(?:high|critical)[-\s]?risk\b/i.test(value) ||
+    /\b(?:high|critical)[-\s]?risk\s*[/|,+]\s*long\b/i.test(value)
+  const explicitLongHorizon = declaredLongHorizon || compoundLongRisk || LONG.test(value)
   const signals = [
     signal("long-request-text", value.length > 700, 1),
     signal("medium-request-text", value.length > 250, 1),
@@ -91,8 +179,9 @@ export function classifyEngineeringTask(text, facts = {}) {
   if (/(docker|kubernetes|terraform|github actions|ci\/cd|deploy|triển khai)/i.test(value)) domains.push("devops")
 
   return {
-    schemaVersion: 3,
+    schemaVersion: 4,
     score,
+    signals,
     risk,
     mode,
     executionProfile: profile.name,
@@ -105,7 +194,11 @@ export function classifyEngineeringTask(text, facts = {}) {
     requireFreshEvidence: true,
     profile,
     domains: [...new Set(domains)],
-    signals,
+    recovery: {
+      escalateAfterFailure: true,
+      diagnosisBeforePatch: true,
+      deepRecoveryFromAttempt: 3,
+    },
     antiHallucination: {
       evidenceFirst: true,
       noCompletionWithoutVerification: mode !== "inline" || risk === "high",

package/lib/task-engine.mjs

@@ -9,10 +9,10 @@ import { relevantAcceptedLearnings } from "./learning-engine.mjs"
 import { validateVerificationReceipt } from "./evidence-receipt.mjs"
 import { appendRuntimeEvent, readRuntimeEvents } from "./runtime-events.mjs"
 import { createGateReceipt, validateGateReceipt } from "./gate-receipt.mjs"
-import { classifyEngineeringTask } from "./orchestrator-policy.mjs"
+import { classifyEngineeringTask, recoveryPolicyForAttempt } from "./orchestrator-policy.mjs"
 
 const WORK_DIR = ".ues-work"
-const STATE_SCHEMA = 3
+const STATE_SCHEMA = 4
 const LOCK_TIMEOUT_MS = 30_000
 const LOCK_STALE_MS = 120_000
 const LOCK_HEARTBEAT_MS = 15_000
@@ -284,6 +284,7 @@ export async function initWork(root, slug, goal) {
     tasks: {},
     decisions: [],
     blockers: [],
+    checkpoint: null,
     nextAction: "Complete SPEC.md, create PLAN.json, then run ocskill work plan.",
   })
   await writeJson(paths.evidence, {
@@ -387,6 +388,7 @@ export async function importPlan(root, slug, planInput) {
       planHash: hash,
       planApproval: { status: "pending", planHash: hash, at: updatedAt, evidence: null },
       integrationVerification: null,
+      checkpoint: null,
       evidencePolicy: evidencePolicyForPlan(plan),
       tasks: stateTasks,
       nextAction: "Run ues-plan-checker, then record PASS with 'ocskill work approve-plan'.",
@@ -489,7 +491,7 @@ export function readyTasks(plan, state) {
   const ready = []
   for (const task of plan.tasks) {
     const status = state.tasks?.[task.id]?.status
-    if (!["pending", "failed"].includes(status)) continue
+    if (!["pending", "failed", "retryable"].includes(status)) continue
     if (!(task.dependsOn || []).every((dep) => completed.has(dep))) continue
     const files = taskFiles(task)
     if (files.length === 0 && runningFiles.size > 0) continue
@@ -501,7 +503,7 @@ export function readyTasks(plan, state) {
 
 export async function workStatus(root, slug) {
   const loaded = await loadWork(root, slug)
-  const counts = { pending: 0, running: 0, completed: 0, failed: 0 }
+  const counts = { pending: 0, running: 0, completed: 0, failed: 0, retryable: 0 }
   for (const value of Object.values(loaded.state.tasks || {})) {
     if (Object.hasOwn(counts, value.status)) counts[value.status] += 1
   }
@@ -541,6 +543,7 @@ export async function workStatus(root, slug) {
       gateReceipts: (loaded.evidence.gateReceipts || []).length,
     },
     nextAction: loaded.state.nextAction,
+    checkpoint: loaded.state.checkpoint || null,
     updatedAt: loaded.state.updatedAt,
   }
 }
@@ -673,7 +676,7 @@ export async function recoverTask(root, slug, taskID, options = {}) {
     const timestamp = now()
     const previousOwner = record.owner ? { ...record.owner } : null
     const previousRunId = record.runId || null
-    record.status = "failed"
+    record.status = "retryable"
     record.lastFailure = String(options.reason || "stale executor lease recovered after interruption")
     record.lastOwner = previousOwner
     record.lastRunId = previousRunId
@@ -709,7 +712,7 @@ export async function recoverStaleTasks(root, slug, options = {}) {
       if (!stale) continue
       const previousOwner = record.owner ? { ...record.owner } : null
       const previousRunId = record.runId || null
-      record.status = "failed"
+      record.status = "retryable"
       record.lastFailure = "stale executor lease recovered after interruption"
       record.lastOwner = previousOwner
       record.lastRunId = previousRunId
@@ -1082,12 +1085,22 @@ async function buildContextPack(loaded, taskID) {
     changedFiles: taskFiles(task).length,
     risk: task.risk,
   })
+  const attempt = Math.max(1, Number(loaded.state.tasks?.[taskID]?.attempts || 1))
+  const recovery = recoveryPolicyForAttempt(contextPolicy, attempt)
+  const effectiveContextPolicy = {
+    ...contextPolicy,
+    contextBudget: recovery.contextBudget,
+    maxSkills: recovery.maxSkills,
+    effectiveContextBudget: recovery.contextBudget,
+    effectiveMaxSkills: recovery.maxSkills,
+    recovery,
+  }
   const contextManifest = await buildContextManifest(
     loaded.paths.root,
     task,
     {
-      budget: contextPolicy.contextBudget,
-      strategy: contextPolicy.profile?.contextStrategy || "semantic+graph+git",
+      budget: recovery.contextBudget,
+      strategy: recovery.contextStrategy,
     },
   ).catch(() => null)
   const learnings = await relevantAcceptedLearnings(
@@ -1097,7 +1110,8 @@ async function buildContextPack(loaded, taskID) {
 
   return {
     schemaVersion: STATE_SCHEMA,
-    contextPolicy,
+    contextPolicy: effectiveContextPolicy,
+    attempt,
     slug: loaded.state.slug,
     task,
     taskBrief: path.relative(loaded.paths.root, path.join(loaded.paths.tasks, `${taskID}.md`)).replaceAll("\\", "/"),
@@ -1111,6 +1125,7 @@ async function buildContextPack(loaded, taskID) {
     workingState: {
       status: loaded.state.status,
       task: loaded.state.tasks?.[taskID],
+      checkpoint: loaded.state.checkpoint || null,
     },
   }
 }
@@ -1151,6 +1166,128 @@ export async function contextPack(root, slug, taskID) {
   return buildContextPack(await loadWork(root, slug), taskID)
 }
 
+function checkpointEvidencePointers(evidence = {}) {
+  const pointers = []
+  for (const entry of (evidence.entries || []).slice(-12)) {
+    pointers.push({
+      kind: "evidence-entry",
+      task: entry.task || null,
+      at: entry.at || entry.recordedAt || null,
+      runId: entry.runId || null,
+    })
+  }
+  for (const receipt of (evidence.receipts || []).slice(-12)) {
+    pointers.push({
+      kind: "verification-receipt",
+      id: receipt.id || null,
+      task: receipt.task || null,
+      runId: receipt.runId || null,
+      verdict: receipt.verdict || null,
+    })
+  }
+  for (const receipt of (evidence.gateReceipts || []).slice(-8)) {
+    pointers.push({
+      kind: "gate-receipt",
+      id: receipt.id || null,
+      receiptKind: receipt.kind || null,
+      verdict: receipt.verdict || null,
+    })
+  }
+  return pointers.slice(-24)
+}
+
+function checkpointNextAction(loaded, taskID, runId) {
+  const record = taskID ? loaded.state.tasks?.[taskID] : null
+  if (record?.status === "running") {
+    return {
+      type: "continue-task",
+      taskId: taskID,
+      runId: runId || record.runId || null,
+      instruction: "Continue the active scoped task from durable evidence; execute the next required tool/action before narrative summary.",
+    }
+  }
+
+  const ready = readyTasks(loaded.plan, loaded.state)
+  if (ready.length) {
+    const nextTask = ready[0]
+    return {
+      type: "dispatch-task",
+      taskId: nextTask,
+      attempt: Number(loaded.state.tasks?.[nextTask]?.attempts || 0) + 1,
+      instruction: "Dispatch the next ready task in a fresh executor from .ues-work.",
+    }
+  }
+
+  return {
+    type: "inspect-state",
+    instruction: loaded.state.nextAction || "Inspect durable work state and choose the next deterministic action.",
+  }
+}
+
+export async function checkpointWork(root, slug, options = {}) {
+  return withWorkLock(root, slug, async () => {
+    const loaded = await loadWork(root, slug)
+    const taskID = String(options.taskID || "").trim() ||
+      Object.entries(loaded.state.tasks || {}).find(([, value]) => value.status === "running")?.[0] ||
+      null
+    const record = taskID ? loaded.state.tasks?.[taskID] : null
+    if (taskID && !record) throw new Error(`task '${taskID}' is not tracked`)
+    if (record?.status === "running") assertRunFence(record, { runId: options.runId || null })
+
+    const timestamp = now()
+    const checkpoint = {
+      schemaVersion: 1,
+      reason: String(options.reason || "runtime-checkpoint"),
+      createdAt: timestamp,
+      currentTaskId: taskID,
+      runId: record?.runId || options.runId || null,
+      planHash: loaded.plan ? planHash(loaded.plan) : loaded.state.planHash || null,
+      nextAction: checkpointNextAction(loaded, taskID, record?.runId || options.runId || null),
+      workspaceFingerprint: workspaceFingerprint(loaded.paths.root),
+      evidencePointers: checkpointEvidencePointers(loaded.evidence),
+      resumedAt: null,
+    }
+
+    loaded.state.schemaVersion = STATE_SCHEMA
+    loaded.state.checkpoint = checkpoint
+    loaded.state.updatedAt = timestamp
+    await writeJson(loaded.paths.state, loaded.state)
+    await journal(loaded.paths, "work.checkpoint", {
+      task: taskID,
+      runId: checkpoint.runId,
+      planHash: checkpoint.planHash,
+      reason: checkpoint.reason,
+      nextAction: checkpoint.nextAction,
+    })
+    return checkpoint
+  })
+}
+
+export async function markCheckpointResumed(root, slug, options = {}) {
+  return withWorkLock(root, slug, async () => {
+    const loaded = await loadWork(root, slug)
+    const checkpoint = loaded.state.checkpoint
+    if (!checkpoint) return null
+    if (options.taskID && checkpoint.currentTaskId && checkpoint.currentTaskId !== options.taskID) {
+      throw new Error("checkpoint task mismatch")
+    }
+    if (checkpoint.runId && options.runId && checkpoint.runId !== options.runId) {
+      throw new Error("checkpoint runId mismatch")
+    }
+    const timestamp = now()
+    checkpoint.resumedAt = timestamp
+    checkpoint.resumeReason = String(options.reason || "deterministic-action-observed")
+    loaded.state.updatedAt = timestamp
+    await writeJson(loaded.paths.state, loaded.state)
+    await journal(loaded.paths, "work.checkpoint-resumed", {
+      task: checkpoint.currentTaskId || null,
+      runId: checkpoint.runId || null,
+      reason: checkpoint.resumeReason,
+    })
+    return checkpoint
+  })
+}
+
 export async function runtimeEvents(root, slug, options = {}) {
   const paths = workPaths(root, slug)
   return readRuntimeEvents(paths.events, options)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "version": "9.0.0",
-  "description": "Evidence-first engineering runtime with adaptive orchestration, incremental semantic context, bounded ACI, sandboxed verification, replayable traces and benchmark-gated learning for OpenCode",
+  "version": "10.0.0",
+  "description": "Evidence-first engineering runtime with adaptive context, selective routing, weak-model recovery, bounded ACI and benchmark-gated verification for OpenCode",
   "type": "module",
   "bin": {
     "ocskill": "bin/ocskill.mjs"
@@ -45,7 +45,8 @@
     "release:check-tag": "node scripts/check-release-tag.mjs",
     "evals:polyglot:validate": "node scripts/validate-live-suite.mjs --suite polyglot",
     "evals:polyglot": "node scripts/eval-live.mjs --suite polyglot",
-    "evals:matrix:gate": "node scripts/eval-matrix.mjs --require-confidence"
+    "evals:matrix:gate": "node scripts/eval-matrix.mjs --require-confidence",
+    "evals:ablation": "node scripts/eval-ablation.mjs"
   },
   "keywords": [
     "opencode",

package/scripts/eval-ablation.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { compareEvalSummaries } from "../lib/eval-ablation.mjs"
+
+const args = process.argv.slice(2)
+
+function option(name, fallback) {
+  const index = args.indexOf(name)
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : fallback
+}
+
+function positional() {
+  const values = []
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index].startsWith("--")) {
+      if (["--pass-rate-tolerance", "--min-initial-reduction", "--max-token-ratio", "--max-duration-ratio"].includes(args[index])) index += 1
+      continue
+    }
+    values.push(args[index])
+  }
+  return values
+}
+
+const [referenceFile, candidateFile] = positional()
+if (!referenceFile || !candidateFile) {
+  console.error("Usage: node scripts/eval-ablation.mjs <reference-summary.json> <candidate-summary.json> [--require-gate] [--min-initial-reduction 0.10]")
+  process.exit(2)
+}
+
+const [reference, candidate] = await Promise.all([
+  readFile(path.resolve(referenceFile), "utf8").then(JSON.parse),
+  readFile(path.resolve(candidateFile), "utf8").then(JSON.parse),
+])
+
+const report = compareEvalSummaries(reference, candidate, {
+  passRateTolerance: Number(option("--pass-rate-tolerance", "0")),
+  minInitialInputReduction: Number(option("--min-initial-reduction", "0.10")),
+  maxTotalTokenRatio: Number(option("--max-token-ratio", "1.05")),
+  maxDurationRatio: Number(option("--max-duration-ratio", "1.10")),
+})
+
+console.log(JSON.stringify(report, null, 2))
+if (args.includes("--require-gate") && !report.gateEligible) process.exitCode = 1

package/scripts/eval-matrix.mjs

@@ -32,6 +32,8 @@ const onlyLive = has("--standard-only")
 const onlyPolyglot = has("--polyglot-only")
 const withoutPolyglot = has("--without-polyglot")
 const requireConfidence = has("--require-confidence")
+const maxInitialInputRatio = Number(argValue("--max-initial-input-ratio", "1.5"))
+const maxTokenRatio = Number(argValue("--max-token-ratio", "1.75"))
 
 if (!model) {
   console.error("Usage: node scripts/eval-matrix.mjs --model provider/model [--trials 3] [--auth current|env-only] [--variant high] [--without-polyglot|--long-only|--standard-only|--polyglot-only]")
@@ -110,7 +112,10 @@ const baselineCount = results.filter((item) => item.mode === "baseline").length
 const uesCount = results.filter((item) => item.mode === "ues").length
 const coverageComplete = baselineCount === expectedPerMode && uesCount === expectedPerMode
 const summary = summarizeEvalResults(results)
-const confidence = pairedBenchmarkConfidence(results)
+const confidence = pairedBenchmarkConfidence(results, {
+  maxInitialInputRatio: Number.isFinite(maxInitialInputRatio) ? maxInitialInputRatio : 1.5,
+  maxTokenRatio: Number.isFinite(maxTokenRatio) ? maxTokenRatio : 1.75,
+})
 
 const report = {
   schemaVersion: 1,
@@ -134,7 +139,11 @@ const report = {
     mode: item.mode,
     passed: item.passed === true,
     durationMs: item.durationMs ?? null,
-    telemetry: item.telemetry?.costSamples > 0 ? { cost: item.telemetry.cost } : {},
+    telemetry: {
+      ...(item.telemetry?.costSamples > 0 ? { cost: item.telemetry.cost } : {}),
+      ...(item.telemetry?.firstUsage ? { firstUsage: item.telemetry.firstUsage } : {}),
+      ...(item.telemetry?.tokens ? { tokens: item.telemetry.tokens } : {}),
+    },
   })),
   summary,
   confidence,
@@ -149,6 +158,8 @@ console.log("- UES: " + (summary.modes.ues?.passed || 0) + "/" + (summary.modes.
 console.log("- pass-rate delta: " + (summary.passRateDelta == null ? "n/a" : (summary.passRateDelta * 100).toFixed(1) + " pp"))
 console.log("- coverage: " + (coverageComplete ? "COMPLETE" : "INCOMPLETE"))
 console.log("- paired confidence: " + (confidence.promotionEligible ? "SUPPORTED" : "NOT YET SUPPORTED") + " (pairs=" + confidence.pairs + ", p=" + confidence.pValue.toFixed(4) + ")")
+console.log("- initial-input ratio UES/baseline: " + (confidence.initialInput.ratio == null ? "n/a" : confidence.initialInput.ratio.toFixed(3)) + " (max " + confidence.initialInput.maxRatio + ")")
+console.log("- total-token ratio UES/baseline: " + (confidence.tokens.ratio == null ? "n/a" : confidence.tokens.ratio.toFixed(3)) + " (max " + confidence.tokens.maxRatio + ")")
 console.log("- confidence gate: " + (requireConfidence ? "REQUIRED" : "report-only"))
 console.log("- report: " + reportFile)