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

package/lib/task-engine.mjs

@@ -10,6 +10,13 @@ import { validateVerificationReceipt } from "./evidence-receipt.mjs"
 import { appendRuntimeEvent, readRuntimeEvents } from "./runtime-events.mjs"
 import { createGateReceipt, validateGateReceipt } from "./gate-receipt.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"
+import { assertActivePlanScope, persistPlanScope } from "./work-plan-scope.mjs"
+import { classifyDecisionPolicy } from "./decision-policy.mjs"
 
 const WORK_DIR = ".ues-work"
 const STATE_SCHEMA = 4
@@ -44,6 +51,8 @@ export function workPaths(root, slug) {
     events: path.join(dir, "EVENTS.jsonl"),
     tasks: path.join(dir, "tasks"),
     reports: path.join(dir, "reports"),
+    plans: path.join(dir, "plans"),
+    activePlan: path.join(dir, "ACTIVE_PLAN.json"),
     lock: path.join(dir, ".state-lock"),
   }
 }
@@ -263,6 +272,7 @@ export async function initWork(root, slug, goal) {
 
   await mkdir(paths.tasks, { recursive: true })
   await mkdir(paths.reports, { recursive: true })
+  await mkdir(paths.plans, { recursive: true })
   const createdAt = now()
   const cleanGoal = String(goal || "").trim() || "Define the requested engineering outcome."
 
@@ -280,6 +290,7 @@ export async function initWork(root, slug, goal) {
     planImportedAt: null,
     planHash: null,
     planApproval: null,
+    planScope: null,
     integrationVerification: null,
     tasks: {},
     decisions: [],
@@ -378,6 +389,7 @@ export async function importPlan(root, slug, planInput) {
     }
 
     const updatedAt = now()
+    const planScope = await persistPlanScope(loaded.paths, hash, plan, { importedAt: updatedAt, previousPlanHash: loaded.state.planHash || null })
     const state = {
       ...loaded.state,
       schemaVersion: STATE_SCHEMA,
@@ -387,6 +399,7 @@ export async function importPlan(root, slug, planInput) {
       planImportedAt: updatedAt,
       planHash: hash,
       planApproval: { status: "pending", planHash: hash, at: updatedAt, evidence: null },
+      planScope,
       integrationVerification: null,
       checkpoint: null,
       evidencePolicy: evidencePolicyForPlan(plan),
@@ -409,6 +422,7 @@ export async function approvePlan(root, slug, evidence, options = {}) {
     const loaded = await loadWork(root, slug)
     if (!loaded.plan) throw new Error("PLAN.json is missing")
     const hash = planHash(loaded.plan)
+    await assertActivePlanScope(loaded.paths, loaded.state.planHash || hash)
     if (loaded.state.planHash && loaded.state.planHash !== hash) {
       throw new Error("PLAN.json changed after import; re-import it before approval")
     }
@@ -535,6 +549,7 @@ export async function workStatus(root, slug) {
     blockers: loaded.state.blockers || [],
     planApproval: loaded.state.planApproval || null,
     integrationVerification: loaded.state.integrationVerification || null,
+    planScope: loaded.state.planScope || null,
     evidence: {
       receiptBacked,
       completed,
@@ -552,6 +567,7 @@ export async function startTask(root, slug, taskID, options = {}) {
   const result = await withWorkLock(root, slug, async () => {
     const loaded = await loadWork(root, slug)
     if (!loaded.plan) throw new Error("PLAN.json is missing; import a valid plan first")
+    await assertActivePlanScope(loaded.paths, loaded.state.planHash || planHash(loaded.plan))
     if (!planIsApproved(loaded.state, loaded.plan)) {
       throw new Error("plan is not approved; run ues-plan-checker and 'ocskill work approve-plan' first")
     }
@@ -883,16 +899,19 @@ export async function failTask(root, slug, taskID, reason, options = {}) {
 }
 
 export async function addDecision(root, slug, decision) {
-  const text = String(decision || "").trim()
+  const input = decision && typeof decision === "object" ? decision : { text: decision }
+  const text = String(input.text || "").trim()
   if (!text) throw new Error("decision text is required")
-
+  const policy = classifyDecisionPolicy(text, input.facts || input)
+  if (input.auto === true && !policy.autoResolvable) throw new Error("decision requires human approval before automatic resolution")
   return withWorkLock(root, slug, async () => {
     const loaded = await loadWork(root, slug)
     loaded.state.decisions ??= []
     const timestamp = now()
-    loaded.state.decisions.push({ at: timestamp, text })
+    loaded.state.decisions.push({ at: timestamp, text, policy, source: input.source || (input.auto === true ? "auto-ruling" : "human-or-agent") })
     loaded.state.updatedAt = timestamp
     await writeJson(loaded.paths.state, loaded.state)
+    await journal(loaded.paths, "decision.recorded", { text, policy })
     return loaded.state
   })
 }
@@ -1068,11 +1087,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 = [
@@ -1095,27 +1122,88 @@ async function buildContextPack(loaded, taskID) {
     effectiveMaxSkills: recovery.maxSkills,
     recovery,
   }
-  const contextManifest = await buildContextManifest(
+  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: recovery.contextBudget,
+      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,
+    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 || [],

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
+}

package/lib/visual-spec.mjs

@@ -0,0 +1,159 @@
+function number(value, fallback = 0) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+function range(value, tolerance = 0) {
+  if (Array.isArray(value) && value.length >= 2) return [number(value[0]), number(value[1])]
+  const exact = number(value)
+  return [exact - tolerance, exact + tolerance]
+}
+
+function within(actual, expected, tolerance) {
+  const [min, max] = range(expected, tolerance)
+  return actual >= Math.min(min, max) && actual <= Math.max(min, max)
+}
+
+function normalizeElement(item = {}) {
+  return {
+    id: String(item.id || "").trim(),
+    role: item.role || null,
+    region: item.region || null,
+    expected: {
+      ...(item.expected || {}),
+      ...(item.x !== undefined ? { x: item.x } : {}),
+      ...(item.y !== undefined ? { y: item.y } : {}),
+      ...(item.width !== undefined ? { width: item.width } : {}),
+      ...(item.height !== undefined ? { height: item.height } : {}),
+    },
+    tolerance: {
+      position: number(item.tolerance?.position, 8),
+      size: number(item.tolerance?.size, 8),
+    },
+    required: item.required !== false,
+  }
+}
+
+export function normalizeVisualSpec(spec = {}) {
+  const viewport = {
+    width: Math.max(1, number(spec.viewport?.width, 1440)),
+    height: Math.max(1, number(spec.viewport?.height, 900)),
+    deviceScaleFactor: Math.max(0.1, number(spec.viewport?.deviceScaleFactor, 1)),
+  }
+  return {
+    schemaVersion: 1,
+    name: spec.name || null,
+    viewport,
+    elements: (spec.elements || []).map(normalizeElement).filter((item) => item.id),
+    regions: Array.isArray(spec.regions) ? spec.regions : [],
+    tokens: spec.tokens || {},
+    metadata: spec.metadata || {},
+  }
+}
+
+export function validateVisualSpec(spec = {}) {
+  const normalized = normalizeVisualSpec(spec)
+  const errors = []
+  const ids = new Set()
+  for (const item of normalized.elements) {
+    if (ids.has(item.id)) errors.push("duplicate element id: " + item.id)
+    ids.add(item.id)
+    for (const key of ["x", "y", "width", "height"]) {
+      if (item.expected[key] === undefined) continue
+      const values = Array.isArray(item.expected[key]) ? item.expected[key] : [item.expected[key]]
+      if (values.some((value) => !Number.isFinite(Number(value)))) errors.push(item.id + ": invalid " + key)
+    }
+  }
+  return { valid: errors.length === 0, errors, spec: normalized }
+}
+
+function actualMap(actual = []) {
+  const values = Array.isArray(actual) ? actual : Object.values(actual || {})
+  return new Map(values.filter((item) => item?.id).map((item) => [String(item.id), item]))
+}
+
+export function createGeometryReceipt(specInput, actualInput, options = {}) {
+  const checked = validateVisualSpec(specInput)
+  if (!checked.valid) throw new Error("Invalid visual spec: " + checked.errors.join("; "))
+  const actual = actualMap(actualInput)
+  const elements = []
+  let failed = 0
+
+  for (const expected of checked.spec.elements) {
+    const found = actual.get(expected.id)
+    if (!found) {
+      const pass = !expected.required
+      if (!pass) failed += 1
+      elements.push({ id: expected.id, verdict: pass ? "PASS" : "FAIL", reason: "missing", expected: expected.expected, actual: null })
+      continue
+    }
+
+    const failures = []
+    const checks = {}
+    for (const key of ["x", "y"]) {
+      if (expected.expected[key] === undefined) continue
+      const ok = within(number(found[key]), expected.expected[key], expected.tolerance.position)
+      checks[key] = ok
+      if (!ok) failures.push(key)
+    }
+    for (const key of ["width", "height"]) {
+      if (expected.expected[key] === undefined) continue
+      const ok = within(number(found[key]), expected.expected[key], expected.tolerance.size)
+      checks[key] = ok
+      if (!ok) failures.push(key)
+    }
+    const pass = failures.length === 0
+    if (!pass) failed += 1
+    elements.push({
+      id: expected.id,
+      verdict: pass ? "PASS" : "FAIL",
+      failures,
+      checks,
+      expected: expected.expected,
+      actual: {
+        x: number(found.x),
+        y: number(found.y),
+        width: number(found.width),
+        height: number(found.height),
+      },
+    })
+  }
+
+  return {
+    schemaVersion: 1,
+    kind: "visual-geometry",
+    verdict: failed === 0 ? "PASS" : "FAIL",
+    viewport: checked.spec.viewport,
+    total: elements.length,
+    passed: elements.length - failed,
+    failed,
+    elements,
+    generatedAt: options.generatedAt || new Date().toISOString(),
+  }
+}
+
+export function buildVisualRepairPlan(receipt, pixelDiff = null) {
+  const failedElements = (receipt?.elements || []).filter((item) => item.verdict !== "PASS")
+  return {
+    schemaVersion: 1,
+    action: failedElements.length || (pixelDiff && pixelDiff.differentPixels > 0) ? "repair" : "accept",
+    failedElementIDs: failedElements.map((item) => item.id),
+    geometryFailures: failedElements.map((item) => ({ id: item.id, failures: item.failures || [item.reason] })),
+    pixelRegion: pixelDiff?.bounds || null,
+    directives: [
+      ...(failedElements.length ? ["edit only the owning component/style for failed geometry unless evidence shows a shared token defect"] : []),
+      ...(pixelDiff?.bounds ? ["inspect and, if vision is available, crop only the largest changed pixel region before another edit"] : []),
+      "re-render the affected viewport and produce a fresh receipt before declaring success",
+    ],
+  }
+}
+
+export function responsiveViewportMatrix(input = null) {
+  if (Array.isArray(input) && input.length) return input
+  return [
+    { id: "mobile", width: 390, height: 844 },
+    { id: "tablet", width: 768, height: 1024 },
+    { id: "desktop", width: 1440, height: 900 },
+    { id: "wide", width: 1920, height: 1080 },
+  ]
+}

package/lib/work-plan-scope.mjs

@@ -0,0 +1,49 @@
+import { existsSync } from "node:fs"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+
+function validPlanHash(value) {
+  return /^[a-f0-9]{64}$/i.test(String(value || ""))
+}
+
+export function planScopePaths(paths, planHash) {
+  if (!validPlanHash(planHash)) throw new Error("plan scope requires a SHA-256 plan hash")
+  const dir = path.join(paths.plans, planHash)
+  return { dir, plan: path.join(dir, "PLAN.json"), metadata: path.join(dir, "SCOPE.json") }
+}
+
+export async function persistPlanScope(paths, planHash, plan, metadata = {}) {
+  const scoped = planScopePaths(paths, planHash)
+  await mkdir(scoped.dir, { recursive: true })
+  await writeFile(scoped.plan, JSON.stringify(plan, null, 2) + "\n", "utf8")
+  const record = {
+    schemaVersion: 1,
+    planHash,
+    importedAt: metadata.importedAt || new Date().toISOString(),
+    previousPlanHash: metadata.previousPlanHash || null,
+    relativeDir: path.relative(paths.root, scoped.dir).replaceAll("\\", "/"),
+  }
+  await writeFile(scoped.metadata, JSON.stringify(record, null, 2) + "\n", "utf8")
+  await writeFile(paths.activePlan, JSON.stringify(record, null, 2) + "\n", "utf8")
+  return record
+}
+
+export async function readActivePlanScope(paths) {
+  if (!existsSync(paths.activePlan)) return null
+  try { return JSON.parse(await readFile(paths.activePlan, "utf8")) }
+  catch { throw new Error("ACTIVE_PLAN.json is invalid; re-import the plan before execution") }
+}
+
+export async function assertActivePlanScope(paths, expectedPlanHash) {
+  const active = await readActivePlanScope(paths)
+  if (!active) return { legacy: true, planHash: expectedPlanHash || null }
+  if (!validPlanHash(active.planHash)) throw new Error("ACTIVE_PLAN.json contains an invalid plan hash")
+  if (expectedPlanHash && active.planHash !== expectedPlanHash) {
+    throw new Error("active plan scope mismatch; re-import PLAN.json before executing tasks")
+  }
+  const scoped = planScopePaths(paths, active.planHash)
+  if (!existsSync(scoped.plan) || !existsSync(scoped.metadata)) {
+    throw new Error("active plan scope snapshot is incomplete; re-import PLAN.json")
+  }
+  return { ...active, legacy: false }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "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",
+  "version": "12.0.0-beta.0",
+  "description": "Perception-aware evidence-first engineering runtime with adaptive context, capability routing, visual/browser verification, weak-model recovery and benchmark-gated execution for OpenCode",
   "type": "module",
   "bin": {
     "ocskill": "bin/ocskill.mjs"
@@ -23,7 +23,7 @@
     "evals": "node scripts/eval-skills.mjs",
     "evals:live:validate": "node scripts/validate-live-suite.mjs",
     "test": "node --test test/*.test.mjs",
-    "ci": "npm run syntax && npm run validate && npm run evals && npm run evals:router && npm run evals:live:validate && npm run evals:long:validate && npm run evals:polyglot:validate && npm test && npm pack --dry-run && npm run smoke:pack && npm run smoke:plain-install",
+    "ci": "npm run syntax && npm run validate && npm run docs:check && npm run evals && npm run evals:router && npm run evals:v11:validate && npm run evals:v12:validate && npm run evals:repo-scale:validate && npm run evals:live:validate && npm run evals:long:validate && npm run evals:polyglot:validate && npm test && npm pack --dry-run && npm run smoke:pack && npm run smoke:plain-install",
     "postinstall": "node scripts/install.mjs",
     "preuninstall": "node scripts/uninstall.mjs",
     "prepublishOnly": "npm run ci",
@@ -42,11 +42,16 @@
     "dashboard": "node scripts/control-center.mjs",
     "evals:matrix": "node scripts/eval-matrix.mjs",
     "smoke:plain-install": "node scripts/smoke-plain-install.mjs",
+    "docs:check": "node scripts/check-release-consistency.mjs",
     "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:ablation": "node scripts/eval-ablation.mjs"
+    "evals:ablation": "node scripts/eval-ablation.mjs",
+    "evals:v11": "node --test test/*-v11.test.mjs",
+    "evals:v11:validate": "node scripts/validate-v11-suite.mjs",
+    "evals:repo-scale:validate": "node scripts/validate-repo-scale-suite.mjs",
+    "evals:v12:validate": "node scripts/validate-v12-foundation.mjs"
   },
   "keywords": [
     "opencode",
@@ -56,7 +61,10 @@
     "engineering-workflow",
     "code-review",
     "debugging",
-    "verification"
+    "verification",
+    "visual-testing",
+    "browser-automation",
+    "multimodal-agents"
   ],
   "engines": {
     "node": ">=20"