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

package/lib/leaf-runtime-optimizer.mjs

@@ -0,0 +1,76 @@
+import { classifyEngineeringTask } from "./task-policy.mjs"
+
+function strings(value) {
+  if (!value) return []
+  return (Array.isArray(value) ? value : [value]).map(String).map((item) => item.trim()).filter(Boolean)
+}
+
+function declaredWriteFiles(task = {}) {
+  const files = task?.files || {}
+  return [...new Set([
+    ...strings(files.create),
+    ...strings(files.modify),
+    ...strings(files.test),
+    ...strings(files.delete),
+  ].map((item) => item.replaceAll("\\", "/")))]
+}
+
+export function leafTaskPolicy(task = {}, rootPolicy = {}) {
+  const writeFiles = declaredWriteFiles(task)
+  const readFiles = strings(task?.files?.read)
+  const text = [
+    task?.title,
+    task?.summary,
+    ...strings(task?.acceptance),
+    ...strings(task?.verification),
+    task?.riskNotes,
+    writeFiles.length ? "Declared write files: " + writeFiles.join(", ") : "",
+    readFiles.length ? "Declared read files: " + readFiles.join(", ") : "",
+  ].filter(Boolean).join("\n")
+
+  const policy = classifyEngineeringTask(text, {
+    declaredFiles: writeFiles,
+    changedFiles: writeFiles.length,
+    risk: task?.risk,
+    longHorizon: false,
+    failureEvidence: false,
+  })
+
+  // The root may be DEEP because the overall project is large; do not force an
+  // independent low-risk leaf to pay that cost. Root safety is preserved by the
+  // final integration/completion gates and by leaf-declared risk.
+  return {
+    ...policy,
+    requireFreshEvidence: true,
+    rootExecutionProfile: rootPolicy?.executionProfile || null,
+    rootRisk: rootPolicy?.risk || null,
+    localEnvWriteExplicitlyAllowed: rootPolicy?.localEnvWriteExplicitlyAllowed === true,
+    leafOptimized: true,
+  }
+}
+
+const FAILURE_SIGNAL = /(?:\bFAIL(?:ED|URE)?\b|\bERROR\b|AssertionError|TypeError|ReferenceError|SQLSTATE|ECONN\w*|EADDRINUSE|expected|actual|exit(?:Code| code)?\s*[:=]?\s*[1-9]|timed?\s*out|timeout|not found|cannot|unable|mismatch|regression|✖|×)/i
+const FILE_SIGNAL = /(?:^|\s)(?:[A-Za-z]:)?[^\s:]+\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|cs|sql|json|yaml|yml)(?::\d+(?::\d+)?)?/i
+
+export function failureDelta(output, options = {}) {
+  const maxChars = Math.max(1200, Math.min(8000, Number(options.maxChars || 4200)))
+  const raw = String(output || "").trim()
+  if (!raw) return ""
+
+  const lines = raw.split(/\r?\n/)
+  const selected = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (!FAILURE_SIGNAL.test(line) && !FILE_SIGNAL.test(line)) continue
+    if (i > 0 && lines[i - 1].trim()) selected.push(lines[i - 1])
+    selected.push(line)
+    if (i + 1 < lines.length && lines[i + 1].trim()) selected.push(lines[i + 1])
+  }
+
+  const compact = [...new Set(selected.map((line) => line.trim()).filter(Boolean))].join("\n")
+  if (compact) return compact.slice(0, maxChars)
+
+  // Fail closed on unknown output shape: keep a bounded tail, which usually
+  // contains the final verdict/error without replaying the entire previous turn.
+  return raw.slice(Math.max(0, raw.length - maxChars))
+}

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/pi-child-invocation.mjs

