opencode-agent-skill 15.1.0 → 15.1.2

package/lib/learning-engine.mjs

@@ -1,11 +1,88 @@
 import { existsSync } from "node:fs"
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises"
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises"
 import { createHash } from "node:crypto"
 import path from "node:path"
 import { pairedBenchmarkConfidence } from "./benchmark-confidence.mjs"
 
 const LEARNING_DIR = ".ues-learning"
 const STATE_FILE = "LEARNINGS.json"
+const LEARNING_WRITE_TAILS = new Map()
+const LEARNING_LOCK_STALE_MS = 15_000
+const LEARNING_LOCK_WAIT_MS = 20_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function learningLockPath(root) {
+  return path.join(path.resolve(root), LEARNING_DIR, ".learning-write.lock")
+}
+
+async function withCrossProcessLearningLock(root, fn) {
+  const lockDir = learningLockPath(root)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + LEARNING_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 > LEARNING_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 learning 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 withLearningWriteLock(root, fn) {
+  const key = path.resolve(root)
+  const previous = LEARNING_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  LEARNING_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessLearningLock(root, fn)
+  } finally {
+    release()
+    if (LEARNING_WRITE_TAILS.get(key) === tail) LEARNING_WRITE_TAILS.delete(key)
+  }
+}
+
+async function atomicJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true })
+  const temp = file + "." + process.pid + "." + Date.now() + ".tmp"
+  await writeFile(temp, JSON.stringify(value, null, 2) + "\n", "utf8")
+  try {
+    await rename(temp, file)
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => {})
+    throw error
+  }
+}
 
 function idFor(type, key) {
   return createHash("sha256").update(type + ":" + key).digest("hex").slice(0, 16)
@@ -27,6 +104,22 @@ async function walkJson(dir, limit = 500) {
   return files
 }
 
+async function mapLimit(items, limit, worker) {
+  if (!items.length) return []
+  const output = new Array(items.length)
+  let cursor = 0
+  const width = Math.min(items.length, Math.max(1, Number(limit || 1)))
+  const runners = Array.from({ length: width }, async () => {
+    while (true) {
+      const index = cursor++
+      if (index >= items.length) return
+      output[index] = await worker(items[index], index)
+    }
+  })
+  await Promise.all(runners)
+  return output
+}
+
 function failureReasons(item) {
   const reasons = []
   if (item.timedOut) reasons.push("hard-timeout")
@@ -71,15 +164,15 @@ function clampRate(value) {
 
 export async function analyzeEvalTraces(evalDir) {
   const files = await walkJson(path.resolve(evalDir))
-  const results = []
-  for (const file of files) {
+  const batches = await mapLimit(files, 12, async (file) => {
     try {
       const payload = JSON.parse(await readFile(file, "utf8"))
-      for (const item of payload.results || []) {
-        results.push({ ...item, source: file })
-      }
-    } catch {}
-  }
+      return (payload.results || []).map((item) => ({ ...item, source: file }))
+    } catch {
+      return []
+    }
+  })
+  const results = batches.flat()
 
   const reasonCounters = new Map()
   const clusters = new Map()
@@ -186,48 +279,49 @@ export async function readLearningState(root) {
 }
 
 export async function saveLearningAnalysis(root, analysis) {
-  const dir = path.dirname(learningFile(root))
-  await mkdir(dir, { recursive: true })
-  const current = await readLearningState(root)
-  const acceptedIDs = new Set(current.accepted.map((item) => item.id))
-  const existing = new Map(current.proposals.map((item) => [item.id, item]))
-  const proposals = analysis.proposals
-    .filter((item) => !acceptedIDs.has(item.id))
-    .map((item) => ({
-      ...item,
-      firstProposedAt: existing.get(item.id)?.firstProposedAt || new Date().toISOString(),
-      lastAnalyzedAt: analysis.analyzedAt,
-    }))
-  const next = {
-    schemaVersion: 2,
-    updatedAt: new Date().toISOString(),
-    proposals,
-    accepted: current.accepted,
-  }
-  await writeFile(learningFile(root), JSON.stringify(next, null, 2) + "\n", "utf8")
-  return next
+  return withLearningWriteLock(root, async () => {
+    const current = await readLearningState(root)
+    const acceptedIDs = new Set(current.accepted.map((item) => item.id))
+    const existing = new Map(current.proposals.map((item) => [item.id, item]))
+    const proposals = analysis.proposals
+      .filter((item) => !acceptedIDs.has(item.id))
+      .map((item) => ({
+        ...item,
+        firstProposedAt: existing.get(item.id)?.firstProposedAt || new Date().toISOString(),
+        lastAnalyzedAt: analysis.analyzedAt,
+      }))
+    const next = {
+      schemaVersion: 2,
+      updatedAt: new Date().toISOString(),
+      proposals,
+      accepted: current.accepted,
+    }
+    await atomicJson(learningFile(root), next)
+    return next
+  })
 }
 
 // Backward-compatible manual acceptance. Shadow-required proposals remain excluded
 // from retrieval until they are promoted with measured benchmark improvement.
 export async function acceptLearning(root, id) {
-  const current = await readLearningState(root)
-  const item = current.proposals.find((entry) => entry.id === id)
-  if (!item) throw new Error("unknown learning proposal: " + id)
-  const accepted = {
-    ...item,
-    status: item.shadowRequired ? "accepted-awaiting-shadow" : "accepted",
-    acceptedAt: new Date().toISOString(),
-  }
-  const next = {
-    schemaVersion: 2,
-    updatedAt: accepted.acceptedAt,
-    proposals: current.proposals.filter((entry) => entry.id !== id),
-    accepted: [...current.accepted.filter((entry) => entry.id !== id), accepted],
-  }
-  await mkdir(path.dirname(learningFile(root)), { recursive: true })
-  await writeFile(learningFile(root), JSON.stringify(next, null, 2) + "\n", "utf8")
-  return accepted
+  return withLearningWriteLock(root, async () => {
+    const current = await readLearningState(root)
+    const item = current.proposals.find((entry) => entry.id === id)
+    if (!item) throw new Error("unknown learning proposal: " + id)
+    const accepted = {
+      ...item,
+      status: item.shadowRequired ? "accepted-awaiting-shadow" : "accepted",
+      acceptedAt: new Date().toISOString(),
+    }
+    const next = {
+      schemaVersion: 2,
+      updatedAt: accepted.acceptedAt,
+      proposals: current.proposals.filter((entry) => entry.id !== id),
+      accepted: [...current.accepted.filter((entry) => entry.id !== id), accepted],
+    }
+    await atomicJson(learningFile(root), next)
+    return accepted
+  })
 }
 
 async function benchmarkValidationFromArtifact(root, reportPath) {
@@ -295,32 +389,37 @@ async function benchmarkValidationFromArtifact(root, reportPath) {
 }
 
 export async function promoteLearning(root, id, validation = {}) {
-  const current = await readLearningState(root)
-  const item = current.accepted.find((entry) => entry.id === id)
-  if (!item) {
-    if (current.proposals.some((entry) => entry.id === id)) {
+  const initial = await readLearningState(root)
+  const initialItem = initial.accepted.find((entry) => entry.id === id)
+  if (!initialItem) {
+    if (initial.proposals.some((entry) => entry.id === id)) {
       throw new Error("learning proposal must be explicitly accepted before shadow promotion: " + id)
     }
     throw new Error("unknown learning proposal: " + id)
   }
 
   const shadowValidation = await benchmarkValidationFromArtifact(root, validation.report)
-  const promotedAt = new Date().toISOString()
-  const promoted = {
-    ...item,
-    status: "promoted",
-    promotedAt,
-    shadowValidation,
-  }
-  const next = {
-    schemaVersion: 2,
-    updatedAt: promotedAt,
-    proposals: current.proposals.filter((entry) => entry.id !== id),
-    accepted: [...current.accepted.filter((entry) => entry.id !== id), promoted],
-  }
-  await mkdir(path.dirname(learningFile(root)), { recursive: true })
-  await writeFile(learningFile(root), JSON.stringify(next, null, 2) + "\n", "utf8")
-  return promoted
+  return withLearningWriteLock(root, async () => {
+    const current = await readLearningState(root)
+    const item = current.accepted.find((entry) => entry.id === id)
+    if (!item) throw new Error("learning proposal changed during promotion: " + id)
+
+    const promotedAt = new Date().toISOString()
+    const promoted = {
+      ...item,
+      status: "promoted",
+      promotedAt,
+      shadowValidation,
+    }
+    const next = {
+      schemaVersion: 2,
+      updatedAt: promotedAt,
+      proposals: current.proposals.filter((entry) => entry.id !== id),
+      accepted: [...current.accepted.filter((entry) => entry.id !== id), promoted],
+    }
+    await atomicJson(learningFile(root), next)
+    return promoted
+  })
 }
 
 function retrievalTerms(text) {

package/lib/memory-engine.mjs

@@ -1,10 +1,12 @@
 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"
 import { buildRepoGraphCached } from "./repo-graph.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
+import { workspaceStatusEntries } from "./workspace-fingerprint.mjs"
 
 const MEMORY_DIR = ".ues-memory"
 const MEMORY_FILE = "MEMORY.json"
@@ -16,6 +18,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 +186,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 +245,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 +626,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,
@@ -594,21 +673,24 @@ export async function memoryStatus(root = process.cwd()) {
 }
 
 function changedFiles(root) {
-  const result = spawnSync("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
+  const result = spawnSync("git", [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--",
+    ...sourceGitPathspecs(),
+  ], {
     cwd: path.resolve(root),
     encoding: "utf8",
     windowsHide: true,
     maxBuffer: 4 * 1024 * 1024,
   })
   if (result.status !== 0) return []
-  return uniq(
-    String(result.stdout || "")
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map((line) => line.slice(3).trim())
-      .map((value) => value.includes(" -> ") ? value.split(" -> ").at(-1) : value)
-      .map(normalizeFile),
-  ).slice(0, 80)
+  const changed = workspaceStatusEntries(String(result.stdout || ""))
+    .filter((entry) => entry.renameSource !== true)
+    .map((entry) => normalizeFile(entry.file))
+  return uniq(sourceFacingPaths(changed)).slice(0, 80)
 }
 
 function compactVerification(value, limit = 1200) {