opencode-agent-skill 15.1.0 → 15.1.1

package/lib/memory-engine.mjs

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto"
 import { existsSync } from "node:fs"
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { evidenceExists, putEvidence } from "./evidence-store.mjs"
@@ -16,6 +16,72 @@ const STOP = new Set([
   "file","files","change","changes","được","các","cho","với","trong","này","một","những","không","theo",
 ])
 
+const MEMORY_WRITE_TAILS = new Map()
+const MEMORY_LOCK_STALE_MS = 15_000
+const MEMORY_LOCK_WAIT_MS = 20_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function memoryLockPath(root) {
+  return path.join(path.resolve(root), MEMORY_DIR, ".memory-write.lock")
+}
+
+async function withCrossProcessMemoryLock(root, fn) {
+  const lockDir = memoryLockPath(root)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + MEMORY_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 > MEMORY_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 memory write 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 withMemoryWriteLock(root, fn) {
+  const key = path.resolve(root)
+  const previous = MEMORY_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  MEMORY_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessMemoryLock(root, fn)
+  } finally {
+    release()
+    if (MEMORY_WRITE_TAILS.get(key) === tail) MEMORY_WRITE_TAILS.delete(key)
+  }
+}
+
 function now() {
   return new Date().toISOString()
 }
@@ -118,55 +184,58 @@ export async function proposeMemory(root, input = {}) {
   if (!content) throw new Error("memory content is required")
   const type = VALID_TYPES.has(input.type) ? input.type : "episodic"
   const scope = VALID_SCOPES.has(input.scope) ? input.scope : "project"
-  const state = await readMemoryState(root)
   const id = idFor({ ...input, type, scope, content })
-  const timestamp = now()
-  const existing = state.memories.find((item) => item.id === id) ||
-    state.memories.find((item) => sameMemoryIdentity(item, { ...input, type, scope, content }))
-  if (existing) {
-    const reinforced = {
-      ...existing,
-      lastSeenAt: timestamp,
-      reinforcementCount: Number(existing.reinforcementCount || 1) + 1,
-      evidenceRefs: uniq([...(existing.evidenceRefs || []), ...(input.evidenceRefs || [])]),
-      files: uniq([...(existing.files || []), ...(input.files || []).map(normalizeFile)]),
-      dependencies: uniq([...(existing.dependencies || []), ...(input.dependencies || []).map(normalizeFile)]),
-      tags: uniq([...(existing.tags || []), ...(input.tags || [])]),
-      confidence: Math.max(clamp(existing.confidence), clamp(input.confidence, existing.confidence ?? 0.7)),
-      taskClass: input.taskClass || existing.taskClass || null,
-      expiresAt: input.expiresAt || existing.expiresAt || null,
+
+  return withMemoryWriteLock(root, async () => {
+    const state = await readMemoryState(root)
+    const timestamp = now()
+    const existing = state.memories.find((item) => item.id === id) ||
+      state.memories.find((item) => sameMemoryIdentity(item, { ...input, type, scope, content }))
+    if (existing) {
+      const reinforced = {
+        ...existing,
+        lastSeenAt: timestamp,
+        reinforcementCount: Number(existing.reinforcementCount || 1) + 1,
+        evidenceRefs: uniq([...(existing.evidenceRefs || []), ...(input.evidenceRefs || [])]),
+        files: uniq([...(existing.files || []), ...(input.files || []).map(normalizeFile)]),
+        dependencies: uniq([...(existing.dependencies || []), ...(input.dependencies || []).map(normalizeFile)]),
+        tags: uniq([...(existing.tags || []), ...(input.tags || [])]),
+        confidence: Math.max(clamp(existing.confidence), clamp(input.confidence, existing.confidence ?? 0.7)),
+        taskClass: input.taskClass || existing.taskClass || null,
+        expiresAt: input.expiresAt || existing.expiresAt || null,
+      }
+      await writeMemoryState(root, state.memories.map((item) => item.id === existing.id ? reinforced : item))
+      return reinforced
     }
-    await writeMemoryState(root, state.memories.map((item) => item.id === id ? reinforced : item))
-    return reinforced
-  }
 
-  const memory = {
-    id,
-    key: input.key || null,
-    type,
-    scope,
-    content,
-    status: "candidate",
-    confidence: clamp(input.confidence),
-    evidenceRefs: uniq(input.evidenceRefs || []),
-    files: uniq((input.files || []).map(normalizeFile)),
-    dependencies: uniq((input.dependencies || []).map(normalizeFile)),
-    tags: uniq(input.tags || []),
-    sourceTask: input.sourceTask || null,
-    sourceCommit: input.sourceCommit || null,
-    taskClass: input.taskClass || null,
-    expiresAt: input.expiresAt || null,
-    createdAt: timestamp,
-    lastSeenAt: timestamp,
-    lastUsedAt: null,
-    useCount: 0,
-    reinforcementCount: 1,
-    verifiedAt: null,
-    verifier: null,
-    supersededBy: null,
-  }
-  await writeMemoryState(root, [...state.memories, memory])
-  return memory
+    const memory = {
+      id,
+      key: input.key || null,
+      type,
+      scope,
+      content,
+      status: "candidate",
+      confidence: clamp(input.confidence),
+      evidenceRefs: uniq(input.evidenceRefs || []),
+      files: uniq((input.files || []).map(normalizeFile)),
+      dependencies: uniq((input.dependencies || []).map(normalizeFile)),
+      tags: uniq(input.tags || []),
+      sourceTask: input.sourceTask || null,
+      sourceCommit: input.sourceCommit || null,
+      taskClass: input.taskClass || null,
+      expiresAt: input.expiresAt || null,
+      createdAt: timestamp,
+      lastSeenAt: timestamp,
+      lastUsedAt: null,
+      useCount: 0,
+      reinforcementCount: 1,
+      verifiedAt: null,
+      verifier: null,
+      supersededBy: null,
+    }
+    await writeMemoryState(root, [...state.memories, memory])
+    return memory
+  })
 }
 
 export async function verifyMemory(root, id, verification = {}) {
@@ -174,47 +243,52 @@ export async function verifyMemory(root, id, verification = {}) {
     throw new Error("memory verification requires verdict PASS")
   }
   if (!verification.verifier) throw new Error("memory verification requires an independent verifier identity")
-  const state = await readMemoryState(root)
-  const current = state.memories.find((item) => item.id === id)
-  if (!current) throw new Error("unknown memory: " + id)
-  if (current.status === "superseded") throw new Error("cannot verify a superseded memory")
-
-  const refs = uniq([...(current.evidenceRefs || []), ...(verification.evidenceRefs || [])])
-  if (!refs.length) throw new Error("memory verification requires at least one durable evidence reference")
-  for (const ref of refs) {
-    if (!(await evidenceExists(root, ref))) throw new Error("memory evidence reference is missing: " + ref)
-  }
 
-  const verified = {
-    ...current,
-    status: "verified",
-    evidenceRefs: refs,
-    verifier: String(verification.verifier),
-    verifiedAt: now(),
-    lastSeenAt: now(),
-    confidence: Math.max(clamp(current.confidence), clamp(verification.confidence, current.confidence ?? 0.7)),
-  }
-  await writeMemoryState(root, state.memories.map((item) => item.id === id ? verified : item))
-  return verified
+  return withMemoryWriteLock(root, async () => {
+    const state = await readMemoryState(root)
+    const current = state.memories.find((item) => item.id === id)
+    if (!current) throw new Error("unknown memory: " + id)
+    if (current.status === "superseded") throw new Error("cannot verify a superseded memory")
+
+    const refs = uniq([...(current.evidenceRefs || []), ...(verification.evidenceRefs || [])])
+    if (!refs.length) throw new Error("memory verification requires at least one durable evidence reference")
+    for (const ref of refs) {
+      if (!(await evidenceExists(root, ref))) throw new Error("memory evidence reference is missing: " + ref)
+    }
+
+    const verified = {
+      ...current,
+      status: "verified",
+      evidenceRefs: refs,
+      verifier: String(verification.verifier),
+      verifiedAt: now(),
+      lastSeenAt: now(),
+      confidence: Math.max(clamp(current.confidence), clamp(verification.confidence, current.confidence ?? 0.7)),
+    }
+    await writeMemoryState(root, state.memories.map((item) => item.id === id ? verified : item))
+    return verified
+  })
 }
 
 export async function supersedeMemory(root, id, replacementId) {
   if (!replacementId || replacementId === id) throw new Error("replacement memory id must be different")
-  const state = await readMemoryState(root)
-  const current = state.memories.find((item) => item.id === id)
-  const replacement = state.memories.find((item) => item.id === replacementId)
-  if (!current) throw new Error("unknown memory: " + id)
-  if (!replacement) throw new Error("unknown replacement memory: " + replacementId)
-  if (replacement.status !== "verified") throw new Error("replacement memory must be verified before supersession")
-  const timestamp = now()
-  const superseded = {
-    ...current,
-    status: "superseded",
-    supersededBy: replacementId,
-    lastSeenAt: timestamp,
-  }
-  await writeMemoryState(root, state.memories.map((item) => item.id === id ? superseded : item))
-  return superseded
+  return withMemoryWriteLock(root, async () => {
+    const state = await readMemoryState(root)
+    const current = state.memories.find((item) => item.id === id)
+    const replacement = state.memories.find((item) => item.id === replacementId)
+    if (!current) throw new Error("unknown memory: " + id)
+    if (!replacement) throw new Error("unknown replacement memory: " + replacementId)
+    if (replacement.status !== "verified") throw new Error("replacement memory must be verified before supersession")
+    const timestamp = now()
+    const superseded = {
+      ...current,
+      status: "superseded",
+      supersededBy: replacementId,
+      lastSeenAt: timestamp,
+    }
+    await writeMemoryState(root, state.memories.map((item) => item.id === id ? superseded : item))
+    return superseded
+  })
 }
 
 function tokenVector(value, dims = 96) {
@@ -550,9 +624,12 @@ export async function retrieveMemories(root, query, options = {}) {
   if (options.touch === true && results.length) {
     const used = new Set(results.map((item) => item.id))
     const timestamp = now()
-    await writeMemoryState(root, state.memories.map((item) => used.has(item.id)
-      ? { ...item, lastUsedAt: timestamp, useCount: Number(item.useCount || 0) + 1 }
-      : item))
+    await withMemoryWriteLock(root, async () => {
+      const latest = await readMemoryState(root)
+      await writeMemoryState(root, latest.memories.map((item) => used.has(item.id)
+        ? { ...item, lastUsedAt: timestamp, useCount: Number(item.useCount || 0) + 1 }
+        : item))
+    })
   }
   return {
     schemaVersion: SCHEMA_VERSION,

package/lib/model-config.mjs

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
 import { defaultModelPolicy, resolveModel } from "./model-policy.mjs"
 import { normalizeCapabilityProfile } from "./capability-registry.mjs"
@@ -7,6 +7,70 @@ import { normalizePerformanceHistory, recordPerformanceOutcome } from "./model-p
 
 const TIERS = new Set(["light", "standard", "heavy"])
 
+const MODEL_POLICY_WRITE_TAILS = new Map()
+const MODEL_POLICY_LOCK_STALE_MS = 15_000
+const MODEL_POLICY_LOCK_WAIT_MS = 20_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function modelPolicyLockDir(configDir) {
+  return modelPolicyFile(configDir) + ".lock"
+}
+
+async function withCrossProcessModelPolicyLock(configDir, fn) {
+  const lockDir = modelPolicyLockDir(configDir)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + MODEL_POLICY_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 > MODEL_POLICY_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 model-policy write 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 withModelPolicyWriteLock(configDir, fn) {
+  const key = path.resolve(configDir)
+  const previous = MODEL_POLICY_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  MODEL_POLICY_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessModelPolicyLock(configDir, fn)
+  } finally {
+    release()
+    if (MODEL_POLICY_WRITE_TAILS.get(key) === tail) MODEL_POLICY_WRITE_TAILS.delete(key)
+  }
+}
+
 function validModelID(value) {
   return typeof value === "string" && /^[^\s/]+\/[^\s#]+(?:#[^\s]+)?$/.test(value)
 }
@@ -61,8 +125,7 @@ export async function readModelPolicy(configDir) {
   }
 }
 
-export async function writeModelPolicy(configDir, patch = {}) {
-  const current = await readModelPolicy(configDir)
+async function persistModelPolicy(configDir, current, patch = {}) {
   const merged = normalize({
     ...current,
     ...patch,
@@ -73,10 +136,24 @@ export async function writeModelPolicy(configDir, patch = {}) {
   })
   const file = modelPolicyFile(configDir)
   await mkdir(path.dirname(file), { recursive: true })
-  await writeFile(file, JSON.stringify(merged, null, 2) + "\n", "utf8")
+  const temp = file + "." + process.pid + "." + Date.now() + ".tmp"
+  await writeFile(temp, JSON.stringify(merged, null, 2) + "\n", "utf8")
+  try {
+    await rename(temp, file)
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => {})
+    throw error
+  }
   return { ...merged, file }
 }
 
+export async function writeModelPolicy(configDir, patch = {}) {
+  return withModelPolicyWriteLock(configDir, async () => {
+    const current = await readModelPolicy(configDir)
+    return persistModelPolicy(configDir, current, patch)
+  })
+}
+
 export function validateModelID(value) {
   return validModelID(value)
 }
@@ -102,7 +179,9 @@ export function applyConfiguredModel(source, role, policy) {
 }
 
 export async function recordModelPerformance(configDir, outcome = {}) {
-  const current = await readModelPolicy(configDir)
-  const performance = recordPerformanceOutcome(current.performance || {}, outcome)
-  return writeModelPolicy(configDir, { performance })
+  return withModelPolicyWriteLock(configDir, async () => {
+    const current = await readModelPolicy(configDir)
+    const performance = recordPerformanceOutcome(current.performance || {}, outcome)
+    return persistModelPolicy(configDir, current, { performance })
+  })
 }

package/lib/performance-fabric.mjs

@@ -91,6 +91,73 @@ function gitDiffRows(source, limit = 140) {
   ], limit)
 }
 
+function gitStatusRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^##\s+/,
+    /^On branch\s+/i,
+    /^Your branch\s+/i,
+    /^Changes to be committed:/i,
+    /^Changes not staged for commit:/i,
+    /^Untracked files:/i,
+    /^Unmerged paths:/i,
+    /^\s*(?:nothing to commit|working tree clean)/i,
+    /^[ MARCUD?!]{1,2}\s+\S+/,
+  ], limit)
+}
+
+function gitLogRows(source, limit = 100) {
+  return matchingLines(source, [
+    /^commit\s+[0-9a-f]{7,40}\b/i,
+    /^Author:\s+/i,
+    /^Date:\s+/i,
+    /^Merge:\s+/i,
+    /^\s{4}\S+/,
+    /^fatal:/i,
+    /^error:/i,
+  ], limit)
+}
+
+function verificationTestRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^(?:ok|FAIL)\s+\S+/,
+    /^---\s+(?:PASS|FAIL):\s+/,
+    /^test result:\s+(?:ok|FAILED)\b/i,
+    /^failures?:/i,
+    /^running\s+\d+\s+tests?/i,
+    /^Finished\s+test\b/i,
+    /^Total tests:\s*\d+/i,
+    /^\s*(?:Passed|Failed|Skipped):\s*\d+/i,
+    /\b(?:panic|assertion failed|FAILED|FAILURE|ERROR)\b/i,
+    /\berror\[E\d+\]/,
+    /\bBUILD\s+(?:SUCCESS|FAILURE)\b/i,
+    /\bTests run:\s*\d+/i,
+  ], limit)
+}
+
+function pythonLintRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^.+:\d+:\d+:\s+[A-Z]+\d+\s+/,
+    /^.+:\d+:\d+:\s+(?:error|warning)\b/i,
+    /^Found\s+\d+\s+errors?/i,
+    /^All checks passed!?$/i,
+    /^\d+\s+files?\s+(?:reformatted|left unchanged)/i,
+    /\b(?:error|warning|failed)\b/i,
+  ], limit)
+}
+
+function packageInstallRows(source, limit = 120) {
+  return matchingLines(source, [
+    /\b(?:added|removed|changed)\s+\d+\s+packages?\b/i,
+    /\baudited\s+\d+\s+packages?\b/i,
+    /\b\d+\s+packages?\s+(?:are\s+)?looking for funding\b/i,
+    /\b\d+\s+vulnerabilit(?:y|ies)\b/i,
+    /\b(?:deprecated|warning|warn|error|ERR!|ELIFECYCLE|ERR_)\b/i,
+    /^Packages:\s+[+-]?\d+/i,
+    /^Progress:\s+/i,
+    /^Done in\s+/i,
+  ], limit)
+}
+
 function rgRows(source, limit = 100) {
   const lines = String(source || "").split(/\r?\n/).filter(Boolean)
   const matched = []
@@ -213,6 +280,16 @@ const REDUCERS = Object.freeze([
     match: (hint) => /\b(?:pytest|py\.test)\b/.test(hint),
     rows: pytestRows,
   },
+  {
+    family: "git-status",
+    match: (hint) => /\bgit\s+status\b/.test(hint),
+    rows: gitStatusRows,
+  },
+  {
+    family: "git-log",
+    match: (hint) => /\bgit\s+log\b/.test(hint),
+    rows: gitLogRows,
+  },
   {
     family: "git-diff",
     match: (hint) => /\bgit\s+(?:diff|show)\b/.test(hint),
@@ -248,6 +325,21 @@ const REDUCERS = Object.freeze([
     match: (hint) => /\bprisma\b|schema\.prisma/.test(hint),
     rows: prismaRows,
   },
+  {
+    family: "package-install",
+    match: (hint) => /(?:^|\s)(?:npm\s+(?:i|install|ci)|pnpm\s+(?:i|install|add)|yarn\s+(?:install|add))(?:\s|$)/.test(hint),
+    rows: packageInstallRows,
+  },
+  {
+    family: "verification-test",
+    match: (hint) => /\b(?:go\s+test|cargo\s+test|dotnet\s+test|mvn\s+test|gradle\s+test)\b/.test(hint),
+    rows: verificationTestRows,
+  },
+  {
+    family: "python-lint",
+    match: (hint) => /\b(?:ruff|flake8|pylint)\b/.test(hint),
+    rows: pythonLintRows,
+  },
   {
     family: "build",
     match: (hint) => /\b(?:compile|build|gradle|maven|mvn|cargo\s+check|dotnet\s+build)\b/.test(hint),