opencode-agent-skill 14.2.0-beta.1 → 14.4.0

package/lib/fast-verification-gate.mjs

@@ -0,0 +1,69 @@
+const BEHAVIORAL_TEST_COMMAND = [
+  /(?:^|\s)(?:node|bun)\s+--test(?:\s|$)/i,
+  /(?:^|\s)(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test(?:\s|$|:)/i,
+  /(?:^|\s)(?:npx\s+)?(?:jest|vitest|pytest)(?:\s|$)/i,
+  /(?:^|\s)go\s+test(?:\s|$)/i,
+  /(?:^|\s)cargo\s+test(?:\s|$)/i,
+  /(?:^|\s)dotnet\s+test(?:\s|$)/i,
+  /(?:^|\s)(?:mvn|mvnw|gradle|gradlew|\.\/gradlew|gradlew\.bat)\b[^\n]*\btest\b/i,
+]
+
+function commandText(row = {}) {
+  const receipt = row?.receipt || {}
+  return [receipt.command, ...(Array.isArray(receipt.args) ? receipt.args : [])].filter(Boolean).join(" ").trim()
+}
+
+function finishedAtMs(row = {}) {
+  const value = Date.parse(row?.finishedAt || row?.receipt?.finishedAt || "")
+  return Number.isFinite(value) ? value : null
+}
+
+export function isBehavioralVerificationReceipt(row = {}) {
+  const receipt = row?.receipt || {}
+  if (receipt.passed !== true || Number(receipt.exitCode) !== 0) return false
+  const command = commandText(row)
+  return Boolean(command) && BEHAVIORAL_TEST_COMMAND.some((pattern) => pattern.test(command))
+}
+
+export function evaluateFastVerificationGate(input = {}) {
+  const policy = input.policy || {}
+  const implementation = input.implementation || {}
+  const receipts = Array.isArray(input.receipts) ? input.receipts : []
+  const attemptStartedAtMs = Number(input.attemptStartedAtMs || 0)
+  const eligible =
+    policy.executionProfile === "fast" &&
+    policy.singleFileBounded === true &&
+    policy.risk === "low" &&
+    input.visualRequired !== true
+  const implementationOk =
+    Number(implementation.exitCode) === 0 &&
+    String(implementation.stopReason || "").toLowerCase() !== "error"
+  const verificationText = String(implementation?.report?.sections?.verification || "").trim()
+  const implementationReportedVerification =
+    Boolean(verificationText) &&
+    !/(?:not\s+run|not\s+available|skipped|unverified|no\s+(?:tests?|checks?)\s+(?:run|available))/i.test(verificationText)
+  const behavioralReceipts = receipts
+    .filter((row) => {
+      const finished = finishedAtMs(row)
+      return isBehavioralVerificationReceipt(row) &&
+        (attemptStartedAtMs <= 0 || (finished != null && finished >= attemptStartedAtMs))
+    })
+    .map((row) => ({
+      command: commandText(row),
+      finishedAt: row?.finishedAt || row?.receipt?.finishedAt || null,
+      receiptId: row?.receipt?.id || null,
+    }))
+  let reason = "fresh-behavioral-evidence"
+  if (!eligible) reason = "not-fast-bounded"
+  else if (!implementationOk) reason = "implementation-not-clean"
+  else if (!implementationReportedVerification) reason = "implementation-did-not-report-verification"
+  else if (!behavioralReceipts.length) reason = "no-fresh-behavioral-receipt"
+  return {
+    schemaVersion: 1,
+    eligible,
+    passed: eligible && implementationOk && implementationReportedVerification && behavioralReceipts.length > 0,
+    reason,
+    behavioralReceiptCount: behavioralReceipts.length,
+    behavioralReceipts,
+  }
+}

package/lib/mcp-health.mjs

@@ -0,0 +1,144 @@
+const TRANSIENT_ERROR =
+  /(timeout|timed out|econnreset|econnrefused|socket|connection (?:closed|reset|lost)|transport|network|temporar(?:y|ily)|service unavailable|bad gateway|gateway timeout|\b502\b|\b503\b|\b504\b|rate limit|\b429\b)/i
+
+function nowMs(value) {
+  const number = Number(value)
+  return Number.isFinite(number) ? number : Date.now()
+}
+
+export function isTransientMcpFailure(value = "") {
+  return TRANSIENT_ERROR.test(String(value || ""))
+}
+
+export function mcpReconnectAdvice(input = {}) {
+  const policy = input.policy || {}
+  const attempt = Math.max(1, Math.trunc(Number(input.attempt || 1)))
+  const transient = isTransientMcpFailure(input.error || input.message || "")
+  const destructive = policy.confirmationRequired === true || policy.annotations?.destructiveHint === true
+  const retryable = policy.retryAllowed === true && transient && !destructive && attempt < Math.max(1, Number(input.maxAttempts || 3))
+  return {
+    schemaVersion: 1,
+    retryable,
+    reconnectRecommended: retryable,
+    reason: destructive
+      ? "destructive-tool-never-auto-reconnect"
+      : !transient
+        ? "non-transient-failure"
+        : policy.retryAllowed !== true
+          ? "tool-not-explicitly-idempotent"
+          : retryable
+            ? "transient-idempotent-failure"
+            : "retry-budget-exhausted",
+    backoffMs: retryable ? Math.min(5_000, 250 * (2 ** Math.max(0, attempt - 1))) : 0,
+  }
+}
+
+export class McpHealthTracker {
+  constructor(options = {}) {
+    this.failureThreshold = Math.max(1, Math.min(10, Number(options.failureThreshold || 2)))
+    this.cooldownMs = Math.max(1_000, Math.min(5 * 60_000, Number(options.cooldownMs || 15_000)))
+    this.maxEntries = Math.max(16, Math.min(2_000, Number(options.maxEntries || 256)))
+    this.state = new Map()
+    this.active = new Map()
+  }
+
+  clear() {
+    this.state.clear()
+    this.active.clear()
+  }
+
+  begin(callId, toolName, policy = {}, at = Date.now()) {
+    const id = String(callId || "")
+    const name = String(toolName || "")
+    if (id && name) this.active.set(id, { name, policy, startedAt: nowMs(at) })
+    this.#trim()
+    return this.status(name, at)
+  }
+
+  finish(callId, result = {}, at = Date.now()) {
+    const id = String(callId || "")
+    const active = this.active.get(id)
+    if (!active) return null
+    this.active.delete(id)
+    const timestamp = nowMs(at)
+    const previous = this.state.get(active.name) || {
+      successes: 0,
+      failures: 0,
+      consecutiveFailures: 0,
+      cooldownUntil: 0,
+      lastError: null,
+      lastFinishedAt: 0,
+    }
+    const errorText = [
+      result.error,
+      result.message,
+      result.stderr,
+      result.text,
+    ].filter(Boolean).join("\n").slice(0, 4000)
+    const failed = result.isError === true || Number(result.exitCode) > 0
+    const transient = failed && isTransientMcpFailure(errorText)
+    const consecutiveFailures = failed ? Number(previous.consecutiveFailures || 0) + 1 : 0
+    const cooldownUntil = transient && consecutiveFailures >= this.failureThreshold
+      ? timestamp + this.cooldownMs
+      : failed
+        ? Number(previous.cooldownUntil || 0)
+        : 0
+    const reconnectAdvice = failed
+      ? mcpReconnectAdvice({ policy: active.policy, error: errorText, attempt: consecutiveFailures })
+      : null
+    const next = {
+      successes: Number(previous.successes || 0) + (failed ? 0 : 1),
+      failures: Number(previous.failures || 0) + (failed ? 1 : 0),
+      consecutiveFailures,
+      cooldownUntil,
+      lastError: failed ? errorText || "tool-result-error" : null,
+      lastTransientFailure: transient,
+      reconnectAdvice,
+      lastFinishedAt: timestamp,
+      policy: active.policy,
+    }
+    this.state.set(active.name, next)
+    this.#trim()
+    return this.status(active.name, timestamp)
+  }
+
+  status(toolName, at = Date.now()) {
+    const name = String(toolName || "")
+    const row = this.state.get(name)
+    const timestamp = nowMs(at)
+    if (!row) {
+      return { schemaVersion: 1, tool: name, status: "unknown", available: true, consecutiveFailures: 0, cooldownUntil: null }
+    }
+    const coolingDown = Number(row.cooldownUntil || 0) > timestamp
+    return {
+      schemaVersion: 1,
+      tool: name,
+      status: coolingDown ? "degraded" : row.consecutiveFailures > 0 ? "recovering" : "healthy",
+      available: !coolingDown,
+      successes: row.successes,
+      failures: row.failures,
+      consecutiveFailures: row.consecutiveFailures,
+      cooldownUntil: coolingDown ? new Date(row.cooldownUntil).toISOString() : null,
+      lastError: row.lastError,
+      lastTransientFailure: row.lastTransientFailure === true,
+      reconnectAdvice: row.reconnectAdvice || null,
+      lastFinishedAt: row.lastFinishedAt ? new Date(row.lastFinishedAt).toISOString() : null,
+    }
+  }
+
+  available(toolName, at = Date.now()) {
+    return this.status(toolName, at).available !== false
+  }
+
+  snapshot(at = Date.now()) {
+    return [...this.state.keys()]
+      .sort()
+      .map((name) => this.status(name, at))
+  }
+
+  #trim() {
+    if (this.state.size <= this.maxEntries) return
+    const ordered = [...this.state.entries()].sort((a, b) => Number(a[1]?.lastFinishedAt || 0) - Number(b[1]?.lastFinishedAt || 0))
+    for (const [name] of ordered.slice(0, Math.max(0, this.state.size - this.maxEntries))) this.state.delete(name)
+  }
+}

