opencode-agent-skill 9.0.0 → 11.0.0

package/lib/task-engine.mjs

@@ -9,10 +9,15 @@ 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"
+import { planEvidenceBudget } from "./evidence-budget.mjs"
+import { putEvidence } from "./evidence-store.mjs"
+import { inferTaskCapabilities } from "./capability-registry.mjs"
+import { buildPromptEnvelope } from "./prompt-cache.mjs"
+import { externalizeContextExcerpts } from "./context-engine-v11.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 +289,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 +393,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 +496,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 +508,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 +548,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 +681,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 +717,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
@@ -1065,11 +1073,19 @@ async function buildContextPack(loaded, taskID) {
   const task = taskByID(loaded.plan, taskID)
   const spec = await readFile(loaded.paths.spec, "utf8").catch(() => "")
   const dependencyReports = {}
+  const dependencyReportRefs = {}
 
   for (const dep of task.dependsOn || []) {
     const file = path.join(loaded.paths.reports, `${dep}.md`)
     if (!existsSync(file)) continue
-    dependencyReports[dep] = (await readFile(file, "utf8")).slice(0, 12000)
+    const report = await readFile(file, "utf8")
+    dependencyReports[dep] = report.slice(0, 6000)
+    const stored = await putEvidence(loaded.paths.root, report, {
+      kind: "dependency-report",
+      source: path.relative(loaded.paths.root, file).replaceAll("\\", "/"),
+      summary: `Dependency report for ${dep}`,
+    }).catch(() => null)
+    if (stored?.ref) dependencyReportRefs[dep] = stored.ref
   }
 
   const taskText = [
@@ -1082,26 +1098,98 @@ async function buildContextPack(loaded, taskID) {
     changedFiles: taskFiles(task).length,
     risk: task.risk,
   })
-  const contextManifest = await buildContextManifest(
+  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 capabilities = inferTaskCapabilities(taskText, {
+    longContext: contextPolicy.mode === "long-horizon",
+    coding: true,
+    toolCalling: true,
+    filesystem: true,
+  })
+  const evidenceBudget = planEvidenceBudget(effectiveContextPolicy, task, capabilities.required)
+  const rawContextManifest = await buildContextManifest(
     loaded.paths.root,
     task,
     {
-      budget: contextPolicy.contextBudget,
-      strategy: contextPolicy.profile?.contextStrategy || "semantic+graph+git",
+      budget: evidenceBudget.total,
+      strategy: recovery.contextStrategy,
+      evidenceBudget,
     },
   ).catch(() => null)
+  const externalizedContext = rawContextManifest
+    ? await externalizeContextExcerpts(loaded.paths.root, rawContextManifest, {
+        task,
+        threshold: Math.max(1800, Math.round(evidenceBudget.total * 0.12)),
+        inlineChars: Math.max(600, Math.min(1600, Math.round(evidenceBudget.total * 0.08))),
+      }).catch(() => ({ manifest: rawContextManifest, externalized: [], externalizedBytes: 0 }))
+    : { manifest: null, externalized: [], externalizedBytes: 0 }
+  const contextManifest = externalizedContext.manifest
   const learnings = await relevantAcceptedLearnings(
     loaded.paths.root,
     [task.title, task.summary, ...(task.acceptance || [])].join(" "),
   ).catch(() => [])
 
+  const specStored = spec
+    ? await putEvidence(loaded.paths.root, spec, {
+        kind: "work-spec",
+        source: path.relative(loaded.paths.root, loaded.paths.spec).replaceAll("\\", "/"),
+        summary: "Durable work specification",
+      }).catch(() => null)
+    : null
+  const promptEnvelope = buildPromptEnvelope({
+    role: "executor",
+    invariants: "evidence-first; scoped edits; fresh verification; no unsupported completion claims",
+    skills: contextPolicy.domains || [],
+    projectFacts: {
+      instructions: contextManifest?.instructions || [],
+      strategy: recovery.contextStrategy,
+    },
+    task,
+    evidence: [
+      ...(specStored?.ref ? [specStored.ref] : []),
+      ...Object.values(dependencyReportRefs),
+      ...(contextManifest?.evidencePointers || []).map((item) => item.ref),
+      ...(contextManifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
+    ],
+    recentFailure: recovery.stage === "initial" ? null : loaded.state.tasks?.[taskID]?.lastError || null,
+    nextAction: loaded.state.checkpoint?.nextAction || loaded.state.nextAction || null,
+  })
+
   return {
     schemaVersion: STATE_SCHEMA,
-    contextPolicy,
+    contextSchemaVersion: 6,
+    contextPolicy: effectiveContextPolicy,
+    capabilities,
+    evidenceBudget,
+    promptCache: {
+      stablePrefixHash: promptEnvelope.stablePrefixHash,
+      dynamicHash: promptEnvelope.dynamicHash,
+      stableChars: promptEnvelope.stableChars,
+      dynamicChars: promptEnvelope.dynamicChars,
+      cacheableRatio: promptEnvelope.cacheableRatio,
+    },
+    attempt,
     slug: loaded.state.slug,
     task,
     taskBrief: path.relative(loaded.paths.root, path.join(loaded.paths.tasks, `${taskID}.md`)).replaceAll("\\", "/"),
-    spec: spec.slice(0, 24000),
+    spec: spec.slice(0, Math.min(12000, evidenceBudget.buckets.instructions + evidenceBudget.buckets.task)),
+    evidencePointers: {
+      spec: specStored?.ref || null,
+      dependencyReports: dependencyReportRefs,
+      context: (contextManifest?.evidencePointers || []).map((item) => item.ref),
+    },
+    evidenceStore: {
+      refs: externalizedContext.externalized.length,
+      externalizedBytes: externalizedContext.externalizedBytes,
+    },
     dependencyReports,
     decisions: loaded.state.decisions || [],
     blockers: loaded.state.blockers || [],
@@ -1111,6 +1199,7 @@ async function buildContextPack(loaded, taskID) {
     workingState: {
       status: loaded.state.status,
       task: loaded.state.tasks?.[taskID],
+      checkpoint: loaded.state.checkpoint || null,
     },
   }
 }
@@ -1151,6 +1240,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/lib/ui-inspector.mjs

@@ -0,0 +1,152 @@
+function uniq(values) {
+  return [...new Set(values.filter((value) => value !== null && value !== undefined && value !== ""))]
+}
+
+function round(value, digits = 3) {
+  const factor = 10 ** digits
+  return Math.round(Number(value) * factor) / factor
+}
+
+function normalizeBox(item = {}) {
+  const box = item.box && typeof item.box === "object" ? item.box : item
+  const x = Number(box.x)
+  const y = Number(box.y)
+  const width = Number(box.width)
+  const height = Number(box.height)
+  if (![x,y,width,height].every(Number.isFinite)) return null
+  return {
+    id: String(item.id || item.name || "").trim() || null,
+    role: item.role || null,
+    x, y, width, height,
+    right: x + width,
+    bottom: y + height,
+  }
+}
+
+function containsBox(a, b) {
+  return a.x <= b.x && a.y <= b.y && a.right >= b.right && a.bottom >= b.bottom
+}
+
+function intersectionArea(a, b) {
+  const width = Math.max(0, Math.min(a.right, b.right) - Math.max(a.x, b.x))
+  const height = Math.max(0, Math.min(a.bottom, b.bottom) - Math.max(a.y, b.y))
+  return width * height
+}
+
+export function inspectResponsiveLayout(items = [], viewport = {}, options = {}) {
+  const width = Math.max(1, Number(viewport.width || 0))
+  const height = Math.max(1, Number(viewport.height || 0))
+  const boxes = items.map(normalizeBox).filter(Boolean)
+  const issues = []
+  const minTouch = Math.max(1, Number(options.minTouchTarget || 44))
+  const touchRoles = new Set(["button","link","checkbox","radio","switch","tab","menuitem"])
+
+  for (const box of boxes) {
+    if (box.x < 0 || box.y < 0 || box.right > width || box.bottom > height) {
+      issues.push({
+        kind: "viewport-overflow",
+        id: box.id,
+        box,
+        viewport: { width, height },
+      })
+    }
+    if (touchRoles.has(String(box.role || "").toLowerCase()) && (box.width < minTouch || box.height < minTouch)) {
+      issues.push({
+        kind: "small-touch-target",
+        id: box.id,
+        role: box.role,
+        actual: { width: box.width, height: box.height },
+        minimum: minTouch,
+      })
+    }
+  }
+
+  const maxPairChecks = Math.max(0, Math.min(10000, Number(options.maxPairChecks || 3000)))
+  let checks = 0
+  for (let i = 0; i < boxes.length; i += 1) {
+    for (let j = i + 1; j < boxes.length && checks < maxPairChecks; j += 1) {
+      checks += 1
+      const a = boxes[i]
+      const b = boxes[j]
+      if (containsBox(a,b) || containsBox(b,a)) continue
+      const area = intersectionArea(a,b)
+      if (!area) continue
+      const smaller = Math.max(1, Math.min(a.width*a.height, b.width*b.height))
+      const ratio = area / smaller
+      if (ratio >= Number(options.overlapRatio ?? 0.15)) {
+        issues.push({
+          kind: "element-overlap",
+          a: a.id,
+          b: b.id,
+          intersectionArea: area,
+          smallerElementRatio: round(ratio),
+        })
+      }
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    viewport: { width, height },
+    elementCount: boxes.length,
+    pairChecks: checks,
+    verdict: issues.length ? "FAIL" : "PASS",
+    issues,
+  }
+}
+
+function normalizeCssValue(value) {
+  return String(value || "").trim().replace(/\s+/g, " ")
+}
+
+export function extractDesignTokens(css = "") {
+  const source = String(css || "")
+  const variables = {}
+  for (const match of source.matchAll(/--([a-zA-Z0-9_-]+)\s*:\s*([^;}{]+)\s*;/g)) {
+    variables["--" + match[1]] = normalizeCssValue(match[2])
+  }
+
+  const colors = uniq([
+    ...source.matchAll(/#[0-9a-fA-F]{3,8}\b/g),
+    ...source.matchAll(/\b(?:rgb|rgba|hsl|hsla)\([^)]*\)/g),
+  ].map((match) => match[0].toLowerCase())).slice(0, 128)
+
+  const lengths = uniq([...source.matchAll(/-?\d*\.?\d+(?:px|rem|em)\b/g)].map((m)=>m[0]))
+  const px = lengths.filter((value)=>value.endsWith("px")).map((value)=>Number.parseFloat(value)).filter((value)=>Number.isFinite(value) && value >= 0)
+  const radii = uniq([...source.matchAll(/border-radius\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+  const fontSizes = uniq([...source.matchAll(/font-size\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+  const shadows = uniq([...source.matchAll(/box-shadow\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+
+  const spacingCandidates = uniq(px.filter((value)=>value <= 128).sort((a,b)=>a-b)).slice(0,32)
+
+  return {
+    schemaVersion: 1,
+    variables,
+    colors,
+    spacingCandidates,
+    radii,
+    fontSizes,
+    shadows,
+    stats: {
+      variableCount: Object.keys(variables).length,
+      colorCount: colors.length,
+      lengthCount: lengths.length,
+    },
+  }
+}
+
+export function designTokenEvidence(tokens = {}) {
+  const variableEntries = Object.entries(tokens.variables || {})
+  return {
+    schemaVersion: 1,
+    summary: {
+      variables: variableEntries.slice(0,40),
+      colors: (tokens.colors || []).slice(0,24),
+      spacingCandidates: (tokens.spacingCandidates || []).slice(0,20),
+      radii: (tokens.radii || []).slice(0,16),
+      fontSizes: (tokens.fontSizes || []).slice(0,16),
+      shadows: (tokens.shadows || []).slice(0,12),
+    },
+    stats: tokens.stats || {},
+  }
+}

package/lib/v11-metrics.mjs

@@ -0,0 +1,64 @@
+function finite(value) {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : 0
+}
+
+function ratio(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : null
+}
+
+export function summarizeV11Efficiency(samples = []) {
+  const totals = {
+    samples: samples.length,
+    stableChars: 0,
+    dynamicChars: 0,
+    repeatedStableChars: 0,
+    externalizedEvidenceBytes: 0,
+    evidenceRefs: 0,
+    visualRepairAttempts: 0,
+    contextExpansions: 0,
+    modelEscalations: 0,
+    duplicateToolBlocks: 0,
+    loopBlocks: 0,
+  }
+
+  for (const sample of samples) {
+    const cache = sample.promptCache || sample.contextPack?.promptCache || {}
+    totals.stableChars += finite(cache.stableChars)
+    totals.dynamicChars += finite(cache.dynamicChars)
+    totals.repeatedStableChars += finite(sample.repeatedStableChars ?? cache.repeatedStableChars)
+
+    const evidence = sample.evidenceStore || sample.evidence || {}
+    totals.externalizedEvidenceBytes += finite(evidence.externalizedBytes ?? evidence.bytes)
+    totals.evidenceRefs += finite(evidence.refs ?? sample.evidenceRefs)
+
+    totals.visualRepairAttempts += finite(sample.visualRepairAttempts)
+    totals.contextExpansions += finite(sample.contextExpansions)
+    totals.modelEscalations += finite(sample.modelEscalations)
+    totals.duplicateToolBlocks += finite(sample.duplicateToolBlocks)
+    totals.loopBlocks += finite(sample.loopBlocks)
+  }
+
+  const inputChars = totals.stableChars + totals.dynamicChars
+  return {
+    schemaVersion: 1,
+    totals,
+    cacheablePrefixRatio: ratio(totals.stableChars, inputChars),
+    repeatedStableRatio: ratio(totals.repeatedStableChars, totals.stableChars),
+    externalizedEvidenceBytesPerSample: ratio(totals.externalizedEvidenceBytes, totals.samples),
+    evidenceRefsPerSample: ratio(totals.evidenceRefs, totals.samples),
+    visualRepairsPerSample: ratio(totals.visualRepairAttempts, totals.samples),
+    contextExpansionsPerSample: ratio(totals.contextExpansions, totals.samples),
+    modelEscalationsPerSample: ratio(totals.modelEscalations, totals.samples),
+  }
+}
+
+export function verifiedSuccessPer100kTokens(results = []) {
+  let success = 0
+  let tokens = 0
+  for (const item of results) {
+    if (item.passed === true && item.verified !== false) success += 1
+    tokens += finite(item.tokens ?? item.telemetry?.tokens?.total)
+  }
+  return tokens > 0 ? success / (tokens / 100_000) : null
+}