opencode-agent-skill 15.1.0 → 15.1.2

package/lib/decision-policy.mjs

@@ -2,6 +2,21 @@ const HIGH_RISK = /(npm publish|publish package|deploy|production|git push|force
 const MEDIUM_RISK = /(migration|schema|dependency upgrade|lockfile|generated code|shared config|auth|permission|security)/i
 const REVERSIBLE = /(local|test|rename|format|refactor|temporary|fixture|internal|reversible)/i
 
+function confidenceForDecision(input = {}) {
+  if (input.requiresUser === true && (input.destructive === true || input.externalSideEffect === true || input.explicitlyIrreversible === true)) return 0.99
+  if (input.reversible === true && input.risk === "low") return 0.96
+  if (input.risk === "medium") return 0.82
+  if (input.requiresUser === true) return 0.90
+  return 0.74
+}
+
+function confidenceBand(value) {
+  const score = Number(value || 0)
+  if (score >= 0.90) return "high"
+  if (score >= 0.72) return "medium"
+  return "low"
+}
+
 export function classifyDecisionPolicy(text = "", facts = {}) {
   const value = String(text || "").trim()
   const explicitlyIrreversible = facts.irreversible === true
@@ -11,10 +26,33 @@ export function classifyDecisionPolicy(text = "", facts = {}) {
   const reversible = facts.reversible === true || (!destructive && REVERSIBLE.test(value))
   const risk = destructive || explicitlyIrreversible || externalSideEffect ? "high" : medium ? "medium" : "low"
   const requiresUser = risk === "high" || facts.productDecision === true
+  const autoResolvable = !requiresUser && (reversible || risk === "low")
+  const confidence = confidenceForDecision({
+    requiresUser,
+    destructive,
+    externalSideEffect,
+    explicitlyIrreversible,
+    reversible,
+    risk,
+  })
   return {
-    schemaVersion: 1, risk, reversible, destructive, externalSideEffect, requiresUser,
-    autoResolvable: !requiresUser && (reversible || risk === "low"),
+    schemaVersion: 1,
+    risk,
+    reversible,
+    destructive,
+    externalSideEffect,
+    requiresUser,
+    autoResolvable,
     reason: requiresUser ? "human-approval-required" : reversible ? "reversible-local-decision" : "bounded-engineering-decision",
+    decision: {
+      schemaVersion: 1,
+      kind: String(facts.decisionKind || "engineering-choice"),
+      source: "deterministic",
+      value: requiresUser ? "escalate-to-user" : autoResolvable ? "auto-resolve" : "bounded-review",
+      confidence,
+      confidenceBand: confidenceBand(confidence),
+      crossCheckRecommended: confidence < 0.72 || risk === "medium",
+    },
   }
 }
 

package/lib/evidence-store.mjs

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto"
 import { existsSync } from "node:fs"
-import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises"
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
 
 const STORE_VERSION = 1
@@ -12,6 +12,82 @@ const AUTO_GC_EVERY_WRITES = 8
 const AUTO_GC_LARGE_ITEM_BYTES = 16 * 1024 * 1024
 const PUT_COUNTS = new Map()
 
+const STORE_MUTATION_TAILS = new Map()
+const STORE_LOCK_STALE_MS = 30_000
+const STORE_LOCK_WAIT_MS = 40_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function storeLockPath(root) {
+  return path.join(evidenceStoreRoot(root), ".mutation.lock")
+}
+
+async function withCrossProcessStoreLock(root, fn) {
+  const lockDir = storeLockPath(root)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + STORE_LOCK_WAIT_MS
+  let delayMs = 8
+  while (true) {
+    try {
+      await mkdir(lockDir)
+      break
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      const info = await stat(lockDir).catch(() => null)
+      if (info && Date.now() - info.mtimeMs > STORE_LOCK_STALE_MS) {
+        const confirmed = await stat(lockDir).catch(() => null)
+        if (
+          confirmed &&
+          confirmed.ino === info.ino &&
+          confirmed.mtimeMs === info.mtimeMs
+        ) {
+          await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+          continue
+        }
+      }
+      if (Date.now() >= deadline) throw new Error("Timed out waiting for evidence-store mutation lock")
+      await sleep(delayMs)
+      delayMs = Math.min(100, delayMs * 2)
+    }
+  }
+  try {
+    return await fn()
+  } finally {
+    await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+async function withStoreMutationLock(root, fn) {
+  const key = path.resolve(root)
+  const previous = STORE_MUTATION_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  STORE_MUTATION_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessStoreLock(root, fn)
+  } finally {
+    release()
+    if (STORE_MUTATION_TAILS.get(key) === tail) STORE_MUTATION_TAILS.delete(key)
+  }
+}
+
+async function atomicWrite(file, value, encoding) {
+  await mkdir(path.dirname(file), { recursive: true })
+  const temp = file + "." + process.pid + "." + Date.now() + ".tmp"
+  await writeFile(temp, value, encoding)
+  try {
+    await rename(temp, file)
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => {})
+    throw error
+  }
+}
+
 function boundedNumber(value, fallback, min, max) {
   const parsed = Number(value)
   if (!Number.isFinite(parsed)) return fallback
@@ -104,42 +180,50 @@ export async function putEvidence(root, value, options = {}) {
   const encoded = toBytes(value, options)
   const hash = createHash("sha256").update(encoded.bytes).digest("hex")
   const target = evidencePaths(root, hash)
-  await mkdir(target.dir, { recursive: true })
 
-  const now = new Date().toISOString()
-  const existing = existsSync(target.meta)
-    ? JSON.parse(await readFile(target.meta, "utf8").catch(() => "{}"))
-    : null
+  const mutation = await withStoreMutationLock(root, async () => {
+    await mkdir(target.dir, { recursive: true })
+    const now = new Date().toISOString()
+    const existing = existsSync(target.meta)
+      ? JSON.parse(await readFile(target.meta, "utf8").catch(() => "{}"))
+      : null
 
-  if (!existsSync(target.data)) await writeFile(target.data, encoded.bytes)
+    if (!existsSync(target.data)) {
+      await atomicWrite(target.data, encoded.bytes)
+    }
 
-  const preview = encoded.encoding === "utf8"
-    ? encoded.bytes.toString("utf8", 0, Math.min(encoded.bytes.length, 600))
-    : null
+    const preview = encoded.encoding === "utf8"
+      ? encoded.bytes.toString("utf8", 0, Math.min(encoded.bytes.length, 600))
+      : null
 
-  const metadata = {
-    schemaVersion: STORE_VERSION,
-    ref: evidenceReference(hash),
-    sha256: hash,
-    bytes: encoded.bytes.length,
-    encoding: encoded.encoding,
-    mediaType: encoded.mediaType,
-    kind: options.kind || existing?.kind || "tool-output",
-    source: options.source || existing?.source || null,
-    summary: options.summary || existing?.summary || null,
-    createdAt: existing?.createdAt || now,
-    lastSeenAt: now,
-    preview,
-  }
-  await writeFile(target.meta, JSON.stringify(metadata, null, 2) + "\n", "utf8")
+    const metadata = {
+      schemaVersion: STORE_VERSION,
+      ref: evidenceReference(hash),
+      sha256: hash,
+      bytes: encoded.bytes.length,
+      encoding: encoded.encoding,
+      mediaType: encoded.mediaType,
+      kind: options.kind || existing?.kind || "tool-output",
+      source: options.source || existing?.source || null,
+      summary: options.summary || existing?.summary || null,
+      createdAt: existing?.createdAt || now,
+      lastSeenAt: now,
+      preview,
+    }
+    await atomicWrite(target.meta, JSON.stringify(metadata, null, 2) + "\n", "utf8")
 
-  const writes = (PUT_COUNTS.get(root) || 0) + 1
-  PUT_COUNTS.set(root, writes)
-  if (writes % AUTO_GC_EVERY_WRITES === 0 || encoded.bytes.length >= AUTO_GC_LARGE_ITEM_BYTES) {
+    const writes = (PUT_COUNTS.get(root) || 0) + 1
+    PUT_COUNTS.set(root, writes)
+    return {
+      metadata,
+      shouldGc: writes % AUTO_GC_EVERY_WRITES === 0 || encoded.bytes.length >= AUTO_GC_LARGE_ITEM_BYTES,
+    }
+  })
+
+  if (mutation.shouldGc) {
     await gcEvidenceStore(root, defaultStoreLimits()).catch(() => null)
   }
-
-  return metadata
+  return mutation.metadata
 }
 
 export async function getEvidence(root, ref, options = {}) {
@@ -275,7 +359,7 @@ export async function evidenceStoreStatus(root = process.cwd()) {
   }
 }
 
-export async function gcEvidenceStore(root = process.cwd(), options = {}) {
+async function gcEvidenceStoreUnlocked(root = process.cwd(), options = {}) {
   root = path.resolve(root)
   const files = await metadataFiles(root)
   const defaults = defaultStoreLimits()
@@ -332,6 +416,12 @@ export async function gcEvidenceStore(root = process.cwd(), options = {}) {
   }
 }
 
+
+export async function gcEvidenceStore(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  return withStoreMutationLock(root, () => gcEvidenceStoreUnlocked(root, options))
+}
+
 export async function evidenceExists(root, ref) {
   try {
     const target = evidencePaths(root, normalizeHash(ref))

package/lib/executable-probe.mjs

@@ -0,0 +1,69 @@
+import { accessSync, constants as fsConstants } from "node:fs"
+import path from "node:path"
+
+const DEFAULT_TTL_MS = 60_000
+const commandProbeCache = new Map()
+
+function executableFile(target) {
+  try {
+    accessSync(target, process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function probeKey(name) {
+  return [
+    name,
+    String(process.env.PATH || ""),
+    process.platform === "win32" ? String(process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD") : "",
+  ].join("\u0000")
+}
+
+export function commandExists(command, options = {}) {
+  if (!command) return false
+  const name = String(command).trim()
+  if (!name) return false
+
+  const ttlMs = Math.max(0, Number(options.ttlMs ?? DEFAULT_TTL_MS))
+  const key = probeKey(name)
+  const now = Date.now()
+  const cached = commandProbeCache.get(key)
+  if (cached && now - cached.checkedAt < ttlMs) return cached.available
+
+  const hasPath = path.isAbsolute(name) || name.includes("/") || name.includes("\\")
+  let available = false
+  if (hasPath) {
+    available = executableFile(path.resolve(name))
+  } else {
+    const dirs = String(process.env.PATH || "")
+      .split(path.delimiter)
+      .map((item) => item.trim().replace(/^"|"$/g, ""))
+      .filter(Boolean)
+    const extension = path.extname(name)
+    const suffixes = process.platform === "win32" && !extension
+      ? String(process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+          .split(";")
+          .map((item) => item.trim())
+          .filter(Boolean)
+      : [""]
+
+    outer:
+    for (const dir of dirs) {
+      for (const suffix of suffixes) {
+        if (executableFile(path.join(dir, name + suffix))) {
+          available = true
+          break outer
+        }
+      }
+    }
+  }
+
+  commandProbeCache.set(key, { available, checkedAt: now })
+  return available
+}
+
+export function clearExecutableProbeCache() {
+  commandProbeCache.clear()
+}

package/lib/execution-contract.mjs

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto"
 import { spawnSync } from "node:child_process"
 import { lstatSync, readFileSync, readlinkSync } from "node:fs"
 import path from "node:path"
-import { sourceFacingPaths } from "./runtime-artifacts.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const PHASE_HEADING = /^\s*(?:=+\s*)?PHASE\s+(\d+)\s*(?:[—–:-]+)\s*(.+?)\s*$/i
 const LOCAL_ENV_BASENAME = /^\.env(?:\.[^/\\]+)?$/i
@@ -187,7 +187,7 @@ export function captureInheritedDirtyState(root, options = {}) {
   ) {
     statusOutput = workspaceState.statusOutput
   } else {
-    const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+    const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...sourceGitPathspecs()], {
       cwd: resolved,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024,

package/lib/hierarchical-context.mjs

@@ -3,6 +3,7 @@ import { buildSemanticIndex } from "./semantic-index.mjs"
 
 const DEFAULT_L0 = 256
 const DEFAULT_L1 = 4000
+let HIERARCHY_RUNTIME_CACHE = new WeakMap()
 const STOP = new Set([
   "this","that","with","from","into","then","than","when","where","what","your","have","will",
   "task","code","file","files","fix","update","change","changes","được","các","cho","với","trong","này","một","những","không","theo",
@@ -84,6 +85,20 @@ export async function buildContextHierarchy(root = process.cwd(), options = {})
     maxFiles: options.maxFiles ?? 6000,
     maxDepth: options.maxDepth ?? 14,
   })
+  const l0Limit = Math.max(96, Number(options.l0Chars || DEFAULT_L0))
+  const l1Limit = Math.max(512, Number(options.l1Chars || DEFAULT_L1))
+  const indexObject = built?.index && typeof built.index === "object" ? built.index : null
+  const cacheKey = [root, l0Limit, l1Limit].join("\u0000")
+  const cachedBucket = indexObject ? HIERARCHY_RUNTIME_CACHE.get(indexObject) : null
+  const cached = cachedBucket?.get(cacheKey)
+  if (cached) {
+    return {
+      ...cached,
+      stats: built.stats,
+      runtimeCacheHit: true,
+    }
+  }
+
   const nodes = new Map()
   const children = new Map()
   const ensure = (dir) => {
@@ -122,19 +137,27 @@ export async function buildContextHierarchy(root = process.cwd(), options = {})
     .map((node) => buildNodeSummary(node, children, options))
     .sort((a, b) => a.path.localeCompare(b.path))
 
-  return {
+  const result = {
     schemaVersion: 1,
     kind: "ues-context-hierarchy",
     root,
     generatedAt: new Date().toISOString(),
     levels: {
-      L0: { maxChars: Math.max(96, Number(options.l0Chars || DEFAULT_L0)), purpose: "routing abstract" },
-      L1: { maxChars: Math.max(512, Number(options.l1Chars || DEFAULT_L1)), purpose: "scope overview" },
+      L0: { maxChars: l0Limit, purpose: "routing abstract" },
+      L1: { maxChars: l1Limit, purpose: "scope overview" },
       L2: { purpose: "source excerpts loaded on demand by the context manifest" },
     },
     nodes: summaries,
     stats: built.stats,
+    runtimeCacheHit: false,
   }
+
+  if (indexObject) {
+    const bucket = cachedBucket || new Map()
+    bucket.set(cacheKey, result)
+    if (!cachedBucket) HIERARCHY_RUNTIME_CACHE.set(indexObject, bucket)
+  }
+  return result
 }
 
 function containsFile(scope, file) {
@@ -211,5 +234,10 @@ export async function queryContextHierarchy(root, query, options = {}) {
     levels: hierarchy.levels,
     scopes,
     stats: hierarchy.stats,
+    runtimeCacheHit: hierarchy.runtimeCacheHit === true,
   }
+}
+
+export function clearContextHierarchyRuntimeCache() {
+  HIERARCHY_RUNTIME_CACHE = new WeakMap()
 }