package/lib/mcp-tool-policy.mjs

@@ -0,0 +1,19 @@
+function firstObject(...values) { return values.find((value) => value && typeof value === "object" && !Array.isArray(value)) || {} }
+function explicitBoolean(value) { return typeof value === "boolean" ? value : null }
+export function normalizeMcpAnnotations(tool = {}) {
+  const raw = firstObject(tool.annotations, tool.metadata?.annotations, tool._meta?.annotations, tool._meta?.mcp?.annotations)
+  const annotations = { readOnlyHint: explicitBoolean(raw.readOnlyHint), destructiveHint: explicitBoolean(raw.destructiveHint), idempotentHint: explicitBoolean(raw.idempotentHint), openWorldHint: explicitBoolean(raw.openWorldHint) }
+  return { schemaVersion: 1, explicit: Object.values(annotations).some((value) => value !== null), ...annotations }
+}
+export function mcpExecutionPolicy(tool = {}) {
+  const annotations = normalizeMcpAnnotations(tool)
+  const destructive = annotations.destructiveHint === true
+  const readOnly = annotations.readOnlyHint === true && !destructive
+  const idempotent = annotations.idempotentHint === true && !destructive
+  return { schemaVersion: 1, tool: String(tool?.name || ""), annotations, fastAllowed: readOnly, confirmationRequired: destructive, retryAllowed: idempotent, externalEvidenceBoundary: annotations.openWorldHint === true, trust: "hint-only" }
+}
+export function mcpPolicyMap(tools = []) {
+  const map = new Map()
+  for (const tool of Array.isArray(tools) ? tools : []) { const name = String(tool?.name || "").trim(); if (name) map.set(name, mcpExecutionPolicy(tool)) }
+  return map
+}

