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

package/lib/installer.mjs

@@ -23,6 +23,15 @@ function validManagedPlugin(value) {
   return value === ROUTER_PLUGIN_STATE
 }
 
+function validPromptAlias(value) {
+  if (typeof value !== "string" || !value.startsWith(SKILL_PREFIX)) return false
+  return validResourceID(value.slice(SKILL_PREFIX.length))
+}
+
+function promptAliasTemplateName(value) {
+  return value.slice(SKILL_PREFIX.length) + ".md"
+}
+
 function isOwnedPackageName(value) {
   return !value || value === PACKAGE_NAME || value === LEGACY_PACKAGE_NAME
 }
@@ -94,7 +103,7 @@ async function writeManagedFile(file, content, warnings) {
 
 async function readManagedState(file, warnings = []) {
   const raw = await readText(file)
-  if (!raw) return { kind: "empty", state: { skills: [], commands: [], agents: [], plugins: [] } }
+  if (!raw) return { kind: "empty", state: { skills: [], commands: [], promptAliases: [], agents: [], plugins: [] } }
 
   try {
     const parsed = JSON.parse(raw)
@@ -103,7 +112,7 @@ async function readManagedState(file, warnings = []) {
       return {
         kind: "foreign",
         package: parsed.package,
-        state: { skills: [], commands: [], agents: [], plugins: [] },
+        state: { skills: [], commands: [], promptAliases: [], agents: [], plugins: [] },
       }
     }
     return {
@@ -112,13 +121,14 @@ async function readManagedState(file, warnings = []) {
         ...parsed,
         skills: Array.isArray(parsed.skills) ? parsed.skills.filter(validSkillID) : [],
         commands: Array.isArray(parsed.commands) ? parsed.commands.filter(validManagedMarkdown) : [],
+        promptAliases: Array.isArray(parsed.promptAliases) ? parsed.promptAliases.filter(validPromptAlias) : [],
         agents: Array.isArray(parsed.agents) ? parsed.agents.filter(validManagedMarkdown) : [],
         plugins: Array.isArray(parsed.plugins) ? parsed.plugins.filter(validManagedPlugin) : [],
       },
     }
   } catch {
     warnings.push(`Invalid UES state file; run 'ocskill install' to rebuild it: ${file}`)
-    return { kind: "invalid", state: { skills: [], commands: [], agents: [], plugins: [] } }
+    return { kind: "invalid", state: { skills: [], commands: [], promptAliases: [], agents: [], plugins: [] } }
   }
 }
 
@@ -310,7 +320,7 @@ export async function installResources(options = {}) {
   const stateFile = path.join(stateDir, "state.json")
   const warnings = []
   const openCodeMajor = options.openCodeMajor ?? detectOpenCodeMajor()
-  const installed = { skills: [], commands: [], agents: [], plugins: [] }
+  const installed = { skills: [], commands: [], promptAliases: [], agents: [], plugins: [] }
   const previous = await readManagedState(stateFile, warnings)
   const previousState = previous.state
   const modelPolicy = await readModelPolicy(configDir)
@@ -366,25 +376,31 @@ export async function installResources(options = {}) {
 
   const sourceCommands = path.join(sourceRoot, "global-config", "commands")
   const commandEntries = await readdir(sourceCommands, { withFileTypes: true })
-
+  const validCommandEntries = []
   for (const entry of commandEntries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue
-
     const id = entry.name.slice(0, -3)
     if (!validResourceID(id)) {
       warnings.push(`Skipped command with invalid resource ID: ${id}`)
       continue
     }
-    const targetName = `${SKILL_PREFIX}${id}.md`
-    const targetFile = path.join(commandsTarget, targetName)
-    const source = await readFile(path.join(sourceCommands, entry.name), "utf8")
-    const normalizedSource = normalizeManagedMarker(source)
-    const content = hasManagedMarker(normalizedSource)
-      ? normalizedSource
-      : `${normalizedSource.trimEnd()}\n\n${MANAGED_MARKER}\n`
+    validCommandEntries.push(entry)
+  }
 
-    if (await writeManagedFile(targetFile, content, warnings)) {
-      installed.commands.push(targetName)
+  if (openCodeMajor < 2) {
+    for (const entry of validCommandEntries) {
+      const id = entry.name.slice(0, -3)
+      const targetName = `${SKILL_PREFIX}${id}.md`
+      const targetFile = path.join(commandsTarget, targetName)
+      const source = await readFile(path.join(sourceCommands, entry.name), "utf8")
+      const normalizedSource = normalizeManagedMarker(source)
+      const content = hasManagedMarker(normalizedSource)
+        ? normalizedSource
+        : `${normalizedSource.trimEnd()}\n\n${MANAGED_MARKER}\n`
+
+      if (await writeManagedFile(targetFile, content, warnings)) {
+        installed.commands.push(targetName)
+      }
     }
   }
 
@@ -425,6 +441,14 @@ export async function installResources(options = {}) {
     if (existsSync(path.join(sourcePluginDir, "index.js"))) {
       if (await installPluginDirectory(sourcePluginDir, targetPluginDir, warnings)) {
         installed.plugins.push(ROUTER_PLUGIN_STATE)
+
+        const promptAliasDir = path.join(targetPluginDir, "command-templates")
+        await mkdir(promptAliasDir, { recursive: true })
+        for (const entry of validCommandEntries) {
+          const id = entry.name.slice(0, -3)
+          await cp(path.join(sourceCommands, entry.name), path.join(promptAliasDir, entry.name))
+          installed.promptAliases.push(`${SKILL_PREFIX}${id}`)
+        }
       }
     }
 
@@ -457,7 +481,7 @@ export async function installResources(options = {}) {
   }
 
   const state = {
-    schemaVersion: 2,
+    schemaVersion: 3,
     package: PACKAGE_NAME,
     version: await packageVersion(),
     configDir,
@@ -465,6 +489,7 @@ export async function installResources(options = {}) {
     openCodeMajor,
     skills: installed.skills.sort(),
     commands: installed.commands.sort(),
+    promptAliases: installed.promptAliases.sort(),
     agents: installed.agents.sort(),
     plugins: installed.plugins.sort(),
   }
@@ -611,11 +636,13 @@ export async function getStatus() {
 
   state.skills = Array.isArray(state.skills) ? state.skills.filter(validSkillID) : []
   state.commands = Array.isArray(state.commands) ? state.commands.filter(validManagedMarkdown) : []
+  state.promptAliases = Array.isArray(state.promptAliases) ? state.promptAliases.filter(validPromptAlias) : []
   state.agents = Array.isArray(state.agents) ? state.agents.filter(validManagedMarkdown) : []
   state.plugins = Array.isArray(state.plugins) ? state.plugins.filter(validManagedPlugin) : []
 
   let skillsPresent = 0
   let commandsPresent = 0
+  let promptAliasesPresent = 0
   let agentsPresent = 0
   let pluginsPresent = 0
 
@@ -625,6 +652,11 @@ export async function getStatus() {
   for (const name of state.commands || []) {
     if (existsSync(path.join(configDir, "commands", name))) commandsPresent += 1
   }
+  for (const name of state.promptAliases || []) {
+    if (existsSync(path.join(configDir, "plugins", "ues-router", "command-templates", promptAliasTemplateName(name)))) {
+      promptAliasesPresent += 1
+    }
+  }
   for (const name of state.agents || []) {
     if (existsSync(path.join(configDir, "agents", name))) agentsPresent += 1
   }
@@ -639,6 +671,7 @@ export async function getStatus() {
     ...state,
     skillsPresent,
     commandsPresent,
+    promptAliasesPresent,
     agentsPresent,
     pluginsPresent,
     workflowPresent: agents.includes(AGENTS_BEGIN),

package/lib/task-engine.mjs

@@ -1,9 +1,9 @@
 import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs"
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
+import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import { createHash, randomUUID } from "node:crypto"
 import path from "node:path"
-import { analyzePlan, taskFiles, validatePlan } from "./task-graph.mjs"
+import { analyzePlan, taskFiles, taskVerificationCommands, validatePlan } from "./task-graph.mjs"
 import { buildContextManifest } from "./context-manifest.mjs"
 import { relevantAcceptedLearnings } from "./learning-engine.mjs"
 import { validateVerificationReceipt } from "./evidence-receipt.mjs"
@@ -17,6 +17,7 @@ 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"
+import { readTextAuto } from "./text-encoding.mjs"
 
 const WORK_DIR = ".ues-work"
 const STATE_SCHEMA = 4
@@ -59,7 +60,7 @@ export function workPaths(root, slug) {
 
 async function readJson(file, fallback = null) {
   try {
-    return JSON.parse(await readFile(file, "utf8"))
+    return JSON.parse(readTextAuto(file))
   } catch (error) {
     if (error?.code === "ENOENT") return fallback
     throw error
@@ -340,7 +341,7 @@ function currentEvidencePolicy(state, plan) {
 
 function taskBrief(task) {
   const files = taskFiles(task)
-  return `# ${task.id}: ${task.title}\n\n## Summary\n\n${task.summary || "No summary provided."}\n\n## Dependencies\n\n${(task.dependsOn || []).map((id) => `- ${id}`).join("\n") || "- None"}\n\n## Files\n\n${files.map((file) => `- ${file}`).join("\n") || "- Scope must be established before editing."}\n\n## Acceptance criteria\n\n${(task.acceptance || []).map((item) => `- ${item}`).join("\n")}\n\n## Verification\n\n${(task.verification || []).map((item) => `- ${item}`).join("\n")}\n\n## Risk\n\n${task.risk || "medium"}\n`
+  return `# ${task.id}: ${task.title}\n\n## Summary\n\n${task.summary || "No summary provided."}\n\n## Dependencies\n\n${(task.dependsOn || []).map((id) => `- ${id}`).join("\n") || "- None"}\n\n## Files\n\n${files.map((file) => `- ${file}`).join("\n") || "- Scope must be established before editing."}\n\n## Acceptance criteria\n\n${(task.acceptance || []).map((item) => `- ${item}`).join("\n")}\n\n## Verification\n\n${(task.verification || []).map((item) => `- ${item}`).join("\n")}\n\n## Structured verification commands\n\n${taskVerificationCommands(task).map((item) => `- ${[item.command, ...item.args].join(" ")}`).join("\n") || "- None declared"}\n\n## Risk\n\n${task.risk || "medium"}\n`
 }
 
 function planIsApproved(state, plan) {
@@ -351,7 +352,7 @@ function planIsApproved(state, plan) {
 
 export async function importPlan(root, slug, planInput) {
   const plan = typeof planInput === "string"
-    ? JSON.parse(await readFile(path.resolve(planInput), "utf8"))
+    ? JSON.parse(readTextAuto(path.resolve(planInput)))
     : planInput
 
   const validation = validatePlan(plan)
@@ -534,7 +535,9 @@ export async function workStatus(root, slug) {
       leaseExpiresAt: value.leaseExpiresAt || null,
     }))
   const taskEntries = Object.values(loaded.state.tasks || {})
-  const receiptBacked = taskEntries.filter((value) => value.evidenceStrength === "receipt-backed").length
+  const receiptBacked = taskEntries.filter((value) =>
+    ["receipt-backed", "command-receipt-backed", "independent-agent-receipt-backed"].includes(value.evidenceStrength)
+  ).length
   const completed = taskEntries.filter((value) => value.status === "completed").length
 
   return {
@@ -823,7 +826,13 @@ export async function completeTask(root, slug, taskID, options = {}) {
     record.status = "completed"
     record.completedAt = timestamp
     record.report = path.relative(loaded.paths.root, reportPath).replaceAll("\\", "/")
-    record.evidenceStrength = acceptedReceipts.length ? "receipt-backed" : "narrative"
+    const commandReceipts = acceptedReceipts.filter((item) => item.kind !== "agent-verifier")
+    const agentVerifierReceipts = acceptedReceipts.filter((item) => item.kind === "agent-verifier")
+    record.evidenceStrength = commandReceipts.length
+      ? "command-receipt-backed"
+      : agentVerifierReceipts.length
+        ? "independent-agent-receipt-backed"
+        : "narrative"
     record.runId = null
     record.owner = null
     record.heartbeatAt = null
@@ -1085,14 +1094,15 @@ export async function finalizeWork(root, slug, evidence) {
 async function buildContextPack(loaded, taskID) {
   if (!loaded.plan) throw new Error("PLAN.json is missing")
   const task = taskByID(loaded.plan, taskID)
-  const spec = await readFile(loaded.paths.spec, "utf8").catch(() => "")
+  let spec = ""
+  try { spec = readTextAuto(loaded.paths.spec) } catch {}
   const dependencyReports = {}
   const dependencyReportRefs = {}
 
   for (const dep of task.dependsOn || []) {
     const file = path.join(loaded.paths.reports, `${dep}.md`)
     if (!existsSync(file)) continue
-    const report = await readFile(file, "utf8")
+    const report = readTextAuto(file)
     dependencyReports[dep] = report.slice(0, 6000)
     const stored = await putEvidence(loaded.paths.root, report, {
       kind: "dependency-report",

package/lib/task-graph.mjs

@@ -48,6 +48,20 @@ export function taskReadFiles(task) {
   return [...new Set((files.read || []).map(normalizeFile).filter(Boolean))].sort()
 }
 
+
+export function taskVerificationCommands(task) {
+  if (!Array.isArray(task?.verificationCommands)) return []
+  return task.verificationCommands
+    .map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return null
+      const command = String(item.command || "").trim()
+      if (!command) return null
+      const args = Array.isArray(item.args) ? item.args.map((value) => String(value)) : []
+      return { command, args }
+    })
+    .filter(Boolean)
+}
+
 function taskMap(plan) {
   return new Map((plan?.tasks || []).map((task) => [task.id, task]))
 }
@@ -97,6 +111,24 @@ export function validatePlan(plan) {
       errors.push(`${id || prefix}: verification must contain at least one concrete check`)
     }
 
+    if (task.verificationCommands !== undefined) {
+      if (!Array.isArray(task.verificationCommands)) {
+        errors.push(`${id || prefix}.verificationCommands must be an array when provided`)
+      } else {
+        for (const [commandIndex, commandSpec] of task.verificationCommands.entries()) {
+          const commandPrefix = `${id || prefix}.verificationCommands[${commandIndex}]`
+          if (!commandSpec || typeof commandSpec !== "object" || Array.isArray(commandSpec)) {
+            errors.push(`${commandPrefix} must be an object`)
+            continue
+          }
+          if (!String(commandSpec.command || "").trim()) errors.push(`${commandPrefix}.command is required`)
+          if (commandSpec.args !== undefined && !Array.isArray(commandSpec.args)) {
+            errors.push(`${commandPrefix}.args must be an array when provided`)
+          }
+        }
+      }
+    }
+
     const risk = task.risk ?? "medium"
     if (!VALID_RISKS.has(risk)) errors.push(`${id || prefix}: invalid risk '${risk}'`)
 

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/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": "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",
+  "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 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",
+    "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",
@@ -51,7 +51,8 @@
     "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"
+    "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

@@ -130,6 +130,35 @@ export function checkReleaseConsistency(root) {
     }
   }
 
+  // 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) {
@@ -164,7 +193,7 @@ export function checkReleaseConsistency(root) {
     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","evals:repo-scale:validate"]) {
+    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 {
@@ -196,6 +225,9 @@ export function checkReleaseConsistency(root) {
     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 {