@@ -0,0 +1,65 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { resolveManagedPiCommand, resolveWindowsCommand } from "./windows-shim.mjs"
+
+export function looksLikePiCliEntrypoint(file) {
+  const value = String(file || "").replaceAll("\\", "/").toLowerCase()
+  if (!value) return false
+
+  // Managed/npm Pi installs execute the package CLI script. ACP adapters may
+  // also be Node scripts, so do not trust an arbitrary existing argv[1].
+  if (value.includes("/@earendil-works/pi-coding-agent/")) return true
+
+  const base = path.posix.basename(value)
+  return /^(?:pi)(?:\.[cm]?js)?$/.test(base)
+}
+
+function fromResolvedPi(resolved, args, source) {
+  if (!resolved?.executable) return null
+  return {
+    command: resolved.executable,
+    args: [...(resolved.argsPrefix || []), ...args],
+    source,
+  }
+}
+
+export function resolvePiChildInvocation(args = [], options = {}) {
+  const currentScript = options.currentScript ?? process.argv[1]
+  const execPath = options.execPath ?? process.execPath
+  const platform = options.platform ?? process.platform
+  const exists = options.existsSync ?? existsSync
+
+  if (
+    currentScript &&
+    !String(currentScript).startsWith("/$bunfs/root/") &&
+    exists(currentScript) &&
+    looksLikePiCliEntrypoint(currentScript)
+  ) {
+    return {
+      command: execPath,
+      args: [currentScript, ...args],
+      source: "host-pi-cli",
+    }
+  }
+
+  const execBase = path.basename(String(execPath || "")).toLowerCase()
+  if (/^pi(?:\.exe)?$/.test(execBase)) {
+    return { command: execPath, args, source: "host-pi-executable" }
+  }
+
+  if (platform === "win32") {
+    const managed = options.managedPi === undefined
+      ? resolveManagedPiCommand()
+      : options.managedPi
+    const managedInvocation = fromResolvedPi(managed, args, "managed-pi")
+    if (managedInvocation) return managedInvocation
+
+    const pathPi = options.pathPi === undefined
+      ? resolveWindowsCommand("pi")
+      : options.pathPi
+    const pathInvocation = fromResolvedPi(pathPi, args, "path-pi")
+    if (pathInvocation) return pathInvocation
+  }
+
+  return { command: "pi", args, source: "path-pi-fallback" }
+}

package/lib/pi-rpc-pool.mjs

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process"
 import { terminateProcessTree } from "./process-supervisor.mjs"
