opencode-agent-skill 14.4.0 → 15.1.0

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",