opencode-agent-skill 11.0.0 → 13.0.0-beta.0

package/lib/text-encoding.mjs

@@ -0,0 +1,74 @@
+import { readFileSync, writeFileSync } from "node:fs"
+import path from "node:path"
+
+function swappedUtf16(buffer) {
+  const evenLength = buffer.length - (buffer.length % 2)
+  const swapped = Buffer.allocUnsafe(evenLength)
+  for (let index = 0; index < evenLength; index += 2) {
+    swapped[index] = buffer[index + 1]
+    swapped[index + 1] = buffer[index]
+  }
+  return swapped.toString("utf16le")
+}
+
+function utf16Heuristic(buffer) {
+  if (buffer.length < 4) return null
+  let evenNulls = 0
+  let oddNulls = 0
+  let evenCount = 0
+  let oddCount = 0
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (index % 2 === 0) {
+      evenCount += 1
+      if (buffer[index] === 0) evenNulls += 1
+    } else {
+      oddCount += 1
+      if (buffer[index] === 0) oddNulls += 1
+    }
+  }
+  const evenRatio = evenCount ? evenNulls / evenCount : 0
+  const oddRatio = oddCount ? oddNulls / oddCount : 0
+  if (oddRatio >= 0.25 && evenRatio <= 0.05) return "utf16le"
+  if (evenRatio >= 0.25 && oddRatio <= 0.05) return "utf16be"
+  return null
+}
+
+export function decodeTextBuffer(value, options = {}) {
+  const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value || "")
+  if (buffer.length === 0) return ""
+
+  if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+    return buffer.subarray(3).toString("utf8")
+  }
+  if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+    return buffer.subarray(2).toString("utf16le")
+  }
+  if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+    return swappedUtf16(buffer.subarray(2))
+  }
+
+  const guessed = utf16Heuristic(buffer)
+  if (guessed === "utf16le") return buffer.toString("utf16le")
+  if (guessed === "utf16be") return swappedUtf16(buffer)
+
+  let nulBytes = 0
+  for (const byte of buffer) if (byte === 0) nulBytes += 1
+  if (nulBytes > Math.max(2, Math.floor(buffer.length * 0.01)) && options.allowBinary !== true) {
+    const error = new Error("file appears to be binary; refusing lossy text decoding")
+    error.code = "UES_BINARY_TEXT"
+    error.exitCode = 2
+    throw error
+  }
+
+  return buffer.toString("utf8")
+}
+
+export function readTextAuto(file, options = {}) {
+  return decodeTextBuffer(readFileSync(path.resolve(file)), options)
+}
+
+export function writeUtf8Text(file, text) {
+  const resolved = path.resolve(file)
+  writeFileSync(resolved, String(text ?? ""), "utf8")
+  return resolved
+}

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/lib/worktree-sandbox.mjs

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs"
-import { mkdir, rm } from "node:fs/promises"
+import { createHash } from "node:crypto"
+import { copyFile, mkdir, readFile, rm, unlink, writeFile } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 
@@ -27,11 +28,69 @@ function safeName(value) {
   return String(value || "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "")
 }
 
+function metadataFile(dir) {
+  return path.resolve(dir) + ".ues-meta.json"
+}
+
+async function readSandboxMetadata(dir) {
+  try {
+    return JSON.parse(await readFile(metadataFile(dir), "utf8"))
+  } catch {
+    return null
+  }
+}
+
+async function writeSandboxMetadata(dir, value) {
+  await writeFile(metadataFile(dir), JSON.stringify(value, null, 2) + "\n", "utf8")
+}
+
+async function inheritDirtySnapshot(root, dir) {
+  const inheritedUntrackedHashes = {}
+  const diff = git(root, ["diff", "--binary", "--no-ext-diff", "HEAD", "--"])
+  if (diff.status !== 0) throw new Error((diff.stderr || diff.stdout || "git diff HEAD failed").trim())
+  if (diff.stdout) {
+    const applied = git(dir, ["apply", "--whitespace=nowarn", "-"], { input: diff.stdout })
+    if (applied.status !== 0) throw new Error((applied.stderr || applied.stdout || "git apply inherited root diff failed").trim())
+  }
+
+  const untracked = git(root, ["ls-files", "--others", "--exclude-standard", "-z"])
+  if (untracked.status !== 0) throw new Error((untracked.stderr || untracked.stdout || "git ls-files failed").trim())
+  for (const relative of untracked.stdout.split("\0").filter(Boolean)) {
+    const source = path.join(root, relative)
+    const target = path.join(dir, relative)
+    const bytes = await readFile(source)
+    inheritedUntrackedHashes[relative.replaceAll("\\", "/")] = createHash("sha256").update(bytes).digest("hex")
+    await mkdir(path.dirname(target), { recursive: true })
+    await copyFile(source, target)
+  }
+
+  const add = git(dir, ["add", "-A"])
+  if (add.status !== 0) throw new Error((add.stderr || add.stdout || "git add inherited snapshot failed").trim())
+  const commit = git(dir, [
+    "-c", "user.name=UES Parallel Runtime",
+    "-c", "user.email=ues-parallel@example.invalid",
+    "commit", "-m", "chore(ues): inherited parallel integration snapshot",
+  ])
+  if (commit.status !== 0) {
+    const status = git(dir, ["status", "--porcelain=v1", "--untracked-files=all"])
+    if (status.status !== 0 || status.stdout.trim()) {
+      throw new Error((commit.stderr || commit.stdout || "git commit inherited snapshot failed").trim())
+    }
+  }
+  const head = git(dir, ["rev-parse", "HEAD"])
+  if (head.status !== 0) throw new Error((head.stderr || head.stdout || "git rev-parse inherited snapshot failed").trim())
+  return {
+    head: head.stdout.trim(),
+    inheritedUntrackedHashes,
+  }
+}
+
 export async function createTaskSandbox(root, slug, taskID, options = {}) {
   root = path.resolve(root)
   const status = git(root, ["status", "--porcelain=v1", "--untracked-files=all"])
   if (status.status !== 0) throw new Error((status.stderr || status.stdout || "git status failed").trim())
-  if (status.stdout.trim() && options.allowDirtyRoot !== true) {
+  const rootDirty = Boolean(status.stdout.trim())
+  if (rootDirty && options.allowDirtyRoot !== true && options.inheritDirtyRoot !== true) {
     throw new Error("sandbox creation requires a clean root working tree so the isolated executor cannot miss existing uncommitted changes")
   }
   const base = options.baseDir
@@ -48,7 +107,31 @@ export async function createTaskSandbox(root, slug, taskID, options = {}) {
   const result = git(root, ["worktree", "add", "-b", branch, dir, startPoint])
   if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git worktree add failed").trim())
 
-  return { schemaVersion: 1, root, dir, branch, slug, taskID, startPoint }
+  let integrationBase = git(dir, ["rev-parse", "HEAD"]).stdout.trim()
+  let inheritedDirtyRoot = false
+  let inheritedUntrackedHashes = {}
+  if (rootDirty && options.inheritDirtyRoot === true) {
+    const inherited = await inheritDirtySnapshot(root, dir)
+    integrationBase = inherited.head
+    inheritedUntrackedHashes = inherited.inheritedUntrackedHashes
+    inheritedDirtyRoot = true
+  }
+
+  const metadata = {
+    schemaVersion: 2,
+    root,
+    dir,
+    branch,
+    slug,
+    taskID,
+    startPoint,
+    integrationBase,
+    inheritedDirtyRoot,
+    inheritedUntrackedHashes,
+    createdAt: new Date().toISOString(),
+  }
+  await writeSandboxMetadata(dir, metadata)
+  return metadata
 }
 
 export async function integrateTaskSandbox(root, dir, options = {}) {
@@ -61,13 +144,16 @@ export async function integrateTaskSandbox(root, dir, options = {}) {
   if (rootTop.status !== 0 || sandboxTop.status !== 0) throw new Error("root and sandbox must be Git worktrees")
   if (path.resolve(sandboxTop.stdout.trim()) !== dir) throw new Error("sandbox path is not the worktree root")
 
-  // Resolve the merge base against the canonical root HEAD explicitly.
-  const rootHead = git(root, ["rev-parse", "HEAD"])
-  const sandboxHead = git(dir, ["rev-parse", "HEAD"])
-  if (rootHead.status !== 0 || sandboxHead.status !== 0) throw new Error("could not resolve worktree HEADs")
-  const base = git(dir, ["merge-base", rootHead.stdout.trim(), sandboxHead.stdout.trim()])
-  if (base.status !== 0) throw new Error((base.stderr || base.stdout || "git merge-base failed").trim())
-  const baseSha = base.stdout.trim()
+  const metadata = await readSandboxMetadata(dir)
+  let baseSha = metadata?.integrationBase || null
+  if (!baseSha) {
+    const rootHead = git(root, ["rev-parse", "HEAD"])
+    const sandboxHead = git(dir, ["rev-parse", "HEAD"])
+    if (rootHead.status !== 0 || sandboxHead.status !== 0) throw new Error("could not resolve worktree HEADs")
+    const base = git(dir, ["merge-base", rootHead.stdout.trim(), sandboxHead.stdout.trim()])
+    if (base.status !== 0) throw new Error((base.stderr || base.stdout || "git merge-base failed").trim())
+    baseSha = base.stdout.trim()
+  }
 
   // Intent-to-add exposes untracked files in a binary diff without committing them.
   const addIntent = git(dir, ["add", "-N", "."])
@@ -83,8 +169,30 @@ export async function integrateTaskSandbox(root, dir, options = {}) {
 
   const rootDirty = new Set(statusFiles(root))
   const overlap = changed.filter((file) => rootDirty.has(file))
-  if (overlap.length) {
-    throw new Error("sandbox integration conflicts with existing root changes: " + overlap.join(", "))
+  const unsafeOverlap = []
+  for (const file of overlap) {
+    if (!metadata?.inheritedDirtyRoot) {
+      unsafeOverlap.push(file)
+      continue
+    }
+
+    const inheritedUntrackedHash = metadata?.inheritedUntrackedHashes?.[file]
+    if (inheritedUntrackedHash) {
+      try {
+        const current = await readFile(path.join(root, file))
+        const currentHash = createHash("sha256").update(current).digest("hex")
+        if (currentHash !== inheritedUntrackedHash) unsafeOverlap.push(file)
+      } catch {
+        unsafeOverlap.push(file)
+      }
+      continue
+    }
+
+    const check = git(root, ["diff", "--quiet", baseSha, "--", file])
+    if (check.status !== 0) unsafeOverlap.push(file)
+  }
+  if (unsafeOverlap.length) {
+    throw new Error("sandbox integration conflicts with existing root changes: " + unsafeOverlap.join(", "))
   }
 
   const patch = git(dir, ["diff", "--binary", "--no-ext-diff", baseSha, "--"])
@@ -121,9 +229,30 @@ export async function removeTaskSandbox(root, dir, options = {}) {
       throw new Error((deleted.stderr || deleted.stdout || "git branch delete failed").trim())
     }
   }
+  await unlink(metadataFile(dir)).catch(() => {})
   return { removed: !existsSync(dir), dir, branch: branch || null }
 }
 
+export async function rollbackTaskSandbox(root, dir, options = {}) {
+  root = path.resolve(root)
+  dir = path.resolve(dir)
+  if (!existsSync(dir)) throw new Error("sandbox does not exist: " + dir)
+  const metadata = await readSandboxMetadata(dir)
+  if (!metadata?.integrationBase) throw new Error("sandbox rollback metadata is missing")
+
+  const patch = git(dir, ["diff", "--binary", "--no-ext-diff", metadata.integrationBase, "--"])
+  if (patch.status !== 0) throw new Error((patch.stderr || patch.stdout || "git diff for rollback failed").trim())
+  if (patch.stdout) {
+    const reversed = git(root, ["apply", "--reverse", "--whitespace=nowarn", "-"], { input: patch.stdout })
+    if (reversed.status !== 0) throw new Error((reversed.stderr || reversed.stdout || "git rollback apply failed").trim())
+  }
+
+  if (!options.keep) {
+    await removeTaskSandbox(root, dir, { force: true, deleteBranch: true })
+  }
+  return { rolledBack: true, dir, base: metadata.integrationBase }
+}
+
 export function listTaskSandboxes(root) {
   const result = git(path.resolve(root), ["worktree", "list", "--porcelain"])
   if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git worktree list failed").trim())

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "version": "11.0.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",
+  "version": "13.0.0-beta.0",
+  "description": "Parallel weak-model engineering runtime with isolated same-model workers, event-driven DAG execution, transactional integration, adaptive context and evidence-gated verification 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:v11: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",
+    "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:v13 && 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,13 +42,17 @@
     "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:v11": "node --test test/*-v11.test.mjs",
-    "evals:v11:validate": "node scripts/validate-v11-suite.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",
+    "evals:v13": "node --test test/*-v13.test.mjs"
   },
   "keywords": [
     "opencode",

package/scripts/check-release-consistency.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const DEFAULT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+function readJson(root, relative) {
+  const file = path.join(root, relative)
+  if (!existsSync(file)) {
+    return { ok: false, error: `${relative}: file not found`, value: null }
+  }
+  try {
+    return { ok: true, error: null, value: JSON.parse(readFileSync(file, "utf8")) }
+  } catch (e) {
+    return { ok: false, error: `${relative}: invalid JSON (${e.message})`, value: null }
+  }
+}
+
+function readText(root, relative) {
+  const file = path.join(root, relative)
+  if (!existsSync(file)) {
+    return { ok: false, error: `${relative}: file not found`, value: null }
+  }
+  return { ok: true, error: null, value: readFileSync(file, "utf8") }
+}
+
+function countSkillDirs(root) {
+  const fullPath = path.join(root, "global-config", "skills")
+  if (!existsSync(fullPath)) return { ok: false, error: "global-config/skills: directory not found", value: 0 }
+  const entries = readdirSync(fullPath, { withFileTypes: true })
+  const count = entries.filter((entry) => entry.isDirectory() && existsSync(path.join(fullPath, entry.name, "SKILL.md"))).length
+  return { ok: true, error: null, value: count }
+}
+
+function countDir(root, dirPath, filter) {
+  const fullPath = path.join(root, dirPath)
+  if (!existsSync(fullPath)) {
+    return { ok: false, error: `${dirPath}: directory not found`, value: 0 }
+  }
+  const entries = readdirSync(fullPath, { withFileTypes: true })
+  const count = filter ? entries.filter(filter).length : entries.length
+  return { ok: true, error: null, value: count }
+}
+
+export function checkReleaseConsistency(root) {
+  root = root || DEFAULT_ROOT
+  const errors = []
+  const warnings = []
+
+  function rJson(relative) {
+    return readJson(root, relative)
+  }
+  function rText(relative) {
+    return readText(root, relative)
+  }
+  function rCount(dirPath, filter) {
+    return countDir(root, dirPath, filter)
+  }
+
+  // 1. package.json version == package-lock.json version
+  const pkg = rJson("package.json")
+  const lock = rJson("package-lock.json")
+  if (pkg.ok && lock.ok) {
+    const pkgVersion = pkg.value.version
+    const lockVersion = lock.value.version
+    if (pkgVersion !== lockVersion) {
+      errors.push(`package.json version (${pkgVersion}) != package-lock.json version (${lockVersion})`)
+    }
+  } else {
+    if (!pkg.ok) errors.push(pkg.error)
+    if (!lock.ok) errors.push(lock.error)
+  }
+
+  // 2. Count skills, commands, subagents
+  const skillRes = countSkillDirs(root)
+  const commandRes = rCount("global-config/commands", (e) => e.isFile() && e.name.endsWith(".md"))
+  const agentRes = rCount("global-config/agents", (e) => e.isFile() && e.name.endsWith(".md"))
+  const skillCount = skillRes.ok ? skillRes.value : 0
+  const commandCount = commandRes.ok ? commandRes.value : 0
+  const agentCount = agentRes.ok ? agentRes.value : 0
+  if (!skillRes.ok) errors.push(skillRes.error)
+  if (!commandRes.ok) errors.push(commandRes.error)
+  if (!agentRes.ok) errors.push(agentRes.error)
+
+  const expectedVersion = pkg.ok ? pkg.value.version : "unknown"
+  const routing = rJson("evals/routing.json")
+  const routerTriggers = rJson("evals/router-triggers.json")
+  const staticScenarioCount = routing.ok && Array.isArray(routing.value.scenarios) ? routing.value.scenarios.length : 0
+  const routerCaseCount = routerTriggers.ok && Array.isArray(routerTriggers.value.cases) ? routerTriggers.value.cases.length : 0
+  if (!routing.ok) errors.push(routing.error)
+  if (!routerTriggers.ok) errors.push(routerTriggers.error)
+
+  // 3. Check README current version block
+  const readme = rText("README.md")
+  if (readme.ok) {
+    const versionMatch = readme.value.match(/Phiên bản hiện tại:\s*\n```text\n(\S+)/)
+    if (versionMatch && versionMatch[1] !== expectedVersion) {
+      errors.push(`README.md: current version says ${versionMatch[1]}, expected ${expectedVersion}`)
+    } else if (!versionMatch) {
+      errors.push("README.md: could not find current version block")
+    }
+    if (staticScenarioCount && !readme.value.includes("**" + staticScenarioCount + " static skill-routing scenarios**")) {
+      errors.push("README.md: static routing scenario count drift (actual: " + staticScenarioCount + ")")
+    }
+    if (routerCaseCount && !readme.value.includes("**" + routerCaseCount + " V2 router cases**")) {
+      errors.push("README.md: router case count drift (actual: " + routerCaseCount + ")")
+    }
+  } else {
+    errors.push(readme.error)
+  }
+
+  // 4. Check V11 docs for stale status markers
+  const v11Docs = ["docs/V11-PERCEPTION-ADAPTIVE.md", "docs/V11-PERCEPTION-ADAPTIVE-EXECUTION.md"]
+  for (const doc of v11Docs) {
+    const content = rText(doc)
+    if (!content.ok) {
+      errors.push(content.error)
+      continue
+    }
+    if (content.value.includes("Status: development")) {
+      errors.push(`${doc}: still marked as development`)
+    }
+    if (content.value.includes("11.0.0-dev.")) {
+      errors.push(`${doc}: still references dev version 11.0.0-dev.*`)
+    }
+    if (content.value.includes("npm `latest` remains V10")) {
+      errors.push(`${doc}: still says V10 remains npm latest`)
+    }
+  }
+
+  // 4b. V13 prerelease contract must stay synchronized with compatibility docs.
+  if (expectedVersion.startsWith("13.")) {
+    const v13 = rText("docs/V13-PARALLEL-WEAK-MODEL-RUNTIME.md")
+    if (!v13.ok) {
+      errors.push(v13.error)
+    } else {
+      if (!v13.value.includes("Status: beta prerelease (`" + expectedVersion + "`).")) {
+        errors.push("docs/V13-PARALLEL-WEAK-MODEL-RUNTIME.md: prerelease version/status drift")
+      }
+      for (const required of ["ues.dispatch_parallel", "same configured model", "OpenCode"]) {
+        if (!v13.value.includes(required)) {
+          errors.push("docs/V13-PARALLEL-WEAK-MODEL-RUNTIME.md: missing V13 contract marker " + required)
+        }
+      }
+    }
+
+    const compat = rText("docs/OPENCODE-COMPAT.md")
+    if (!compat.ok) {
+      errors.push(compat.error)
+    } else {
+      if (!compat.value.includes("V13 ships one npm package")) {
+        errors.push("docs/OPENCODE-COMPAT.md: current compatibility header is stale for V13")
+      }
+      if (!compat.value.includes("ues.dispatch_parallel")) {
+        errors.push("docs/OPENCODE-COMPAT.md: missing V13 parallel capability boundary")
+      }
+    }
+  }
+
+  // 5. Verify docs reflect actual counts (skip historical sections)
+  const docsToCheck = ["README.md", "docs/ENGINEERING-DESIGN.md", "docs/OPENCODE-COMPAT.md"]
+  for (const doc of docsToCheck) {
+    const content = rText(doc)
+    if (!content.ok) {
+      errors.push(content.error)
+      continue
+    }
+    const sections = content.value.split(/\n(?=#{1,6}\s)/)
+    for (const section of sections) {
+      const isHistorical = /^\s*#{1,6}\s+.*(V\d+\.|UES\s+\d+\.|historical|Historical)/im.test(section)
+      if (isHistorical) continue
+      if (section.includes("39 skills") || section.includes("39 namespaced skills")) {
+        errors.push(`${doc}: current section still references 39 skills (actual: ${skillCount})`)
+      }
+      if (section.includes("10 namespaced subagents") || section.includes("10 subagents")) {
+        errors.push(`${doc}: current section still references 10 subagents (actual: ${agentCount})`)
+      }
+      if (section.includes("34 static") && section.includes("scenarios")) {
+        errors.push(`${doc}: current section still references 34 static scenarios (actual: ${staticScenarioCount})`)
+      }
+    }
+  }
+
+  // 6. Check CI workflow
+  const ciYaml = rText(".github/workflows/ci.yml")
+  if (ciYaml.ok) {
+    if (!ciYaml.value.includes("evals:v11:validate")) {
+      errors.push(".github/workflows/ci.yml: missing evals:v11:validate job")
+    }
+    if (!/^\s*name:\s*CI Gate\s*$/m.test(ciYaml.value)) errors.push(".github/workflows/ci.yml: missing CI Gate aggregate job name")
+    if (!/needs:\s*\[\s*static\s*,\s*unit\s*,\s*package\s*\]/m.test(ciYaml.value)) errors.push(".github/workflows/ci.yml: CI Gate must depend on static, unit and package")
+    if (!/if:\s*always\(\)/m.test(ciYaml.value)) errors.push(".github/workflows/ci.yml: aggregate gate must use if: always()")
+    if (!ciYaml.value.includes("docs:check")) errors.push(".github/workflows/ci.yml: missing docs:check job")
+    for (const check of ["evals:v12:validate", ...(expectedVersion.startsWith("13.") ? ["evals:v13"] : []), "evals:repo-scale:validate"]) {
+      if (!ciYaml.value.includes(check)) errors.push(".github/workflows/ci.yml: missing " + check + " job")
+    }
+  } else {
+    errors.push(ciYaml.error)
+  }
+
+  // 7. Check Security workflow
+  const securityYaml = rText(".github/workflows/security.yml")
+  if (securityYaml.ok) {
+    if (!/^\s*name:\s*Security Gate\s*$/m.test(securityYaml.value)) errors.push(".github/workflows/security.yml: missing Security Gate aggregate job name")
+    if (!/needs:\s*\[\s*codeql\s*,\s*dependency-review\s*\]/m.test(securityYaml.value)) errors.push(".github/workflows/security.yml: Security Gate must depend on codeql and dependency-review")
+  } else {
+    errors.push(securityYaml.error)
+  }
+
+  // 8. Check publish workflow idempotency
+  const publishYaml = rText(".github/workflows/publish.yml")
+  if (publishYaml.ok) {
+    if (!publishYaml.value.includes("already published")) {
+      errors.push(".github/workflows/publish.yml: missing idempotency check for existing versions")
+    }
+  } else {
+    errors.push(publishYaml.error)
+  }
+
+  // 9. Check npm script docs:check exists
+  if (pkg.ok) {
+    const pkgScripts = pkg.value.scripts || {}
+    if (!pkgScripts["docs:check"]) {
+      warnings.push("package.json: missing docs:check npm script")
+    }
+    if (expectedVersion.startsWith("13.") && !pkgScripts["evals:v13"]) {
+      errors.push("package.json: V13 requires evals:v13 regression script")
+    }
+  }
+
+  return {
+    pass: errors.length === 0,
+    errors,
+    warnings,
+    version: expectedVersion,
+    skillCount,
+    commandCount,
+    subagentCount: agentCount,
+    staticScenarioCount,
+    routerCaseCount,
+  }
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const result = checkReleaseConsistency(process.env.UES_BUNDLE_ROOT || DEFAULT_ROOT)
+  if (result.warnings.length) {
+    console.warn("Warnings:")
+    for (const w of result.warnings) console.warn(`  WARN: ${w}`)
+  }
+  if (result.errors.length) {
+    console.error("Release consistency check FAILED:")
+    for (const e of result.errors) console.error(`  - ${e}`)
+    process.exit(1)
+  }
+  console.log(
+    `Release consistency check PASS: package=${result.version}, skills=${result.skillCount}, commands=${result.commandCount}, subagents=${result.subagentCount}`,
+  )
+}