package/lib/memory-engine.mjs

@@ -303,6 +303,33 @@ function rankMap(rows, key) {
   )
 }
 
+export function buildMemorySnapshot(memories = []) {
+  const entries = (Array.isArray(memories) ? memories : [])
+    .map((item) => ({
+      id: item.id || null,
+      type: item.type || null,
+      scope: item.scope || null,
+      content: normalizedContent(item.content),
+      confidence: clamp(item.confidence),
+      files: uniq((item.files || []).map(normalizeFile)).sort(),
+      taskClass: item.taskClass || null,
+      verifiedAt: item.verifiedAt || null,
+      evidenceRefs: uniq(item.evidenceRefs || []).sort(),
+    }))
+    .filter((item) => item.id && item.content)
+    .sort((a, b) => String(a.id).localeCompare(String(b.id)))
+  const generation = createHash("sha256")
+    .update(JSON.stringify(entries))
+    .digest("hex")
+    .slice(0, 20)
+  return {
+    schemaVersion: 1,
+    generation,
+    entryCount: entries.length,
+    entries,
+  }
+}
+
 export async function retrieveMemories(root, query, options = {}) {
   const state = await readMemoryState(root)
   const memories = state.memories.filter((item) => item.status === "verified" && !item.supersededBy && !isExpired(item))
@@ -365,6 +392,7 @@ export async function retrieveMemories(root, query, options = {}) {
     query: String(query || ""),
     eligible: memories.length,
     results,
+    snapshot: buildMemorySnapshot(results),
   }
 }
 

