opencode-agent-skill 7.7.0

package/scripts/smoke-packed-install.mjs

@@ -0,0 +1,326 @@
+import assert from "node:assert/strict"
+import { existsSync } from "node:fs"
+import { mkdir, mkdtemp, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const sourcePackageJson = JSON.parse(await readFile(path.join(repoRoot, "package.json"), "utf8"))
+const packageName = sourcePackageJson.name
+
+function runNpm(args, options = {}) {
+  const common = {
+    cwd: options.cwd ?? repoRoot,
+    env: options.env ?? process.env,
+    encoding: "utf8",
+  }
+
+  const npmExecPath = process.env.npm_execpath
+  if (npmExecPath && existsSync(npmExecPath)) {
+    return spawnSync(process.execPath, [npmExecPath, ...args], common)
+  }
+
+  return spawnSync("npm", args, {
+    ...common,
+    shell: process.platform === "win32",
+  })
+}
+
+function requireSuccess(result, label) {
+  if (result.status === 0) return
+  const details = [result.stdout, result.stderr].filter(Boolean).join("\n")
+  throw new Error(`${label} failed with exit code ${result.status ?? "unknown"}\n${details}`)
+}
+
+const temp = await mkdtemp(path.join(os.tmpdir(), "ocskill-pack-smoke-"))
+const packDir = path.join(temp, "pack")
+const prefix = path.join(temp, "prefix")
+const configDir = path.join(temp, "opencode")
+
+try {
+  await mkdir(packDir, { recursive: true })
+
+  const pack = runNpm(["pack", "--pack-destination", packDir])
+  requireSuccess(pack, "npm pack")
+
+  const tarballs = (await readdir(packDir)).filter((name) => name.endsWith(".tgz"))
+  assert.equal(tarballs.length, 1, "expected exactly one packed tarball")
+  const tarball = path.join(packDir, tarballs[0])
+
+  const npmVersion = runNpm(["--version"], { cwd: temp })
+  requireSuccess(npmVersion, "npm --version")
+  const npmMajor = Number.parseInt(npmVersion.stdout.trim().split(".")[0], 10)
+  const installArgs = ["install", "-g", tarball, "--prefix", prefix]
+  if (Number.isFinite(npmMajor) && npmMajor >= 11) {
+    installArgs.push(`--allow-scripts=${packageName}`)
+  }
+
+  const install = runNpm(installArgs, {
+    cwd: temp,
+    env: { ...process.env, OPENCODE_CONFIG_DIR: configDir, UES_OPENCODE_MAJOR: "2" },
+  })
+  requireSuccess(install, "packed global install with automatic OpenCode sync")
+
+  const root = runNpm(["root", "-g", "--prefix", prefix], { cwd: temp })
+  requireSuccess(root, "npm root -g")
+  const globalRoot = root.stdout.trim()
+  assert.ok(globalRoot, "npm root -g returned an empty path")
+
+  const packageDir = path.join(globalRoot, ...packageName.split("/"))
+  const packedReal = await realpath(packageDir)
+  const repoReal = await realpath(repoRoot)
+  assert.notEqual(
+    packedReal.toLowerCase(),
+    repoReal.toLowerCase(),
+    "packed global install unexpectedly points back to the source repository",
+  )
+
+  const packageJson = JSON.parse(await readFile(path.join(packageDir, "package.json"), "utf8"))
+  assert.equal(packageJson.name, packageName)
+
+  const cli = path.join(packageDir, "bin", "ocskill.mjs")
+  const env = { ...process.env, OPENCODE_CONFIG_DIR: configDir }
+
+  const status = spawnSync(process.execPath, [cli, "status"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(status, "ocskill status from packed copy")
+
+  const state = JSON.parse(
+    await readFile(path.join(configDir, ".ues", "state.json"), "utf8"),
+  )
+  assert.equal(state.package, packageName)
+  assert.equal(state.version, packageJson.version)
+  assert.ok(state.skills.length >= 39)
+  assert.ok(state.commands.length >= 11)
+  assert.ok(state.agents.length >= 10)
+  assert.equal(state.openCodeMajor, 2)
+  assert.deepEqual(state.plugins, ["ues-router/index.js"])
+
+  const routerPlugin = path.join(configDir, "plugins", "ues-router", "index.js")
+  assert.ok(existsSync(routerPlugin), "v2 router plugin was not installed from packed package")
+  assert.ok(existsSync(path.join(configDir, "plugins", "ues-router", "router.js")), "v2 router helper was not installed from packed package")
+  assert.ok(existsSync(path.join(configDir, "plugins", "ues-router", "safety.js")), "v2 router safety gate was not installed from packed package")
+  assert.ok(existsSync(path.join(configDir, "plugins", "ues-router", "capabilities.js")), "v7 router capability probe was not installed from packed package")
+  const routerSource = await readFile(routerPlugin, "utf8")
+  assert.match(routerSource, /name: "dispatch_task"/)
+  assert.match(routerSource, /ctx\.session\.create/)
+  assert.match(routerSource, /ctx\.session\.switchAgent/)
+  assert.match(routerSource, /ctx\.session\.switchModel/)
+  assert.match(routerSource, /name: "capabilities"/)
+  assert.match(routerSource, /name: "task_policy"/)
+  const reviewer = await readFile(path.join(configDir, "agents", "ues-reviewer.md"), "utf8")
+  assert.match(reviewer, /permissions:/)
+  assert.doesNotMatch(reviewer, /^permission:/m)
+
+  for (const name of ["ues-codebase-mapper.md", "ues-plan-checker.md", "ues-executor.md", "ues-integration-verifier.md"]) {
+    assert.ok(existsSync(path.join(configDir, "agents", name)), "missing packed V6 subagent " + name)
+  }
+  const executor = await readFile(path.join(configDir, "agents", "ues-executor.md"), "utf8")
+  assert.match(executor, /permissions:/)
+  assert.match(executor, /action: subagent/)
+  assert.match(executor, /effect: deny/)
+  assert.doesNotMatch(executor, /^permission:/m)
+
+  const inspect = spawnSync(process.execPath, [cli, "inspect", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(inspect, "ocskill inspect from packed copy")
+
+  const planFile = path.join(temp, "PLAN.json")
+  await writeFile(planFile, JSON.stringify({
+    schemaVersion: 1,
+    goal: "Packed V6 smoke",
+    tasks: [{
+      id: "T1",
+      title: "Smoke",
+      summary: "Validate packed task graph",
+      files: { modify: ["README.md"] },
+      dependsOn: [],
+      acceptance: ["Task graph is valid"],
+      verification: ["node --version"],
+      risk: "low",
+    }],
+  }, null, 2) + "\n", "utf8")
+
+  const graph = spawnSync(process.execPath, [cli, "task-graph", planFile], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(graph, "ocskill task-graph from packed copy")
+  assert.match(graph.stdout, /"valid": true/)
+
+  const workInit = spawnSync(process.execPath, [cli, "work", "init", "packed-smoke", temp, "--goal", "Packed V6 work smoke"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workInit, "ocskill work init from packed copy")
+
+  const workPlan = spawnSync(process.execPath, [cli, "work", "plan", "packed-smoke", planFile, temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workPlan, "ocskill work plan from packed copy")
+
+  const workStatusBeforeApproval = spawnSync(process.execPath, [cli, "work", "status", "packed-smoke", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workStatusBeforeApproval, "ocskill work status before approval from packed copy")
+  assert.match(workStatusBeforeApproval.stdout, /"status": "awaiting-plan-approval"/)
+  assert.match(workStatusBeforeApproval.stdout, /"ready": \[\]/)
+
+  const workStartBeforeApproval = spawnSync(process.execPath, [cli, "work", "start", "packed-smoke", "T1", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  assert.notEqual(workStartBeforeApproval.status, 0)
+  assert.match(workStartBeforeApproval.stderr, /plan is not approved/)
+
+  const workApprove = spawnSync(process.execPath, [cli, "work", "approve-plan", "packed-smoke", temp, "--evidence", "packed plan checker PASS"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workApprove, "ocskill work approve-plan from packed copy")
+
+  const workStatus = spawnSync(process.execPath, [cli, "work", "status", "packed-smoke", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workStatus, "ocskill work status after approval from packed copy")
+  assert.match(workStatus.stdout, /"T1"/)
+
+  const workStart = spawnSync(process.execPath, [cli, "work", "start", "packed-smoke", "T1", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workStart, "ocskill work start from packed copy")
+  const started = JSON.parse(workStart.stdout)
+  assert.ok(started.record.runId)
+
+  const heartbeat = spawnSync(process.execPath, [cli, "work", "heartbeat", "packed-smoke", "T1", temp, "--run-id", started.record.runId], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(heartbeat, "ocskill work heartbeat from packed copy")
+
+  const verifyCommand = spawnSync(process.execPath, [
+    cli, "work", "verify-command", "packed-smoke", "T1", temp,
+    "--run-id", started.record.runId,
+    "--", process.execPath, "--version",
+  ], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(verifyCommand, "ocskill work verify-command from packed copy")
+  assert.match(verifyCommand.stdout, /"passed": true/)
+
+  const workComplete = spawnSync(process.execPath, [
+    cli, "work", "complete", "packed-smoke", "T1", temp,
+    "--evidence", "node --version => PASS",
+    "--run-id", started.record.runId,
+  ], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workComplete, "ocskill work complete from packed copy")
+  assert.match(workComplete.stdout, /"evidenceStrength": "receipt-backed"/)
+
+  const finalizeBeforeVerify = spawnSync(process.execPath, [cli, "work", "finalize", "packed-smoke", temp, "--evidence", "should fail"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  assert.notEqual(finalizeBeforeVerify.status, 0)
+  assert.match(finalizeBeforeVerify.stderr, /recorded integration PASS/)
+
+  const workVerify = spawnSync(process.execPath, [cli, "work", "verify-integration", "packed-smoke", temp, "--verdict", "PASS", "--evidence", "packed integration PASS"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workVerify, "ocskill work verify-integration from packed copy")
+
+  const workFinalize = spawnSync(process.execPath, [cli, "work", "finalize", "packed-smoke", temp, "--evidence", "packed final acceptance PASS"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(workFinalize, "ocskill work finalize from packed copy")
+  assert.match(workFinalize.stdout, /"status": "completed"/)
+
+  const adaptivePolicy = spawnSync(process.execPath, [
+    cli, "task-policy",
+    "Refactor the entire repository authentication schema migration and public API contracts",
+  ], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(adaptivePolicy, "ocskill task-policy from packed copy")
+  assert.match(adaptivePolicy.stdout, /"mode": "long-horizon"/)
+  assert.match(adaptivePolicy.stdout, /"modelTier": "heavy"/)
+
+  const dashboard = spawnSync(process.execPath, [cli, "dashboard", temp], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(dashboard, "ocskill dashboard from packed copy")
+  assert.ok(existsSync(path.join(temp, ".ues-dashboard", "index.html")))
+
+  const hermes = spawnSync(process.execPath, [cli, "hermes", "status"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(hermes, "ocskill hermes status from packed copy")
+  assert.match(hermes.stdout, /"available":/)
+
+  const modelStatus = spawnSync(process.execPath, [cli, "models", "status"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(modelStatus, "ocskill models status from packed copy")
+  assert.match(modelStatus.stdout, /"enabled": false/)
+
+  const modelSet = spawnSync(process.execPath, [cli, "models", "set", "standard", "provider/mid"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(modelSet, "ocskill models set from packed copy")
+
+  const modelPolicy = spawnSync(process.execPath, [cli, "model-policy", "executor", "--attempt", "1"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(modelPolicy, "ocskill model-policy from packed copy")
+  assert.match(modelPolicy.stdout, /"model": "provider\/mid"/)
+
+  console.log(
+    `One-command packed install smoke passed for ${packageName}@${packageJson.version}: ` +
+      `${state.skills.length} skills, ${state.commands.length} commands, ${state.agents.length} subagents, ${state.plugins.length} v2 router plugin.`,
+  )
+} finally {
+  await rm(temp, { recursive: true, force: true })
+}

package/scripts/syntax-check.mjs

@@ -0,0 +1,35 @@
+import { readdir } from "node:fs/promises"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const roots = ["bin", "lib", "scripts", "test", "global-config/plugins", "evals/live/graders", "evals/live/fixtures", "evals/long/graders", "evals/long/fixtures"]
+const files = []
+
+async function walk(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name)
+    if (entry.isDirectory()) await walk(full)
+    else if (entry.isFile() && /\.(?:mjs|js|cjs)$/.test(entry.name)) files.push(full)
+  }
+}
+
+for (const relative of roots) await walk(path.join(root, relative))
+
+const errors = []
+for (const file of files.sort()) {
+  const run = spawnSync(process.execPath, ["--check", file], { encoding: "utf8" })
+  if (run.status !== 0) {
+    errors.push(`${path.relative(root, file)}\n${run.stderr || run.stdout || "syntax check failed"}`)
+  }
+}
+
+if (errors.length) {
+  console.error("JavaScript syntax validation failed:")
+  for (const error of errors) console.error("\n" + error)
+  process.exit(1)
+}
+
+console.log(`Syntax-checked ${files.length} JavaScript module files.`)

package/scripts/uninstall.mjs

@@ -0,0 +1,21 @@
+import { removeResources } from "../lib/installer.mjs"
+
+try {
+  const result = await removeResources()
+  for (const warning of result.warnings || []) {
+    console.warn(`[ocskill] WARNING: ${warning}`)
+  }
+
+  if (result.stateError) {
+    console.error(`[ocskill] ERROR: ${result.stateError}`)
+    process.exit(1)
+  }
+
+  console.log(
+    `[ocskill] Removed ${result.skills} managed skills, ${result.commands} managed commands and ${result.agents} managed subagents.`,
+  )
+} catch (error) {
+  console.error("[ocskill] Cleanup failed.")
+  console.error(error instanceof Error ? error.stack : error)
+  process.exit(1)
+}

package/scripts/validate-live-suite.mjs

@@ -0,0 +1,65 @@
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const args = process.argv.slice(2)
+const suiteIndex = args.indexOf("--suite")
+const suiteName = suiteIndex >= 0 ? args[suiteIndex + 1] : "live"
+if (!["live", "long"].includes(suiteName)) {
+  console.error("--suite must be live or long")
+  process.exit(2)
+}
+const suiteRoot = path.join(root, "evals", suiteName)
+const suite = JSON.parse(await readFile(path.join(suiteRoot, "tasks.json"), "utf8"))
+const errors = []
+const ids = new Set()
+
+const minimumTasks = suiteName === "long" ? 5 : 20
+if (!Array.isArray(suite.tasks) || suite.tasks.length < minimumTasks) {
+  errors.push(suiteName + " eval suite must contain at least " + minimumTasks + " tasks")
+}
+
+for (const task of suite.tasks || []) {
+  if (!task.id || ids.has(task.id)) {
+    errors.push(`invalid or duplicate task id: ${task.id || "<missing>"}`)
+    continue
+  }
+  ids.add(task.id)
+
+  if (!task.prompt || typeof task.prompt !== "string" || task.prompt.length < 40) {
+    errors.push(`${task.id}: prompt must be a concrete non-trivial string`)
+  }
+
+  const fixture = path.join(suiteRoot, task.fixture || "")
+  const grader = path.join(suiteRoot, task.grader || "")
+  if (!task.fixture || !existsSync(fixture)) errors.push(`${task.id}: missing fixture ${task.fixture || "<missing>"}`)
+  if (!task.grader || !existsSync(grader)) errors.push(`${task.id}: missing grader ${task.grader || "<missing>"}`)
+  if (!task.fixture || !task.grader || !existsSync(fixture) || !existsSync(grader)) continue
+
+  const run = spawnSync(process.execPath, [grader], {
+    cwd: fixture,
+    env: { ...process.env, UES_EVAL_WORKSPACE: fixture, UES_EVAL_TASK: task.id },
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+  })
+
+  if (run.status === 0) {
+    errors.push(`${task.id}: hidden grader unexpectedly passes the intentionally broken fixture`)
+  } else {
+    const diagnostic = `${run.stderr || ""}\n${run.stdout || ""}`
+    if (!/AssertionError|ERR_ASSERTION|assert/i.test(diagnostic)) {
+      errors.push(`${task.id}: grader failed for a non-assertion reason; check syntax/runtime setup`)
+    }
+  }
+}
+
+if (errors.length) {
+  console.error(suiteName + " eval suite validation failed:")
+  for (const error of errors) console.error(`- ${error}`)
+  process.exit(1)
+}
+
+console.log("Validated " + suite.tasks.length + " " + suiteName + " tasks; every hidden grader rejects its broken fixture.")

package/scripts/validate.mjs

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs"
+import { readFile, readdir } from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { validResourceID } from "../lib/ids.mjs"
+
+const root = process.env.UES_BUNDLE_ROOT
+  ? path.resolve(process.env.UES_BUNDLE_ROOT)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const skillsRoot = path.join(root, "global-config", "skills")
+const commandsRoot = path.join(root, "global-config", "commands")
+const agentsRoot = path.join(root, "global-config", "agents")
+const pluginsRoot = path.join(root, "global-config", "plugins")
+const errors = []
+const ids = new Set()
+
+function localMarkdownLinks(source) {
+  return [...source.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)]
+    .map((match) => match[1].trim())
+    .filter((value) =>
+      value &&
+      !value.startsWith("#") &&
+      !value.startsWith("http://") &&
+      !value.startsWith("https://") &&
+      !value.startsWith("mailto:"),
+    )
+}
+
+for (const entry of await readdir(skillsRoot, { withFileTypes: true })) {
+  if (!entry.isDirectory()) continue
+
+  const dir = path.join(skillsRoot, entry.name)
+  const file = path.join(dir, "SKILL.md")
+  if (!existsSync(file)) {
+    errors.push(`${entry.name}: missing SKILL.md`)
+    continue
+  }
+
+  const source = await readFile(file, "utf8")
+  const name = source.match(/^name:\s*([^\r\n]+)/m)?.[1]?.trim()
+  const description = source.match(/^description:\s*([^\r\n]+)/m)?.[1]?.trim()
+
+  if (!name) errors.push(`${entry.name}: missing name`)
+  if (!description) errors.push(`${entry.name}: missing description`)
+  if (name && name !== entry.name) errors.push(`${entry.name}: frontmatter name must match directory`)
+  if (!validResourceID(entry.name)) errors.push(`${entry.name}: invalid skill id`)
+  if (ids.has(entry.name)) errors.push(`${entry.name}: duplicate skill id`)
+  ids.add(entry.name)
+
+  for (const link of localMarkdownLinks(source)) {
+    const relative = link.split("#", 1)[0]
+    if (!relative) continue
+    if (!existsSync(path.resolve(dir, relative))) {
+      errors.push(`${entry.name}: broken local reference ${link}`)
+    }
+  }
+}
+
+const agentIDs = new Set()
+for (const entry of await readdir(agentsRoot, { withFileTypes: true })) {
+  if (!entry.isFile() || !entry.name.endsWith(".md")) continue
+  agentIDs.add(`ues-${entry.name.slice(0, -3)}`)
+}
+
+let commands = 0
+for (const entry of await readdir(commandsRoot, { withFileTypes: true })) {
+  if (!entry.isFile() || !entry.name.endsWith(".md")) continue
+  commands += 1
+  const id = entry.name.slice(0, -3)
+  if (!validResourceID(id)) errors.push(`${entry.name}: invalid command id`)
+  const source = await readFile(path.join(commandsRoot, entry.name), "utf8")
+  if (!source.includes("description:")) errors.push(`${entry.name}: missing command description`)
+  const agent = source.match(/^agent:\s*([^\r\n]+)/m)?.[1]?.trim()
+  if (agent?.startsWith("ues-") && !agentIDs.has(agent)) {
+    errors.push(`${entry.name}: references missing subagent ${agent}`)
+  }
+}
+
+let agents = 0
+for (const entry of await readdir(agentsRoot, { withFileTypes: true })) {
+  if (!entry.isFile() || !entry.name.endsWith(".md")) continue
+  agents += 1
+  const id = entry.name.slice(0, -3)
+  if (!validResourceID(id)) errors.push(`${entry.name}: invalid agent id`)
+  const source = await readFile(path.join(agentsRoot, entry.name), "utf8")
+  if (!source.includes("description:")) errors.push(`${entry.name}: missing agent description`)
+  if (!/mode:\s*subagent/.test(source)) errors.push(`${entry.name}: agent must use mode: subagent`)
+}
+
+if (ids.size < 39) errors.push(`expected at least 39 skills, found ${ids.size}`)
+if (commands < 11) errors.push(`expected at least 11 commands, found ${commands}`)
+if (agents < 10) errors.push(`expected at least 10 subagents, found ${agents}`)
+
+const routerIndex = path.join(pluginsRoot, "ues-router", "index.js")
+const routerCore = path.join(pluginsRoot, "ues-router", "router.js")
+const routerSafety = path.join(pluginsRoot, "ues-router", "safety.js")
+const routerCapabilities = path.join(pluginsRoot, "ues-router", "capabilities.js")
+if (!existsSync(routerIndex)) errors.push("missing OpenCode v2 router plugin entrypoint")
+if (!existsSync(routerCore)) errors.push("missing OpenCode v2 router core")
+if (!existsSync(routerSafety)) errors.push("missing OpenCode v2 safety gate")
+if (!existsSync(routerCapabilities)) errors.push("missing OpenCode v2 runtime capability probe")
+if (existsSync(routerIndex)) {
+  const source = await readFile(routerIndex, "utf8")
+  if (!source.includes('id: "ues-router"')) errors.push("v2 router plugin must declare stable id ues-router")
+  if (!source.includes('ctx.session.hook("prompt"')) errors.push("v2 router plugin must register prompt admission hook")
+  if (!source.includes('ctx.session.hook("context"')) errors.push("v2 router plugin must register context guardrail hook")
+  if (!source.includes('ctx.permission.hook("evaluate"')) errors.push("v2 router plugin must register permission safety hook")
+  if (!source.includes("ctx.tool.transform")) errors.push("v2 router plugin must register UES helper tools")
+  if (!source.includes('name: "dispatch_task"')) errors.push("v2 router plugin must expose fresh-context task dispatch")
+  if (!source.includes("ctx.session.create")) errors.push("v2 task dispatch must create a fresh session")
+  if (!source.includes("ctx.session.switchAgent")) errors.push("v2 task dispatch must select ues-executor")
+  if (!source.includes("ctx.session.switchModel")) errors.push("v2 task dispatch must support configured model escalation")
+  if (!source.includes("ctx.session.wait")) errors.push("v2 task dispatch must wait for executor completion")
+  if (!source.includes('name: "capabilities"')) errors.push("v7 router plugin must expose runtime capability inspection")
+  if (!source.includes('name: "task_policy"')) errors.push("v7 router plugin must expose adaptive task policy")
+  if (!source.includes('"work", "heartbeat"')) errors.push("v7 task dispatch must refresh task leases")
+}
+
+for (const name of ["process-runner.mjs","evidence-receipt.mjs","context-manifest.mjs","orchestrator-policy.mjs","worktree-sandbox.mjs","learning-engine.mjs","hermes-bridge.mjs","control-center.mjs"]) {
+  if (!existsSync(path.join(root, "lib", name))) errors.push(`missing V7 core module ${name}`)
+}
+
+for (const name of ["codebase-mapper.md","plan-checker.md","executor.md","integration-verifier.md"]) {
+  if (!existsSync(path.join(agentsRoot, name))) errors.push(`missing V6 subagent ${name}`)
+}
+
+if (errors.length) {
+  console.error("Validation failed:")
+  for (const error of errors) console.error(`- ${error}`)
+  process.exit(1)
+}
+
+console.log(`Validated ${ids.size} skills, ${commands} commands and ${agents} subagents.`)