opencode-agent-skill 14.4.0 → 15.0.0

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,
+  }
+}

package/lib/planning-speed-policy.mjs

@@ -0,0 +1,131 @@
+function bounded(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function planningRuntimeBudget(role, attempt = 1, options = {}) {
+  const normalizedRole = String(role || "").replace(/^ues-/, "")
+  const normalizedAttempt = Math.max(1, Math.trunc(Number(attempt) || 1))
+
+  if (normalizedRole === "architect") {
+    const recovery = normalizedAttempt > 1
+    const deep = String(options.executionProfile || "") === "deep"
+    const largePrompt = Number(options.taskChars || 0) >= 2500
+    const initialHard = recovery ? 50_000 : 60_000
+    const absoluteHard = recovery
+      ? 95_000
+      : deep || largePrompt
+        ? 150_000
+        : 120_000
+    return {
+      hardTimeoutMs: bounded(
+        recovery ? options.architectRecoveryHardTimeoutMs : options.architectHardTimeoutMs,
+        initialHard,
+        30_000,
+        5 * 60_000,
+      ),
+      absoluteHardTimeoutMs: bounded(
+        recovery ? options.architectRecoveryAbsoluteHardTimeoutMs : options.architectAbsoluteHardTimeoutMs,
+        absoluteHard,
+        initialHard,
+        6 * 60_000,
+      ),
+      activityExtensionMs: bounded(
+        recovery ? options.architectRecoveryActivityExtensionMs : options.architectActivityExtensionMs,
+        recovery ? 25_000 : 35_000,
+        10_000,
+        90_000,
+      ),
+      activityWindowMs: bounded(
+        options.architectActivityWindowMs,
+        20_000,
+        5_000,
+        60_000,
+      ),
+      idleTimeoutMs: bounded(
+        recovery ? options.architectRecoveryIdleTimeoutMs : options.architectIdleTimeoutMs,
+        recovery ? 28_000 : 40_000,
+        10_000,
+        2 * 60_000,
+      ),
+      softSteerMs: bounded(
+        options.architectSoftSteerMs,
+        30_000,
+        15_000,
+        2 * 60_000,
+      ),
+      maxExplorationTools: bounded(options.architectMaxExplorationTools, 16, 8, 80),
+    }
+  }
+
+  if (normalizedRole === "plan-checker") {
+    const recovery = normalizedAttempt > 1
+    const initialHard = recovery ? 45_000 : 70_000
+    return {
+      hardTimeoutMs: bounded(
+        recovery ? options.planCheckerRecoveryHardTimeoutMs : options.planCheckerHardTimeoutMs,
+        initialHard,
+        30_000,
+        5 * 60_000,
+      ),
+      absoluteHardTimeoutMs: bounded(
+        recovery ? options.planCheckerRecoveryAbsoluteHardTimeoutMs : options.planCheckerAbsoluteHardTimeoutMs,
+        recovery ? 80_000 : 130_000,
+        initialHard,
+        5 * 60_000,
+      ),
+      activityExtensionMs: bounded(
+        recovery ? options.planCheckerRecoveryActivityExtensionMs : options.planCheckerActivityExtensionMs,
+        recovery ? 20_000 : 30_000,
+        10_000,
+        60_000,
+      ),
+      activityWindowMs: bounded(
+        options.planCheckerActivityWindowMs,
+        20_000,
+        5_000,
+        60_000,
+      ),
+      idleTimeoutMs: bounded(
+        recovery ? options.planCheckerRecoveryIdleTimeoutMs : options.planCheckerIdleTimeoutMs,
+        recovery ? 24_000 : 38_000,
+        10_000,
+        2 * 60_000,
+      ),
+      softSteerMs: bounded(
+        recovery ? options.planCheckerRecoverySoftSteerMs : options.planCheckerSoftSteerMs,
+        recovery ? 18_000 : 35_000,
+        10_000,
+        2 * 60_000,
+      ),
+      maxExplorationTools: bounded(
+        recovery ? options.planCheckerRecoveryMaxExplorationTools : options.planCheckerMaxExplorationTools,
+        recovery ? 6 : 10,
+        4,
+        40,
+      ),
+    }
+  }
+
+  return null
+}
+
+export function shouldSoftSteerArchitect(progress = {}, budget = null) {
+  if (!budget) return false
+  const elapsedMs = Number(progress.elapsedMs || 0)
+  const toolCalls = Number(progress.toolCalls || 0)
+  const idleMs = Number(progress.idleMs || 0)
+
+  if (budget.softSteerMs && elapsedMs >= budget.softSteerMs) return true
+  if (budget.maxExplorationTools && toolCalls >= budget.maxExplorationTools) return true
+
+  // If the model has gone quiet after doing real exploration, ask it to emit
+  // the plan before the hard idle watchdog has to kill the worker.
+  return toolCalls > 0 && idleMs >= Math.max(10_000, Math.floor((budget.idleTimeoutMs || 30_000) * 0.65))
+}
+
+
+export function shouldSoftSteerPlanningRole(progress = {}, budget = null) {
+  return shouldSoftSteerArchitect(progress, budget)
+}

package/lib/repo-graph.mjs

@@ -6,7 +6,7 @@ const SKIP = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
   ".ues-work", ".ues-cache", ".ues-traces", ".ues-learning", ".ues-dashboard",
-  ".ues-sandboxes", ".ues-memory", ".ues-evals",
+  ".ues-sandboxes", ".ues-memory", ".ues-evals", ".ues-services",
 ])
 
 const SOURCE_EXTENSIONS = new Set([

package/lib/repo-inspect.mjs

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process"
 const SKIP_DIRS = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "bin", "obj",
+  ".ues-services",
 ])
 
 const TEXT_EXTENSIONS = new Set([

package/lib/runtime-artifacts.mjs

@@ -0,0 +1,42 @@
+export const UES_RUNTIME_DIRS = Object.freeze([
+  ".ues-cache",
+  ".ues-traces",
+  ".ues-work",
+  ".ues-learning",
+  ".ues-dashboard",
+  ".ues-sandboxes",
+  ".ues-memory",
+  ".ues-evals",
+  ".ues-services",
+])
+
+export function normalizeRuntimePath(value) {
+  return String(value || "")
+    .replaceAll("\\", "/")
+    .replace(/^\.\//, "")
+    .replace(/^\/+/, "")
+}
+
+export function isUesRuntimeArtifactPath(value) {
+  const normalized = normalizeRuntimePath(value)
+  if (!normalized) return false
+  return UES_RUNTIME_DIRS.some(
+    (dir) => normalized === dir || normalized.startsWith(dir + "/"),
+  )
+}
+
+export function sourceFacingPaths(values = []) {
+  return [...new Set(
+    (values || [])
+      .map(normalizeRuntimePath)
+      .filter(Boolean)
+      .filter((value) => !isUesRuntimeArtifactPath(value)),
+  )]
+}
+
+export function sourceGitPathspecs() {
+  return [
+    ".",
+    ...UES_RUNTIME_DIRS.map((dir) => ":(exclude)" + dir + "/**"),
+  ]
+}

package/lib/runtime-events.mjs

@@ -1,7 +1,39 @@
 import { randomUUID } from "node:crypto"
-import { appendFile, readFile } from "node:fs/promises"
+import { appendFile, readFile, stat, writeFile } from "node:fs/promises"
+
+const DEFAULT_MAX_EVENT_FILE_BYTES = 4 * 1024 * 1024
+const DEFAULT_RETAIN_EVENT_BYTES = 2 * 1024 * 1024
+
+async function compactRuntimeEventFile(file, options = {}) {
+  const maxBytes = Math.max(
+    256 * 1024,
+    Math.min(64 * 1024 * 1024, Number(options.maxBytes || process.env.UES_EVENT_LOG_MAX_BYTES || DEFAULT_MAX_EVENT_FILE_BYTES)),
+  )
+  const retainBytes = Math.max(
+    128 * 1024,
+    Math.min(maxBytes, Number(options.retainBytes || DEFAULT_RETAIN_EVENT_BYTES)),
+  )
+  const info = await stat(file).catch(() => null)
+  if (!info?.isFile() || info.size < maxBytes) return false
+
+  const raw = await readFile(file)
+  let kept = raw.subarray(Math.max(0, raw.length - retainBytes))
+  const newline = kept.indexOf(0x0a)
+  if (newline >= 0 && raw.length > retainBytes) kept = kept.subarray(newline + 1)
+  const marker = Buffer.from(JSON.stringify({
+    schemaVersion: 1,
+    id: randomUUID(),
+    type: "runtime-events.compacted",
+    at: new Date().toISOString(),
+    previousBytes: raw.length,
+    retainedBytes: kept.length,
+  }) + "\n")
+  await writeFile(file, Buffer.concat([marker, kept]))
+  return true
+}
 
 export async function appendRuntimeEvent(file, type, data = {}) {
+  await compactRuntimeEventFile(file).catch(() => false)
   const event = {
     schemaVersion: 1,
     id: randomUUID(),

package/lib/safety.mjs

@@ -1,5 +1,6 @@
 const RULES = [
   { id: "git-force", pattern: /\bgit\s+(?:push\b[^\n]*(?:--force(?:-with-lease)?|(?:^|\s)-f(?:\s|$))|reset\s+--hard|clean\s+-[^\n]*f)/i },
+  { id: "git-discard-work", pattern: /\bgit\s+(?:restore\b|checkout\s+--(?:\s|$)|stash(?:\s|$))/i },
   { id: "history-rewrite", pattern: /\bgit\s+(?:rebase\b|filter-branch\b|filter-repo\b)/i },
   { id: "publish", pattern: /\b(?:npm\s+publish|pnpm\s+publish|yarn\s+npm\s+publish)\b/i },
   { id: "destructive-files", pattern: /(?:^|[;&|]\s*)(?:rm\s+-[^\n]*r[^\n]*f|rmdir\s+\/s|del\s+\/s|remove-item\b[^\n]*-recurse[^\n]*-force)/i },

package/lib/semantic-index.mjs

@@ -12,7 +12,7 @@ const SOURCE_EXTENSIONS = new Set([
 const SKIP_DIRS = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
-  ".ues-work", ".ues-learning", ".ues-memory", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces",
+  ".ues-work", ".ues-learning", ".ues-memory", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces", ".ues-services",
 ])
 const STOP_IDENTIFIERS = new Set([
   "const","let","var","function","class","interface","type","export","import","from","return",