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

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