opencode-agent-skill 15.1.1 → 15.1.2

package/lib/context-manifest.mjs

@@ -7,7 +7,8 @@ import { taskFiles } from "./task-graph.mjs"
 import { buildSemanticIndexCached, querySemanticIndex } from "./semantic-index.mjs"
 import { queryContextHierarchy } from "./hierarchical-context.mjs"
 import { rankContextGraph } from "./context-graph-rank.mjs"
-import { runtimeWorkspaceSnapshot } from "./workspace-fingerprint.mjs"
+import { runtimeWorkspaceSnapshot, workspaceStatusEntries } from "./workspace-fingerprint.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const ROOT_INSTRUCTIONS = [
   "AGENTS.md",
@@ -29,6 +30,14 @@ function unique(values) {
   return [...new Set(values.filter(Boolean))]
 }
 
+function boundedFailure(component, error, impact = "evidence") {
+  return {
+    component,
+    impact,
+    message: String(error instanceof Error ? error.message : error || "unknown failure").slice(0, 500),
+  }
+}
+
 function safeFull(root, relative) {
   const base = path.resolve(root)
   const full = path.resolve(base, relative)
@@ -149,18 +158,22 @@ function symbolHits(source, terms, limit = 12) {
 function gitChangedFiles(root) {
   const result = spawnSync(
     "git",
-    ["status", "--porcelain=v1", "--untracked-files=all"],
+    [
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=all",
+      "--",
+      ...sourceGitPathspecs(),
+    ],
     { cwd: root, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 },
   )
   if (result.status !== 0) return []
-  return unique(
-    result.stdout
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map((line) => line.slice(3).trim())
-      .map((value) => value.includes(" -> ") ? value.split(" -> ").at(-1) : value)
-      .map((value) => value.replaceAll("\\", "/")),
-  )
+  return unique(sourceFacingPaths(
+    workspaceStatusEntries(result.stdout)
+      .filter((entry) => entry.renameSource !== true)
+      .map((entry) => entry.file),
+  ))
 }
 
 async function nearbyInstructions(root, declared) {
@@ -272,11 +285,15 @@ export async function buildContextManifest(root, task, options = {}) {
     ...(task?.verification || []),
   ].filter(Boolean).join(" ")
 
+  const contextDiagnostics = []
   const semanticSnapshot = await buildSemanticIndexCached(root, {
     maxFiles: options.semanticMaxFiles ?? 6000,
     maxDepth: options.semanticMaxDepth ?? 14,
     workspaceFingerprint: reusableWorkspaceFingerprint,
-  }).catch(() => null)
+  }).catch((error) => {
+    contextDiagnostics.push(boundedFailure("semantic-snapshot", error, "performance"))
+    return null
+  })
 
   const useGraph = strategy.includes("graph")
   const [hierarchy, semantic, graph, instructions] = await Promise.all([
@@ -285,19 +302,31 @@ export async function buildContextManifest(root, task, options = {}) {
       maxScopes: options.hierarchyMaxScopes ?? 6,
       maxFiles: options.semanticMaxFiles ?? 6000,
       builtIndex: semanticSnapshot || undefined,
-    }).catch(() => null),
+    }).catch((error) => {
+      contextDiagnostics.push(boundedFailure("hierarchy", error))
+      return null
+    }),
     querySemanticIndex(root, queryText, {
       limit: 32,
       maxFiles: options.semanticMaxFiles ?? 6000,
       builtIndex: semanticSnapshot || undefined,
-    }).catch(() => null),
+    }).catch((error) => {
+      contextDiagnostics.push(boundedFailure("semantic-query", error))
+      return null
+    }),
     useGraph
       ? buildRepoGraphCached(root, {
           maxFiles: options.maxFiles ?? 2500,
           workspaceFingerprint: reusableWorkspaceFingerprint,
-        }).catch(() => ({ nodes: [], edges: [], hotspots: [], scannedFiles: 0, truncated: false }))
+        }).catch((error) => {
+          contextDiagnostics.push(boundedFailure("repo-graph", error))
+          return { nodes: [], edges: [], hotspots: [], scannedFiles: 0, truncated: false }
+        })
       : Promise.resolve({ nodes: [], edges: [], hotspots: [], scannedFiles: 0, truncated: false }),