package/lib/prompt-cache.mjs

@@ -5,31 +5,35 @@ function canonical(value) {
   if (!value || typeof value !== "object") return value
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]))
 }
-
-function stringify(value) {
-  return typeof value === "string" ? value : JSON.stringify(canonical(value))
-}
-
-function digest(value) {
-  return createHash("sha256").update(stringify(value)).digest("hex")
+function stringify(value) { return typeof value === "string" ? value : JSON.stringify(canonical(value)) }
+function digest(value) { return createHash("sha256").update(stringify(value)).digest("hex") }
+function chars(value) { return stringify(value ?? "").length }
+function finiteTokenCount(value) {
+  const number = Number(value)
+  return Number.isFinite(number) && number >= 0 ? number : null
 }
-
-function chars(value) {
-  return stringify(value ?? "").length
+function changedStableKeys(previous, current) {
+  const left = previous?.stable || {}
+  const right = current?.stable || {}
+  return [...new Set([...Object.keys(left), ...Object.keys(right)])]
+    .filter((key) => digest(left[key]) !== digest(right[key]))
+    .sort()
 }
 
 export function buildPromptEnvelope(input = {}) {
+  const memorySnapshot = input.memorySnapshot || null
   const stable = {
     invariants: input.invariants || "",
     role: input.role || "",
     skills: input.skills || [],
     projectFacts: input.projectFacts || {},
     toolPolicy: input.toolPolicy || {},
+    memorySnapshot,
   }
   const dynamic = {
     task: input.task || {},
     evidence: input.evidence || [],
-    memories: input.memories || [],
+    memories: memorySnapshot ? [] : (input.memories || []),
     contextHints: input.contextHints || {},
     recentFailure: input.recentFailure || null,
     nextAction: input.nextAction || null,
@@ -45,18 +49,28 @@ export function buildPromptEnvelope(input = {}) {
     dynamicHash: digest(dynamic),
     stableChars,
     dynamicChars,
+    cacheableChars: stableChars,
     cacheableRatio: stableChars + dynamicChars ? stableChars / (stableChars + dynamicChars) : 0,
+    cacheReadTokens: finiteTokenCount(input.cacheReadTokens),
+    cacheWriteTokens: finiteTokenCount(input.cacheWriteTokens),
   }
 }
 
-export function comparePromptEnvelopes(previous, current) {
+export function comparePromptEnvelopes(previous, current, usage = {}) {
   const stableReused = Boolean(previous?.stablePrefixHash && previous.stablePrefixHash === current?.stablePrefixHash)
   const repeatedStableChars = stableReused ? Number(current?.stableChars || 0) : 0
+  const mutated = stableReused ? [] : changedStableKeys(previous, current)
   return {
     schemaVersion: 1,
     stableReused,
     repeatedStableChars,
     avoidableRepeatedChars: stableReused ? 0 : Math.min(Number(previous?.stableChars || 0), Number(current?.stableChars || 0)),
     currentCacheableRatio: Number(current?.cacheableRatio || 0),
+    cacheableChars: Number(current?.cacheableChars ?? current?.stableChars ?? 0),
+    dynamicChars: Number(current?.dynamicChars || 0),
+    cacheReadTokens: finiteTokenCount(usage.cacheReadTokens ?? current?.cacheReadTokens),
+    cacheWriteTokens: finiteTokenCount(usage.cacheWriteTokens ?? current?.cacheWriteTokens),
+    prefixMutationReason: stableReused ? null : (mutated.length ? mutated.join(",") : "stable-prefix-changed"),
+    mutatedStableKeys: mutated,
   }
 }

package/lib/reversible-context.mjs

@@ -0,0 +1,49 @@
+import { putEvidence, getEvidence, getEvidenceSelected } from "./evidence-store.mjs"
+
+function normalize(value) { return String(value ?? "").replace(/\r\n/g, "\n").replace(/\r/g, "\n") }
+function significantLines(text) {
+  const lines = normalize(text).split("\n")
+  const scored = lines.map((line, index) => {
+    const trimmed = line.trim(); let score = 0
+    if (/^#{1,6}\s/.test(trimmed)) score += 8
+    if (/^(?:[-*+] |\d+[.)]\s)/.test(trimmed)) score += 5
+    if (/\b(?:error|fail|warning|todo|fixme|pass|test|result|summary|important|must|required)\b/i.test(trimmed)) score += 4
+    if (/^(?:export|import|class|function|def|interface|type|CREATE|ALTER)\b/i.test(trimmed)) score += 3
+    if (trimmed.length > 0 && trimmed.length <= 180) score += 1
+    return { index, line, score }
+  })
+  return { lines, scored }
+}
+function summary(text, maxChars) {
+  const { lines, scored } = significantLines(text)
+  if (normalize(text).length <= maxChars) return normalize(text)
+  const wanted = new Set(scored.filter((row) => row.score > 0).sort((a,b) => b.score - a.score || a.index - b.index).slice(0,80).map((row) => row.index))
+  for (let i = Math.max(0, lines.length - 8); i < lines.length; i += 1) wanted.add(i)
+  let out = ""
+  for (const index of [...wanted].sort((a,b) => a-b)) {
+    const candidate = (out ? out + "\n" : "") + lines[index]
+    if (candidate.length > maxChars) break
+    out = candidate
+  }
+  return out || normalize(text).slice(0, maxChars)
+}
+export async function compactContext(root, content, options = {}) {
+  const raw = normalize(content)
+  const stored = await putEvidence(root, raw, { kind: options.kind || "context-block", source: options.source || "ues-context", summary: options.summary || "Reversible raw context block" })
+  return { schemaVersion: 1, ref: stored.ref, originalChars: raw.length, levels: { T1: summary(raw, Math.max(512, Number(options.t1Chars || 1600))), T2: summary(raw, Math.max(1200, Number(options.t2Chars || 5000))), T3: summary(raw, Math.max(2400, Number(options.t3Chars || 12000))) } }
+}
+export async function expandContext(root, ref, options = {}) {
+  return getEvidenceSelected(root, ref, { start: Math.max(0, Number(options.start || 0)), maxBytes: Math.max(1, Math.min(128_000, Number(options.maxBytes || 16_000))) })
+}
+export async function searchContext(root, ref, query, options = {}) {
+  const maxBytes = Math.max(16_000, Math.min(4 * 1024 * 1024, Number(options.maxBytes || 512_000)))
+  const evidence = await getEvidence(root, ref, { maxBytes })
+  const source = normalize(evidence?.content ?? evidence ?? "")
+  const terms = [...new Set(String(query || "").toLowerCase().split(/[^\p{L}\p{N}_$.-]+/u).filter((item) => item.length >= 2))].slice(0, 16)
+  const lines = source.split("\n"); const radius = Math.max(0, Math.min(12, Number(options.radius || 2))); const maxMatches = Math.max(1, Math.min(50, Number(options.maxMatches || 10))); const hits = []
+  for (let index = 0; index < lines.length && hits.length < maxMatches; index += 1) {
+    const lower = lines[index].toLowerCase(); const matched = terms.filter((term) => lower.includes(term)); if (!matched.length) continue
+    hits.push({ line: index + 1, terms: matched, excerpt: lines.slice(Math.max(0,index-radius), Math.min(lines.length,index+radius+1)).join("\n") })
+  }
+  return { schemaVersion: 1, ref, query: String(query || ""), terms, hits, truncatedSource: source.length >= maxBytes }
+}

package/lib/task-engine.mjs

@@ -15,7 +15,7 @@ import { putEvidence } from "./evidence-store.mjs"
 import { inferTaskCapabilities } from "./capability-registry.mjs"
 import { buildPromptEnvelope } from "./prompt-cache.mjs"
 import { externalizeContextExcerpts } from "./context-engine-v11.mjs"
-import { recordVerifiedTaskMemory, retrieveMemories } from "./memory-engine.mjs"
+import { buildMemorySnapshot, recordVerifiedTaskMemory, retrieveMemories } from "./memory-engine.mjs"
 import { capabilityFabricStatus } from "./capability-fabric.mjs"
 import { assertActivePlanScope, persistPlanScope } from "./work-plan-scope.mjs"
 import { classifyDecisionPolicy } from "./decision-policy.mjs"
@@ -1183,6 +1183,7 @@ async function buildContextPack(loaded, taskID) {
     touch: true,
   }).catch(() => ({ schemaVersion: 1, query: taskText, eligible: 0, results: [] }))
   const memories = memoryRetrieval.results || []
+  const memorySnapshot = memoryRetrieval.snapshot || buildMemorySnapshot(memories)
   const fabric = await capabilityFabricStatus(loaded.paths.root).catch(() => null)
   const providerHints = (fabric?.rows || [])
     .filter((row) => row.selected)
@@ -1216,15 +1217,7 @@ async function buildContextPack(loaded, taskID) {
       ...(contextManifest?.evidencePointers || []).map((item) => item.ref),
       ...(contextManifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
     ],
-    memories: memories.map((item) => ({
-      id: item.id,
-      type: item.type,
-      scope: item.scope,
-      content: item.content,
-      confidence: item.confidence,
-      files: item.files,
-      retrieval: item.retrieval,
-    })),
+    memorySnapshot,
     contextHints: {
       hierarchy: (contextManifest?.hierarchy?.scopes || []).slice(0, 6).map((item) => ({
         path: item.path,
@@ -1248,7 +1241,9 @@ async function buildContextPack(loaded, taskID) {
       dynamicHash: promptEnvelope.dynamicHash,
       stableChars: promptEnvelope.stableChars,
       dynamicChars: promptEnvelope.dynamicChars,
+      cacheableChars: promptEnvelope.cacheableChars,
       cacheableRatio: promptEnvelope.cacheableRatio,
+      memoryGeneration: memorySnapshot.generation,
     },
     attempt,
     slug: loaded.state.slug,
@@ -1275,6 +1270,7 @@ async function buildContextPack(loaded, taskID) {
       schemaVersion: memoryRetrieval.schemaVersion || 1,
       eligible: memoryRetrieval.eligible || 0,
       returned: memories.length,
+      generation: memorySnapshot.generation,
     },
     capabilityFabric: {
       healthyCapabilities: fabric?.healthyCapabilities || 0,

package/lib/task-policy.mjs

@@ -4,6 +4,40 @@ const LONG = /(whole repo|whole repository|whole project|entire repo|entire proj
 const DEBUG = /(fix|bug|debug|crash|regression|failure|error|broken|sửa lỗi|lỗi|điều tra lỗi|không chạy)/i
 const CONTRACT = /(public api|api contract|openapi|response schema|request schema|breaking api|hợp đồng api|api công khai)/i
 const DATA = /(database|sql|migration|schema|transaction|index|cơ sở dữ liệu|dữ liệu|migrate)/i
+const BROAD_FILE_SCOPE = /(across\s+(?:multiple|several|many)\s+(?:files|modules|packages)|multiple\s+(?:files|modules|packages)|several\s+(?:files|modules|packages)|many\s+(?:files|modules|packages)|nhiều\s+(?:file|tệp|module)|toàn bộ\s+(?:repo|repository|project|dự án))/i
+const CRITICAL_LOCAL_MUTATION = /(drop\s+table|truncate\s+table|reset\s+--hard|git\s+clean|force\s+push|npm\s+publish|deploy(?:ment)?\s+(?:to\s+)?production|production\s+deploy(?:ment)?|rotate\s+(?:secret|credential)|(?:secret|credential|token).{0,48}(?:rotate|replace|revoke|delete)|(?:authorization|authentication|permission|phân quyền|xác thực).{0,64}(?:change|modify|update|bypass|remove|delete|sửa|thay đổi)|(?:database|sql|schema).{0,64}(?:migration|migrate|drop|truncate|alter)|(?:migration|migrate).{0,64}(?:database|sql|schema)|payment.{0,64}(?:charge|capture|refund|webhook|checkout)|(?:charge|capture|refund|webhook|checkout).{0,64}payment|breaking\s+(?:change\s+to\s+)?(?:public\s+)?api)/i
+const SOURCE_FILE_RE = /(?:^|[\s("'\x60])((?:[A-Za-z]:)?(?:[./\\\w@-]+[\\/])*[\w@.-]+\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|kts|cs|rb|php|swift|dart|vue|svelte))(?=$|[\s"'\x60),:;.])/gi
+
+function referencedSourceFiles(value) {
+  const files = []
+  const seen = new Set()
+  SOURCE_FILE_RE.lastIndex = 0
+  let match
+  while ((match = SOURCE_FILE_RE.exec(String(value || "")))) {
+    const normalized = String(match[1] || "").replaceAll("\\", "/").toLowerCase()
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    files.push(normalized)
+  }
+  return files
+}
+
+function singleFileBoundedTask(value, facts = {}) {
+  const declaredFiles = Array.isArray(facts.declaredFiles) ? facts.declaredFiles.map(String).filter(Boolean) : []
+  const changedFileCount = Array.isArray(facts.changedFiles)
+    ? facts.changedFiles.length
+    : Number.isFinite(Number(facts.changedFiles)) ? Number(facts.changedFiles) : 0
+  const referencedFiles = referencedSourceFiles(value)
+  const counts = [declaredFiles.length, changedFileCount, referencedFiles.length].filter((count) => count > 0)
+  if (!counts.length || counts.some((count) => count > 1)) return false
+  if (BROAD_FILE_SCOPE.test(String(value || "")) || LONG.test(String(value || ""))) return false
+  return counts.some((count) => count === 1) && (
+    declaredFiles.length === 1 ||
+    changedFileCount === 1 ||
+    /\b(?:fix|repair|change|update|modify|rename|implement|correct|sửa|chỉnh sửa|thay đổi|cập nhật)\b/i.test(String(value || ""))
+  )
+}
+
 
 function riskTextFor(value) {
   return String(value || "")
@@ -158,7 +192,18 @@ export function classifyEngineeringTask(text, facts = {}) {
   const value = String(text || "")
   const riskText = riskTextFor(value)
   const sensitiveDomain = SENSITIVE_DOMAIN.test(value)
-  const sensitiveMutation = HIGH_RISK_MUTATION.test(riskText)
+  const singleFileBounded = singleFileBoundedTask(value, facts)
+  const rawSensitiveMutation = HIGH_RISK_MUTATION.test(riskText)
+  const sensitiveMutation =
+    rawSensitiveMutation &&
+    (!singleFileBounded || CRITICAL_LOCAL_MUTATION.test(riskText))
+  const dataMigration =
+    Boolean(facts.hasMigration) ||
+    (
+      !singleFileBounded &&
+      DATA.test(riskText) &&
+      /migration|schema|migrate|di trú|chuyển đổi/i.test(riskText)
+    )
   const declaredHighRisk =
     ["high", "critical"].includes(String(facts.risk || "").toLowerCase()) ||
     /\b(?:risk|rủi ro)\s*[:=\/-]?\s*(?:high|critical|cao|nghiêm trọng)\b/i.test(value) ||
@@ -178,18 +223,28 @@ export function classifyEngineeringTask(text, facts = {}) {
     signal("declared-high-risk", declaredHighRisk, 2),
     signal("explicit-long-horizon", explicitLongHorizon, 2),
     signal("debugging", DEBUG.test(value), 1),
+    signal("single-file-bounded", singleFileBounded, -2),
     signal("public-contract", CONTRACT.test(value) || facts.hasPublicContract, 2),
-    signal("data-migration", (DATA.test(riskText) && /migration|schema|migrate|di trú|chuyển đổi/i.test(riskText)) || facts.hasMigration, 2),
+    signal("data-migration", dataMigration, 2),
     signal("many-changed-files", Number(facts.changedFiles || 0) > 5, 1),
     signal("very-many-changed-files", Number(facts.changedFiles || 0) > 12, 1),
     signal("large-repository", Number(facts.repoFiles || 0) > 1500, 1),
     signal("monorepo", facts.monorepo === true, 1),
   ].filter(Boolean)
 
-  const score = signals.reduce((sum, item) => sum + item.weight, 0)
+  const score = Math.max(0, signals.reduce((sum, item) => sum + item.weight, 0))
   const highRisk = declaredHighRisk || sensitiveMutation || Boolean(facts.hasMigration) || Boolean(facts.hasPublicContract)
-  const risk = highRisk ? "high" : score >= 3 ? "medium" : "low"
-  const mode = explicitLongHorizon || score >= 4 ? "long-horizon" : score >= 2 ? "standard" : "inline"
+  const risk = highRisk ? "high" : singleFileBounded ? "low" : score >= 3 ? "medium" : "low"
+  const mode =
+    explicitLongHorizon
+      ? "long-horizon"
+      : singleFileBounded && !highRisk
+        ? "inline"
+        : score >= 4
+          ? "long-horizon"
+          : score >= 2
+            ? "standard"
+            : "inline"
   const modelTier = risk === "high" || mode === "long-horizon" ? "heavy" : score >= 2 ? "standard" : "light"
   const maxAttempts = risk === "high" ? 2 : 3
   const profile = profileFor(mode, risk)
@@ -218,6 +273,7 @@ export function classifyEngineeringTask(text, facts = {}) {
     requirePlanCheck: profile.durableState || risk === "high",
     requireIntegrationVerification: mode !== "inline" || risk === "high",
     requireFreshEvidence: true,
+    singleFileBounded,
     profile,
     domains: [...new Set(domains)],
     recovery: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "version": "14.2.0-beta.1",
-  "description": "Pi Agent engineering runtime with hierarchical context, verified persistent memory, learned capability failover, durable evidence, and evidence-gated verification",
+  "version": "14.4.0",
+  "description": "Pi Agent engineering runtime with code intelligence, hash-anchored editing, verified persistent memory, health-aware capability routing, reversible context, and evidence-gated completion",
   "type": "module",
   "bin": {
     "ues": "bin/ocskill.mjs",
@@ -38,7 +38,7 @@
     "ci": "npm run integrity && npm run runtime:exports && npm run syntax && npm test && npm run docs:check && npm pack --dry-run && npm run smoke:pi && npm run smoke:package && npm run smoke:packed",
     "prepublishOnly": "npm run ci",
     "smoke:packed": "node scripts/smoke-packed-install.mjs",
-    "eval:v14": "node --test test/capability-fabric-v14.test.mjs test/hierarchical-context-v14.test.mjs test/memory-engine-v14.test.mjs test/context-engine-v14.test.mjs test/task-engine-v14-context.test.mjs test/cli-v14.test.mjs test/v14-contract.test.mjs test/performance-fabric-v14.test.mjs test/browser-mcp-routing-v14.test.mjs test/process-hang-detector-v14.test.mjs test/v14.2-runtime.test.mjs test/benchmark-confidence.test.mjs",
+    "eval:v14": "node --test test/capability-fabric-v14.test.mjs test/hierarchical-context-v14.test.mjs test/memory-engine-v14.test.mjs test/context-engine-v14.test.mjs test/task-engine-v14-context.test.mjs test/cli-v14.test.mjs test/v14-contract.test.mjs test/performance-fabric-v14.test.mjs test/browser-mcp-routing-v14.test.mjs test/process-hang-detector-v14.test.mjs test/v14.2-runtime.test.mjs test/benchmark-confidence.test.mjs test/v14.3-intelligence.test.mjs",
     "integrity": "node scripts/check-source-integrity.mjs",
     "runtime:exports": "node scripts/check-runtime-exports.mjs"
   },