opencode-agent-skill 14.4.0 → 15.1.0

package/global-config/skills/engineering-orchestrator/references/long-horizon.md

@@ -13,6 +13,11 @@ When the user explicitly chooses the long-horizon workflow (for example with `/u
   STATE.json
   EVIDENCE.json
   EVENTS.jsonl
+  EXECUTION_CONTRACT.json
+  FINAL_VERDICTS.json
+  phases/
+    MANIFEST.json
+    phase-XX-<slug>.json
   tasks/
   reports/
 ```
@@ -21,11 +26,15 @@ The directory is git-ignored execution state, not hidden reasoning. Store requir
 
 ## Machine-enforced gates
 
-The V6 engine enforces three boundaries:
+The runtime enforces seven boundaries:
 
-1. **Plan gate** — `work plan` leaves the item in `awaiting-plan-approval`. Long/high-risk plans require a structured `plan-verification` receipt bound to the current plan hash before `work approve-plan` succeeds.
-2. **Concurrent state gate** — all mutable `STATE.json` and `EVIDENCE.json` operations use a per-work-item lock plus atomic file replacement, preventing safe-wave executors from losing each other's state.
-3. **Integration gate** — long/high-risk PASS requires a structured `integration-verification` receipt bound to the current workspace fingerprint. Finalization rejects any later workspace change.
+1. **Inherited-work gate** — snapshot source-facing dirty paths before planning. UES children may not discard them with restore/checkout/stash/clean/reset, and planned writers must declare every touched file.
+2. **Local-env gate** — local `.env*` runtime inputs are no-write by default; only explicit user authorization permits local env mutation. Repository templates remain writable.
+3. **Plan gate** — `work plan` leaves the item in `awaiting-plan-approval`. Long/high-risk plans require a structured `plan-verification` receipt bound to the current plan hash before `work approve-plan` succeeds.
+4. **Phase gate** — explicit execution phases become deterministic previous-phase barriers. Constraint-only phases stay global invariants.
+5. **Concurrent state gate** — all mutable `STATE.json` and `EVIDENCE.json` operations use a per-work-item lock plus atomic file replacement, preventing safe-wave executors from losing each other's state.
+6. **Integration gate** — long/high-risk source completion requires a structured `integration-verification` receipt bound to the current workspace fingerprint. Finalization rejects any later workspace change.
+7. **Verdict matrix gate** — source, runtime, database cleanup and real-device proof remain independent. Missing required evidence is reported as not verified rather than promoted to PASS.
 
 ## Pipeline
 
@@ -33,18 +42,19 @@ The V6 engine enforces three boundaries:
 2. Write observable acceptance criteria into `SPEC.md`.
 3. Initialize state with `ocskill work init`.
 4. Create `PLAN.json` following the plan schema and import it with `ocskill work plan`.
-5. Run `ues-plan-checker`. If it returns PASS, create `work gate-receipt <slug> plan` and persist approval with `work approve-plan --receipt-file ...`.
-6. Use `ocskill task-graph` to compute dependency-safe waves.
-7. For each ready task:
+5. If the user supplied explicit `PHASE N` sections, preserve every execution phase in the plan and let UES add phase barriers; constraint-only phases remain invariants.
+6. Run `ues-plan-checker`. If it returns PASS, create `work gate-receipt <slug> plan` and persist approval with `work approve-plan --receipt-file ...`.
+7. Persist the execution contract/phase artifacts and use `ocskill task-graph` to compute dependency-safe waves.
+8. For each ready task:
    - on OpenCode V2, if two or more approved tasks are independent, prefer `ues.dispatch_parallel` so one shared model can execute them concurrently with isolated worktrees, leases, independent verifier sessions and serialized integration;
    - otherwise prefer `ues.dispatch_task`, which performs `work start`, creates a fresh `ues-executor` session, selects the configured attempt-based model tier, prompts it with a bounded context pack and waits for completion;
    - inspect the child diff and verification;
    - record at least one successful `work verify-command` receipt for long/high-risk work;
    - persist `work complete --evidence ...` or `work fail --reason ...`.
-8. On failure, re-diagnose rather than stacking patches. A later `ues.dispatch_task` attempt can escalate from standard to heavy when configured.
-9. After all tasks complete, run `ues-integration-verifier`.
-10. Persist the verifier's actual result with a structured integration receipt plus `ocskill work verify-integration --receipt-file ...`.
-11. Only a recorded PASS with an unchanged workspace can be finalized.
+9. On failure, re-diagnose rather than stacking patches. A later `ues.dispatch_task` attempt can escalate from standard to heavy when configured.
+10. After all tasks complete, run `ues-integration-verifier`.
+11. Persist the verifier's actual result with a structured integration receipt plus `ocskill work verify-integration --receipt-file ...`.
+12. Emit the independent final verdict matrix and persist `FINAL_VERDICTS.json`. Only a recorded PASS with an unchanged workspace can be finalized.
 
 ## Parallelism
 

package/lib/activity-deadline.mjs

@@ -0,0 +1,70 @@
+function finite(value, fallback, min = 0, max = Number.MAX_SAFE_INTEGER) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function createAdaptiveDeadline(options = {}, startedAt = Date.now()) {
+  const initialMs = finite(options.hardTimeoutMs, 60_000, 1_000)
+  const absoluteMs = Math.max(
+    initialMs,
+    finite(options.absoluteHardTimeoutMs, initialMs, initialMs),
+  )
+  const extensionMs = finite(options.activityExtensionMs, 0, 0, absoluteMs)
+  const activityWindowMs = finite(
+    options.activityWindowMs,
+    Math.max(5_000, Math.min(extensionMs || initialMs, 30_000)),
+    1_000,
+    absoluteMs,
+  )
+
+  let deadlineAt = startedAt + initialMs
+  const absoluteAt = startedAt + absoluteMs
+  let extensions = 0
+
+  function maybeExtend(now = Date.now(), lastActivityAt = 0) {
+    if (extensionMs <= 0 || deadlineAt >= absoluteAt) {
+      return { extended: false, deadlineAt, absoluteAt, extensions }
+    }
+    if (now - Number(lastActivityAt || 0) > activityWindowMs) {
+      return { extended: false, deadlineAt, absoluteAt, extensions }
+    }
+    const next = Math.min(absoluteAt, Math.max(deadlineAt, now + extensionMs))
+    if (next <= deadlineAt) {
+      return { extended: false, deadlineAt, absoluteAt, extensions }
+    }
+    deadlineAt = next
+    extensions += 1
+    return { extended: true, deadlineAt, absoluteAt, extensions }
+  }
+
+  function shouldAbort(now = Date.now(), lastActivityAt = 0) {
+    if (now < deadlineAt) {
+      return { abort: false, deadlineAt, absoluteAt, extensions }
+    }
+    const extension = maybeExtend(now, lastActivityAt)
+    if (extension.extended) {
+      return { abort: false, ...extension }
+    }
+    return {
+      abort: true,
+      reason: now >= absoluteAt ? "absolute-hard-timeout" : "hard-timeout",
+      deadlineAt,
+      absoluteAt,
+      extensions,
+    }
+  }
+
+  return {
+    startedAt,
+    initialMs,
+    absoluteMs,
+    extensionMs,
+    activityWindowMs,
+    get deadlineAt() { return deadlineAt },
+    get absoluteAt() { return absoluteAt },
+    get extensions() { return extensions },
+    maybeExtend,
+    shouldAbort,
+  }
+}

package/lib/adaptive-context-budget.mjs

@@ -59,20 +59,35 @@ export function adaptiveContextBudget(taskPolicy = {}, role = "executor", attemp
   const profile = String(taskPolicy.executionProfile || taskPolicy.profile?.name || "standard")
   const highRisk = taskPolicy.risk === "high" || taskPolicy.risk === "critical"
 
-  // High-risk work keeps the original evidence budget. Turbo mode must not trade
-  // away security/payment/schema evidence for latency.
-  if (highRisk || options.disabled === true) {
+  if (options.disabled === true) {
     return {
       schemaVersion: 1,
       budget: base,
       baseBudget: base,
       adaptive: false,
-      reason: highRisk ? "high-risk-preserves-base-budget" : "disabled",
+      reason: "disabled",
     }
   }
 
   const table = ROLE_TARGETS[profile] || ROLE_TARGETS.standard
   const target = clamp(table?.[role], base, 4_000, base)
+  const plannerRole = role === "architect" || role === "plan-checker"
+
+  // High-risk execution/verification keeps the full evidence ceiling. Read-only
+  // planning roles are allowed a bounded context because they can use targeted
+  // repository tools and are independently plan-gated before any write begins.
+  if (highRisk && !plannerRole) {
+    return {
+      schemaVersion: 1,
+      budget: base,
+      baseBudget: base,
+      adaptive: false,
+      reason: "high-risk-execution-preserves-base-budget",
+      profile,
+      role,
+      attempt: Math.max(1, Math.trunc(Number(attempt || 1))),
+    }
+  }
   const normalizedAttempt = Math.max(1, Math.trunc(Number(attempt || 1)))
 
   // Failed attempts expand deterministically back toward the policy ceiling.
@@ -92,6 +107,11 @@ export function adaptiveContextBudget(taskPolicy = {}, role = "executor", attemp
     profile,
     role,
     attempt: normalizedAttempt,
-    reason: budget < base ? "role-bounded-expand-on-failure" : "policy-ceiling",
+    reason:
+      highRisk && plannerRole
+        ? "high-risk-planner-role-bounded"
+        : budget < base
+          ? "role-bounded-expand-on-failure"
+          : "policy-ceiling",
   }
 }

package/lib/affected-tests.mjs

@@ -6,9 +6,10 @@ import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
 
 const TEST_RE = /(?:^|[/.\\])(?:__tests__|tests?|spec)(?:[/.\\]|$)|\.(?:test|spec|e2e-spec)\.[cm]?[jt]sx?$/i
 const SOURCE_EXT = new Set([".js",".jsx",".mjs",".cjs",".ts",".tsx",".py",".java",".kt",".kts",".cs",".go",".rs",".dart",".swift"])
-const SKIP = new Set([".git","node_modules",".next","dist","build","coverage",".venv","venv","target","Pods","DerivedData",".gradle",".ues-cache",".ues-work",".ues-sandboxes",".ues-traces",".ues-learning",".ues-dashboard",".ues-memory",".ues-evals"])
+const SKIP = new Set([".git","node_modules",".next","dist","build","coverage",".venv","venv","target","Pods","DerivedData",".gradle",".ues-cache",".ues-work",".ues-sandboxes",".ues-traces",".ues-learning",".ues-dashboard",".ues-memory",".ues-evals",".ues-services"])
 const AFFECTED_TEST_CACHE = new Map()
 const AFFECTED_TEST_INFLIGHT = new Map()
+const TEST_CONTENT_CACHE = new Map()
 
 function git(root, args) {
   return spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 })
@@ -47,6 +48,37 @@ async function walk(root, options = {}) {
   return rows
 }
 
+async function projectFiles(root, options = {}) {
+  const indexed = git(root, ["ls-files", "-co", "--exclude-standard", "-z"])
+  if (indexed.status === 0) {
+    const files = String(indexed.stdout || "")
+      .split("\0")
+      .map((value) => normalize(value))
+      .filter(Boolean)
+      .filter((relative) => !relative.split("/").some((part) => SKIP.has(part)))
+      .map((relative) => path.resolve(root, relative))
+    return { files: [...new Set(files)], source: "git-index" }
+  }
+  return { files: await walk(root, options), source: "filesystem-walk" }
+}
+
+async function cachedTestContent(file, info) {
+  if (!info?.size || info.size > 512 * 1024) return ""
+  const key = path.resolve(file)
+  const signature = String(info.size) + ":" + String(Math.trunc(Number(info.mtimeMs || 0)))
+  const cached = TEST_CONTENT_CACHE.get(key)
+  if (cached?.signature === signature) return cached.content
+  const content = await readFile(key, "utf8").catch(() => "")
+  TEST_CONTENT_CACHE.delete(key)
+  TEST_CONTENT_CACHE.set(key, { signature, content })
+  while (TEST_CONTENT_CACHE.size > 1200) {
+    const oldest = TEST_CONTENT_CACHE.keys().next().value
+    if (!oldest) break
+    TEST_CONTENT_CACHE.delete(oldest)
+  }
+  return content
+}
+
 export function gitChangedFiles(root = process.cwd()) {
   root = path.resolve(root)
   const inside = git(root, ["rev-parse", "--is-inside-work-tree"])
@@ -190,7 +222,8 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
   }
 
   const compute = async () => {
-    const files = await walk(root, options)
+    const inventory = await projectFiles(root, options)
+    const files = inventory.files
     const tests = files
       .map((file) => normalize(path.relative(root, file)))
       .filter((file) => TEST_RE.test(file))
@@ -198,9 +231,7 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
     const ranked = []
     for (const testFile of tests) {
       const info = await stat(path.join(root, testFile)).catch(() => null)
-      const content = info?.size && info.size <= 512 * 1024
-        ? await readFile(path.join(root, testFile), "utf8").catch(() => "")
-        : ""
+      const content = await cachedTestContent(path.join(root, testFile), info)
       let best = { score: 0, reasons: [], changedFile: null }
       for (const changedFile of changed) {
         const current = scoreTest(testFile, changedFile, content)
@@ -232,6 +263,7 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
       suggestedCommands,
       truncated: ranked.length > selected.length,
       cacheHit: false,
+      inventorySource: inventory.source,
     }
   }
 
@@ -257,4 +289,5 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
 export function clearAffectedTestCache() {
   AFFECTED_TEST_CACHE.clear()
   AFFECTED_TEST_INFLIGHT.clear()
+  TEST_CONTENT_CACHE.clear()
 }

package/lib/capability-fabric.mjs

@@ -129,6 +129,23 @@ export function defaultCapabilityRegistry(root = process.cwd()) {
       "context.reversible": [
         { id: "ues-evidence-context", kind: "builtin", priority: 120, quality: 0.98, costClass: "low", latencyClass: "fast", metadata: { reversible: true, searchable: true, levels: ["T1", "T2", "T3", "raw"] } },
       ],
+      "runtime.service": [
+        {
+          id: "ues-managed-service",
+          kind: "builtin",
+          priority: 125,
+          quality: 0.98,
+          costClass: "low",
+          latencyClass: "fast",
+          metadata: {
+            shellFree: true,
+            readiness: ["port", "log", "process"],
+            actions: ["start", "wait-ready", "status", "logs", "stop", "restart"],
+            boundedLifetime: true,
+            evidenceLogs: true,
+          },
+        },
+      ],
       memory: [
         { id: "ues-memory", kind: "builtin", priority: 100, quality: 0.9, costClass: "low", latencyClass: "fast" },
       ],

package/lib/code-intelligence/index.mjs

@@ -3,7 +3,7 @@ import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { querySemanticIndex } from "../semantic-index.mjs"
 import { anchoredLines, applyAnchoredEdits } from "./edit-anchor.mjs"
-import { diagnoseCode, lspProviderStatus } from "./lsp-provider.mjs"
+import { diagnoseCode, lspOperation, lspProviderStatus, LSP_OPERATIONS } from "./lsp-provider.mjs"
 
 const AST_COMMANDS = ["ast-grep", "sg"]
 const commandCache = new Map()
@@ -40,6 +40,7 @@ export function probeCodeIntelligence(file = "") {
     semanticIndex: true,
     astProvider,
     lsp: lspProviderStatus(file),
+    lspOperations: [...LSP_OPERATIONS],
   }
 }
 
@@ -92,4 +93,4 @@ export async function searchCodeIntelligence(root, query, options = {}) {
   }
 }
 
-export { diagnoseCode, lspProviderStatus } from "./lsp-provider.mjs"
+export { diagnoseCode, lspOperation, lspProviderStatus, LSP_OPERATIONS } from "./lsp-provider.mjs"