-    nearbyInstructions(root, declared).catch(() => []),
+    nearbyInstructions(root, declared).catch((error) => {
+      contextDiagnostics.push(boundedFailure("instructions", error))
+      return []
+    }),
   ])
   const hierarchyScopes = hierarchy?.scopes?.map((item) => item.path) || []
 
@@ -402,11 +431,8 @@ export async function buildContextManifest(root, task, options = {}) {
     ...instructions,
   ])
 
-  const files = []
-  for (const file of priority) {
-    const info = await fileInfo(root, file)
-    if (info) files.push(info)
-  }
+  const files = (await Promise.all(priority.map((file) => fileInfo(root, file))))
+    .filter(Boolean)
 
   let remaining = budget
   const categoryRemaining = {
@@ -436,9 +462,18 @@ export async function buildContextManifest(root, task, options = {}) {
     })
   }
 
+  contextDiagnostics.sort((a, b) =>
+    a.component.localeCompare(b.component) ||
+    a.impact.localeCompare(b.impact) ||
+    a.message.localeCompare(b.message)
+  )
+  const evidenceDegraded = contextDiagnostics.some((item) => item.impact === "evidence")
+
   return {
     schemaVersion: 4,
     task: task?.id || null,
+    contextQuality: evidenceDegraded ? "degraded" : "full",
+    degradedComponents: contextDiagnostics,
     strategy,
     queryTerms: terms,
     declared,

package/lib/execution-contract.mjs

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto"
 import { spawnSync } from "node:child_process"
 import { lstatSync, readFileSync, readlinkSync } from "node:fs"
 import path from "node:path"
-import { sourceFacingPaths } from "./runtime-artifacts.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const PHASE_HEADING = /^\s*(?:=+\s*)?PHASE\s+(\d+)\s*(?:[—–:-]+)\s*(.+?)\s*$/i
 const LOCAL_ENV_BASENAME = /^\.env(?:\.[^/\\]+)?$/i
@@ -187,7 +187,7 @@ export function captureInheritedDirtyState(root, options = {}) {
   ) {
     statusOutput = workspaceState.statusOutput
   } else {
-    const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+    const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...sourceGitPathspecs()], {
       cwd: resolved,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024,

package/lib/memory-engine.mjs

@@ -5,6 +5,8 @@ import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { evidenceExists, putEvidence } from "./evidence-store.mjs"
 import { buildRepoGraphCached } from "./repo-graph.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
+import { workspaceStatusEntries } from "./workspace-fingerprint.mjs"
 
 const MEMORY_DIR = ".ues-memory"
 const MEMORY_FILE = "MEMORY.json"
@@ -671,21 +673,24 @@ export async function memoryStatus(root = process.cwd()) {
 }
 
 function changedFiles(root) {
-  const result = spawnSync("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
+  const result = spawnSync("git", [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--",
+    ...sourceGitPathspecs(),
+  ], {
     cwd: path.resolve(root),
     encoding: "utf8",
     windowsHide: true,
     maxBuffer: 4 * 1024 * 1024,
   })
   if (result.status !== 0) return []
-  return uniq(
-    String(result.stdout || "")
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map((line) => line.slice(3).trim())
-      .map((value) => value.includes(" -> ") ? value.split(" -> ").at(-1) : value)
-      .map(normalizeFile),
-  ).slice(0, 80)
+  const changed = workspaceStatusEntries(String(result.stdout || ""))
+    .filter((entry) => entry.renameSource !== true)
+    .map((entry) => normalizeFile(entry.file))
+  return uniq(sourceFacingPaths(changed)).slice(0, 80)
 }
 
 function compactVerification(value, limit = 1200) {

package/lib/pi-rpc-pool.mjs

@@ -469,6 +469,17 @@ export class PiRpcWorkerPool {
   constructor(options = {}) {
     this.maxWorkers = Math.max(1, Math.min(16, Number(options.maxWorkers || 8)))
     this.workers = new Map()
+    this.reservations = new Map()
+  }
+
+  reserve(key) {
+    this.reservations.set(key, (this.reservations.get(key) || 0) + 1)
+  }
+
+  release(key) {
+    const next = Math.max(0, (this.reservations.get(key) || 0) - 1)
+    if (next > 0) this.reservations.set(key, next)
+    else this.reservations.delete(key)
   }
 
   async pruneIdleWorkers(protectedKey = null) {
@@ -476,7 +487,7 @@ export class PiRpcWorkerPool {
       let candidateKey = null
       let candidate = null
       for (const [key, worker] of this.workers.entries()) {
-        if (key === protectedKey) continue
+        if (key === protectedKey || this.reservations.has(key)) continue
         if (!worker || worker.dead) {
           candidateKey = key
           candidate = worker
@@ -494,37 +505,56 @@ export class PiRpcWorkerPool {
   }
 
   async run(key, spec, message, options = {}) {
-    let worker = this.workers.get(key)
-    let workerReused = Boolean(worker && !worker.dead && worker.runs > 0)
-    if (options.reuseSession === true && !workerReused) {
-      const error = new Error("Pi RPC same-session resume unavailable")
-      error.code = "UES_RPC_SESSION_UNAVAILABLE"
-      throw error
-    }
-    if (!worker || worker.dead) {
-      if (worker) {
-        await worker.stop().catch(() => {})
+    this.reserve(key)
+    let worker = null
+    let workerReused = false
+    let staleStop = null
+
+    try {
+      worker = this.workers.get(key)
+      workerReused = Boolean(worker && !worker.dead && worker.runs > 0)
+      if (options.reuseSession === true && !workerReused) {
+        const error = new Error("Pi RPC same-session resume unavailable")
+        error.code = "UES_RPC_SESSION_UNAVAILABLE"
+        throw error
+      }
+
+      if (!worker || worker.dead) {
+        const staleWorker = worker
+        if (staleWorker) this.workers.delete(key)
+
+        // Publish the replacement synchronously before any await. Concurrent
+        // callers for the same key must see this worker rather than allocate a
+        // second untracked process while the stale worker is being reaped.
+        worker = new RpcWorker(spec)
+        workerReused = false
+        this.workers.set(key, worker)
+        if (staleWorker) staleStop = staleWorker.stop().catch(() => {})
+      } else {
+        // Refresh insertion order so the bounded worker map behaves as an LRU.
         this.workers.delete(key)
+        this.workers.set(key, worker)
       }
-      worker = new RpcWorker(spec)
-      workerReused = false
-      this.workers.set(key, worker)
-      await this.pruneIdleWorkers(key)
-    } else {
-      // Refresh insertion order so the bounded worker map behaves as an LRU.
-      this.workers.delete(key)
-      this.workers.set(key, worker)
-    }
 
-    try {
-      const result = await worker.run(message, options)
+      // Queue the run before pruning. The reservation prevents another
+      // concurrent key from treating this not-yet-active worker as idle during
+      // the small window before RpcWorker.execute sets active=true.
+      const runPromise = worker.run(message, options)
       await this.pruneIdleWorkers(key)
+      if (staleStop) await staleStop
+
+      const result = await runPromise
       return { ...result, workerReused }
     } catch (error) {
-      this.workers.delete(key)
-      await worker.stop().catch(() => {})
+      if (worker && this.workers.get(key) === worker) {
+        this.workers.delete(key)
+        await worker.stop().catch(() => {})
+      }
       await this.pruneIdleWorkers().catch(() => {})
       throw error
+    } finally {
+      this.release(key)
+      await this.pruneIdleWorkers(key).catch(() => {})
     }
   }
 
@@ -643,6 +673,7 @@ export class PiRpcWorkerPool {
     return {
       workers: this.workers.size,
       activeWorkers: active.length,
+      reservedWorkers: this.reservations.size,
       keys: [...this.workers.keys()],
       active,
     }

package/lib/repo-graph.mjs

@@ -1,12 +1,12 @@
 import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
 import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
+import { UES_RUNTIME_DIRS } from "./runtime-artifacts.mjs"
 
 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-services",
+  ...UES_RUNTIME_DIRS,
 ])
 
 const SOURCE_EXTENSIONS = new Set([

package/lib/repo-inspect.mjs

@@ -2,11 +2,12 @@ import { existsSync } from "node:fs"
 import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
 import { spawnSync } from "node:child_process"
+import { UES_RUNTIME_DIRS, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 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",
+  ...UES_RUNTIME_DIRS,
 ])
 
 const TEXT_EXTENSIONS = new Set([
@@ -231,7 +232,7 @@ export async function impactMap(root = process.cwd(), query = "") {
 
 export async function checkWorkingTree(root = process.cwd()) {
   root = path.resolve(root)
-  const status = runGit(root, ["status", "--porcelain=v1", "--branch"])
+  const status = runGit(root, ["status", "--porcelain=v1", "--branch", "--", ...sourceGitPathspecs()])
   if (status.status !== 0) {
     return { root, git: false, error: (status.stderr || status.stdout || "").trim() }
   }

package/lib/semantic-index.mjs

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs"
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
+import { UES_RUNTIME_DIRS } from "./runtime-artifacts.mjs"
 
 const SCHEMA_VERSION = 1
 const CACHE_DIR = ".ues-cache"
@@ -12,7 +13,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-services",
+  ...UES_RUNTIME_DIRS,
 ])
 const STOP_IDENTIFIERS = new Set([
   "const","let","var","function","class","interface","type","export","import","from","return",

package/lib/task-engine.mjs

@@ -20,6 +20,7 @@ import { capabilityFabricStatus } from "./capability-fabric.mjs"
 import { assertActivePlanScope, persistPlanScope } from "./work-plan-scope.mjs"
 import { classifyDecisionPolicy } from "./decision-policy.mjs"
 import { readTextAuto } from "./text-encoding.mjs"
+import { UES_RUNTIME_DIRS, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const WORK_DIR = ".ues-work"
 const STATE_SCHEMA = 4
@@ -176,7 +177,7 @@ function gitCapture(root, args) {
 }
 
 const FINGERPRINT_SKIP_DIRS = new Set([
-  ".git", ".ues-work", ".ues-learning", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces", ".ues-memory",
+  ".git", ...UES_RUNTIME_DIRS,
   "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".cache", ".turbo", "target", "bin", "obj",
 ])
@@ -250,17 +251,35 @@ function nonGitWorkspaceFingerprint(root, options = {}) {
 
 export function workspaceFingerprint(root) {
   root = path.resolve(root)
-  const inside = gitCapture(root, ["rev-parse", "--is-inside-work-tree"])
-  if (inside.status !== 0) {
-    return nonGitWorkspaceFingerprint(root)
+
+  // Fast common path: resolve worktree identity and HEAD in one Git process.
+  // Preserve the unborn-HEAD behavior by falling back to separate probes only
+  // when the combined command cannot resolve HEAD.
+  const identity = gitCapture(root, ["rev-parse", "--is-inside-work-tree", "HEAD"])
+  const identityLines = String(identity.stdout || "").trim().split(/\r?\n/).filter(Boolean)
+  let insideWorktree = identity.status === 0 && identityLines[0] === "true"
+  let headOutput = identity.status === 0 && insideWorktree
+    ? (identityLines[1] || "")
+    : null
+
+  if (!insideWorktree) {
+    const inside = gitCapture(root, ["rev-parse", "--is-inside-work-tree"])
+    if (inside.status !== 0 || String(inside.stdout || "").trim() !== "true") {
+      return nonGitWorkspaceFingerprint(root)
+    }
+    insideWorktree = true
+    const head = gitCapture(root, ["rev-parse", "HEAD"])
+    headOutput = head.status === 0
+      ? head.stdout
+      : "ERROR:" + (head.stderr || head.stdout || "")
   }
 
-  const parts = []
+  const parts = [String(headOutput || "")]
+  const sourcePathspecs = sourceGitPathspecs()
   const commands = [
-    ["rev-parse", "HEAD"],
-    ["status", "--porcelain=v1", "--untracked-files=all", "--", ".", ":(exclude).ues-work", ":(exclude).ues-learning", ":(exclude).ues-dashboard", ":(exclude).ues-sandboxes", ":(exclude).ues-cache", ":(exclude).ues-traces", ":(exclude).ues-memory"],
-    ["diff", "--binary", "--no-ext-diff", "--", ".", ":(exclude).ues-work", ":(exclude).ues-learning", ":(exclude).ues-dashboard", ":(exclude).ues-sandboxes", ":(exclude).ues-cache", ":(exclude).ues-traces", ":(exclude).ues-memory"],
-    ["diff", "--cached", "--binary", "--no-ext-diff", "--", ".", ":(exclude).ues-work", ":(exclude).ues-learning", ":(exclude).ues-dashboard", ":(exclude).ues-sandboxes", ":(exclude).ues-cache", ":(exclude).ues-traces", ":(exclude).ues-memory"],
+    ["status", "--porcelain=v1", "--untracked-files=all", "--", ...sourcePathspecs],
+    ["diff", "--binary", "--no-ext-diff", "--", ...sourcePathspecs],
+    ["diff", "--cached", "--binary", "--no-ext-diff", "--", ...sourcePathspecs],
   ]
   for (const args of commands) {
     const result = gitCapture(root, args)

package/lib/workspace-fingerprint.mjs

@@ -2,12 +2,9 @@ import { createHash } from "node:crypto"
 import { lstatSync, readFileSync, readlinkSync } from "node:fs"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
-import { UES_RUNTIME_DIRS } from "./runtime-artifacts.mjs"
+import { sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
-const RUNTIME_PATHSPECS = [
-  ".",
-  ...UES_RUNTIME_DIRS.map((dir) => `:(exclude)${dir}/**`),
-]
+const RUNTIME_PATHSPECS = sourceGitPathspecs()
 
 let nonGitNonce = 0
 
@@ -132,12 +129,23 @@ function nonGitSnapshot(root) {
 
 export function captureWorkspaceStateV2(root = process.cwd()) {
   root = path.resolve(root)
-  const inside = git(root, ["rev-parse", "--is-inside-work-tree"])
-  if (inside.status !== 0 || String(inside.stdout || "").trim() !== "true") {
-    return nonGitSnapshot(root)
+
+  // Fast common path: resolve worktree identity and HEAD in one Git process.
+  // A fallback probe is only needed for an unborn/missing HEAD.
+  const identity = git(root, ["rev-parse", "--is-inside-work-tree", "HEAD"])
+  const identityLines = String(identity.stdout || "").trim().split(/\r?\n/).filter(Boolean)
+  let insideWorktree = identityLines[0] === "true"
+  let head = {
+    ...identity,
+    stdout: identity.status === 0 && insideWorktree ? (identityLines[1] || "") : "",
+  }
+  if (identity.status !== 0) {
+    const inside = git(root, ["rev-parse", "--is-inside-work-tree"])
+    insideWorktree = inside.status === 0 && String(inside.stdout || "").trim() === "true"
+    head = { ...identity, stdout: "" }
   }
+  if (!insideWorktree) return nonGitSnapshot(root)
 
-  const head = git(root, ["rev-parse", "HEAD"])
   const status = git(root, [
     "status",
     "--porcelain=v1",

package/lib/workspace-hygiene.mjs

@@ -4,7 +4,7 @@ import { rm } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { decodeTextBuffer } from "./text-encoding.mjs"
-import { isUesRuntimeArtifactPath, sourceFacingPaths } from "./runtime-artifacts.mjs"
+import { isUesRuntimeArtifactPath, sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const CODE_EXTENSIONS = new Set([
   ".js", ".cjs", ".mjs", ".jsx", ".ts", ".cts", ".mts", ".tsx",
@@ -113,7 +113,7 @@ function gitStatusEntries(root, workspaceState = null) {
   ) {
     return parseGitStatusEntries(workspaceState.statusOutput)
   }
-  const result = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+  const result = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...sourceGitPathspecs()], {
     cwd: resolved,
     encoding: "utf8",
     windowsHide: true,

package/lib/worktree-sandbox.mjs

@@ -4,6 +4,7 @@ import { copyFile, mkdir, readFile, readdir, rm, unlink, writeFile } from "node:
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { isUesRuntimeArtifactPath, sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
+import { workspaceStatusEntries } from "./workspace-fingerprint.mjs"
 
 function git(root, args, options = {}) {
   return spawnSync("git", args, {
@@ -15,15 +16,20 @@ function git(root, args, options = {}) {
 }
 
 function statusFiles(root) {
-  const result = git(root, ["status", "--porcelain=v1", "--untracked-files=all"])
+  const result = git(root, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--",
+    ...sourceGitPathspecs(),
+  ])
   if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git status failed").trim())
-  return result.stdout
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => line.slice(3).trim())
-    .map((value) => value.includes(" -> ") ? value.split(" -> ").at(-1) : value)
-    .map((value) => value.replaceAll("\\", "/"))
-    .filter((value) => !isUesRuntimeArtifactPath(value))
+  return sourceFacingPaths(
+    workspaceStatusEntries(result.stdout)
+      .filter((entry) => entry.renameSource !== true)
+      .map((entry) => entry.file),
+  )
 }
 
 function sourceIntentBatches(values, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-agent-skill",
-  "version": "15.1.1",
+  "version": "15.1.2",
   "description": "Pi-native UES coding-agent runtime with adaptive stability, Turbo Fast Path, durable verification, managed services, and weak-model orchestration",
   "type": "module",
   "bin": {

package/pi/extensions/ues-child-runtime.ts

@@ -450,9 +450,45 @@ export default function (pi: ExtensionAPI) {
           throw new Error("unsupported ues_code action");
         }
         const encoded = JSON.stringify(result, null, 2);
+        const bounded = encoded.length > 32000;
+        let contextRef: string | null = null;
+        let visible = encoded;
+        if (bounded) {
+          const preserved = await compactContext(ctx.cwd, encoded, {
+            kind: "ues-code-result",
+            source: `ues_code:${params.action}`,
+            summary: `Full child code-intelligence result for ${params.action}; preserve exact JSON before model-visible bounding`,
+          }).catch(() => null);
+          contextRef = preserved?.ref || null;
+          const metadataFirst = {
+            schemaVersion: result?.schemaVersion || 1,
+            action: params.action,
+            file: result?.file || null,
+            available: result?.available ?? null,
+            provider: result?.provider || null,
+            operation: result?.operation || null,
+            reason: result?.reason || null,
+            persistent: result?.persistent ?? null,
+            pool: result?.pool || result?.lsp?.persistentPool || null,
+            bounded: true,
+            originalChars: encoded.length,
+            contextRef,
+            preview: encoded.slice(0, 22000),
+          };
+          visible = JSON.stringify(metadataFirst, null, 2) +
+            "\n...[full result preserved; use ues_code context-expand with contextRef when more evidence is needed]";
+        }
         return {
-          content: [{ type: "text", text: encoded.length <= 32000 ? encoded : encoded.slice(0, 32000) + "\n...[bounded by ues_code]" }],
-          details: { action: params.action, bounded: encoded.length > 32000 },
+          content: [{ type: "text", text: visible }],
+          details: {
+            action: params.action,
+            bounded,
+            originalChars: encoded.length,
+            contextRef,
+            provider: result?.provider || null,
+            persistent: result?.persistent ?? null,
+            pool: result?.pool || result?.lsp?.persistentPool || null,
+          },
         };
       } catch (error) {
         return {