+import { createAdaptiveDeadline } from "./activity-deadline.mjs"
 
 function clamp(value, fallback, min, max) {
   const parsed = Number(value)
@@ -226,11 +227,37 @@ class RpcWorker {
       this.stderr = ""
 
       const hardTimeoutMs = clamp(options.hardTimeoutMs, 30 * 60_000, 30_000, 2 * 60 * 60_000)
+      const absoluteHardTimeoutMs = clamp(
+        options.absoluteHardTimeoutMs,
+        hardTimeoutMs,
+        hardTimeoutMs,
+        2 * 60 * 60_000,
+      )
+      const activityExtensionMs = clamp(
+        options.activityExtensionMs,
+        0,
+        0,
+        Math.max(hardTimeoutMs, absoluteHardTimeoutMs),
+      )
+      const activityWindowMs = clamp(
+        options.activityWindowMs,
+        Math.max(5_000, Math.min(activityExtensionMs || hardTimeoutMs, 30_000)),
+        1_000,
+        Math.max(hardTimeoutMs, absoluteHardTimeoutMs),
+      )
       const idleTimeoutMs = clamp(options.idleTimeoutMs, 5 * 60_000, 10_000, 30 * 60_000)
-      let lastActivityAt = Date.now()
+      const runStartedAt = Date.now()
+      let lastActivityAt = runStartedAt
+      const adaptiveDeadline = createAdaptiveDeadline({
+        hardTimeoutMs,
+        absoluteHardTimeoutMs,
+        activityExtensionMs,
+        activityWindowMs,
+      }, runStartedAt)
       this.lastActivityAt = lastActivityAt
       this.active = true
       let finalMessage = null
+      let partialAssistantMessage = null
       let toolCalls = 0
       let lastToolErrorAt = 0
       const toolNames = new Set()
@@ -240,19 +267,37 @@ class RpcWorker {
         settledResolve = resolve
         settledReject = reject
       })
+      // The active run can be aborted while the prompt transport is still
+      // completing, before execution reaches "await settled". Attach a handler
+      // immediately so Node never reports a transient unhandled rejection;
+      // awaiting the original promise below still preserves the rejection.
+      settled.catch(() => {})
 
       let aborting = false
       const abortFor = async (reason) => {
         if (aborting) return
         aborting = true
+        const error = new Error("UES RPC " + reason)
+        error.partialMessage = partialAssistantMessage || finalMessage
+        error.stderr = this.stderr
+        error.toolCalls = toolCalls
+        error.toolNames = [...toolNames]
+        error.deadlineExtensions = adaptiveDeadline.extensions
+        error.deadlineAt = adaptiveDeadline.deadlineAt
+        error.absoluteDeadlineAt = adaptiveDeadline.absoluteAt
+        // Settle with the rich timeout error before transport teardown can emit a
+        // generic worker-exit error and win the race.
+        settledReject(error)
         try { await this.abortTransport() } catch {}
-        settledReject(new Error("UES RPC " + reason))
       }
       this.activeAbort = abortFor
 
       const unsubscribe = this.onEvent((event) => {
         lastActivityAt = Date.now()
         this.lastActivityAt = lastActivityAt
+        if (event?.message?.role === "assistant") {
+          partialAssistantMessage = event.message
+        }
         if (event.type === "tool_execution_start") {
           toolCalls += 1
           lastToolErrorAt = 0
@@ -272,22 +317,27 @@ class RpcWorker {
         if (event.type === "ues_rpc_worker_error") settledReject(new Error(event.error || "RPC worker failed"))
       })
 
-      const hardTimer = setTimeout(() => void abortFor("hard-timeout"), hardTimeoutMs)
-      hardTimer.unref?.()
       const postToolErrorIdleTimeoutMs = clamp(
         options.postToolErrorIdleTimeoutMs,
         60_000,
         5_000,
         idleTimeoutMs,
       )
-      const idleTimer = setInterval(() => {
+      const watchdogTimer = setInterval(() => {
         const now = Date.now()
-        const threshold = lastToolErrorAt > 0 ? Math.min(idleTimeoutMs, postToolErrorIdleTimeoutMs) : idleTimeoutMs
+        const threshold = lastToolErrorAt > 0
+          ? Math.min(idleTimeoutMs, postToolErrorIdleTimeoutMs)
+          : idleTimeoutMs
         if (now - lastActivityAt >= threshold) {
           void abortFor(lastToolErrorAt > 0 ? "post-tool-error-stall" : "idle-timeout")
+          return
+        }
+        const deadline = adaptiveDeadline.shouldAbort(now, lastActivityAt)
+        if (deadline.abort) {
+          void abortFor(deadline.reason || "hard-timeout")
         }
       }, 1000)
-      idleTimer.unref?.()
+      watchdogTimer.unref?.()
 
       const signal = options.signal
       const onAbort = () => void abortFor("aborted")
@@ -304,6 +354,9 @@ class RpcWorker {
           stderr: this.stderr,
           toolCalls,
           toolNames: [...toolNames],
+          deadlineExtensions: adaptiveDeadline.extensions,
+          deadlineAt: adaptiveDeadline.deadlineAt,
+          absoluteDeadlineAt: adaptiveDeadline.absoluteAt,
         }
       } catch (error) {
         if (error && typeof error === "object") error.uesRpcPhase = "runtime"
@@ -311,8 +364,7 @@ class RpcWorker {
       } finally {
         this.active = false
         this.activeAbort = null
-        clearTimeout(hardTimer)
-        clearInterval(idleTimer)
+        clearInterval(watchdogTimer)
         unsubscribe()
         if (signal) signal.removeEventListener("abort", onAbort)
       }

package/lib/plan-salvage.mjs

@@ -0,0 +1,124 @@
+import {
+  normalizePlanForValidation,
+  validatePlan,
+} from "./task-graph.mjs"
+
+function balancedObject(source, start) {
+  let depth = 0
+  let inString = false
+  let escaped = false
+  for (let index = start; index < source.length; index++) {
+    const char = source[index]
+    if (inString) {
+      if (escaped) escaped = false
+      else if (char === "\\") escaped = true
+      else if (char === "\"") inString = false
+      continue
+    }
+    if (char === "\"") {
+      inString = true
+      continue
+    }
+    if (char === "{") depth += 1
+    else if (char === "}") {
+      depth -= 1
+      if (depth === 0) {
+        const raw = source.slice(start, index + 1)
+        try {
+          return { value: JSON.parse(raw), raw, end: index + 1 }
+        } catch {
+          return null
+        }
+      }
+    }
+  }
+  return null
+}
+
+function markedCandidate(source, marker) {
+  const markerIndex = source.lastIndexOf(marker)
+  if (markerIndex < 0) return null
+  const start = source.indexOf("{", markerIndex + marker.length)
+  if (start < 0) return null
+  const parsed = balancedObject(source, start)
+  return parsed ? { ...parsed, source: "marked" } : null
+}
+
+function fencedCandidates(source) {
+  const results = []
+  const fence = String.fromCharCode(96, 96, 96)
+  let offset = 0
+  while (offset < source.length) {
+    const open = source.indexOf(fence, offset)
+    if (open < 0) break
+    const bodyStart = source.indexOf("\n", open + fence.length)
+    if (bodyStart < 0) break
+    const close = source.indexOf(fence, bodyStart + 1)
+    if (close < 0) break
+    const body = source.slice(bodyStart + 1, close).trim()
+    if (body.startsWith("{")) {
+      try { results.push({ value: JSON.parse(body), raw: body, source: "fenced" }) } catch {}
+    }
+    offset = close + fence.length
+  }
+  return results
+}
+
+function balancedCandidates(source, limit = 24) {
+  const starts = []
+  for (let i = source.length - 1; i >= 0 && starts.length < limit; i--) {
+    if (source[i] === "{") starts.push(i)
+  }
+  const results = []
+  for (const start of starts) {
+    const parsed = balancedObject(source, start)
+    if (parsed) results.push({ ...parsed, source: "unmarked-balanced" })
+  }
+  return results
+}
+
+function planLike(value) {
+  return Boolean(
+    value &&
+    typeof value === "object" &&
+    Array.isArray(value.tasks) &&
+    (typeof value.goal === "string" || value.schemaVersion === 1)
+  )
+}
+
+export function extractValidatedPlan(output, options = {}) {
+  const source = String(output || "")
+  const marker = String(options.marker || "UES_PLAN_JSON:")
+  const candidates = []
+  const marked = markedCandidate(source, marker)
+  if (marked) candidates.push(marked)
+  candidates.push(...fencedCandidates(source))
+  candidates.push(...balancedCandidates(source))
+
+  const seen = new Set()
+  let bestInvalid = null
+  for (const candidate of candidates) {
+    if (!planLike(candidate.value)) continue
+    let normalized
+    try { normalized = normalizePlanForValidation(candidate.value) } catch { continue }
+    const key = JSON.stringify(normalized)
+    if (seen.has(key)) continue
+    seen.add(key)
+    const validation = validatePlan(normalized)
+    const result = {
+      plan: normalized,
+      validation,
+      source: candidate.source,
+      salvaged: candidate.source !== "marked",
+    }
+    if (validation && validation.valid === true) return result
+    if (!bestInvalid) bestInvalid = result
+  }
+
+  return bestInvalid || {
+    plan: null,
+    validation: null,
+    source: null,
+    salvaged: false,
+  }
+}