opencode-agent-skill 15.1.0 → 15.1.2

package/lib/code-intelligence/lsp-provider.mjs

@@ -1,8 +1,15 @@
-import { spawn, spawnSync } from "node:child_process"
+import { spawn } from "node:child_process"
+import { existsSync } from "node:fs"
 import { lstat, readFile, realpath } from "node:fs/promises"
 import path from "node:path"
+import { commandExists } from "../executable-probe.mjs"
+import { resolveWindowsCommand } from "../windows-shim.mjs"
+import { lspPoolStatus as managedLspPoolStatus, shutdownLspPool as shutdownManagedLspPool, withManagedLspSession } from "./lsp-pool.mjs"
 import { fileURLToPath, pathToFileURL } from "node:url"
 
+const TYPESCRIPT_FALLBACK_CACHE_TTL_MS = 60_000
+let typescriptFallbackCache = null
+
 const PROVIDERS = [
   { id: "typescript-language-server", extensions: new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]), commands: [["typescript-language-server", ["--stdio"]]], languageId: (ext) => [".ts", ".tsx"].includes(ext) ? "typescript" : "javascript" },
   { id: "pyright-langserver", extensions: new Set([".py"]), commands: [["pyright-langserver", ["--stdio"]], ["pylsp", []]], languageId: () => "python" },
@@ -22,19 +29,6 @@ export const LSP_OPERATIONS = Object.freeze([
   "outgoing-calls",
 ])
 
-const commandCache = new Map()
-const COMMAND_TTL_MS = 60_000
-
-function commandExists(command) {
-  const now = Date.now()
-  const cached = commandCache.get(command)
-  if (cached && now - cached.at < COMMAND_TTL_MS) return cached.available
-  const finder = process.platform === "win32" ? "where" : "which"
-  const available = spawnSync(finder, [command], { stdio: "ignore", windowsHide: true }).status === 0
-  commandCache.set(command, { available, at: now })
-  return available
-}
-
 function inside(root, target) {
   return target === root || target.startsWith(root + path.sep)
 }
@@ -50,18 +44,107 @@ async function safeFile(root, relative) {
   return { base, file: actual, info }
 }
 
+export function clearTypeScriptTsserverFallbackCache() {
+  typescriptFallbackCache = null
+}
+
+function deriveTypeScriptTsserverFallback(execution) {
+  const candidates = [
+    execution?.entry,
+    ...(Array.isArray(execution?.argsPrefix) ? execution.argsPrefix : []),
+  ].filter(Boolean)
+
+  for (const value of candidates) {
+    const entry = path.resolve(String(value))
+    const binDir = path.dirname(entry)
+    const packageRoot = path.basename(binDir).toLowerCase() === "bin"
+      ? path.dirname(binDir)
+      : null
+    const preferred = packageRoot ? path.join(packageRoot, "lib", "tsserver.js") : null
+    if (preferred && existsSync(preferred)) return preferred
+    if (existsSync(entry)) return entry
+  }
+  return null
+}
+
+export function resolveTypeScriptTsserverFallback(options = {}) {
+  const explicit = String(options.explicitPath ?? process.env.UES_TYPESCRIPT_TSSERVER_PATH ?? "").trim()
+  if (explicit && existsSync(path.resolve(explicit))) return path.resolve(explicit)
+
+  const platform = String(options.platform || process.platform)
+  if (platform !== "win32") return null
+
+  // Explicit injected executions are deterministic probes used by tests/callers;
+  // do not mix them into the host PATH cache.
+  if (options.execution) return deriveTypeScriptTsserverFallback(options.execution)
+
+  const cacheKey = [
+    explicit,
+    String(process.env.PATH || ""),
+    String(process.env.PATHEXT || ""),
+  ].join("\u0000")
+  const ttlMs = Math.max(0, Math.min(
+    5 * 60_000,
+    Number(options.cacheTtlMs ?? process.env.UES_LSP_PROVIDER_PROBE_TTL_MS ?? TYPESCRIPT_FALLBACK_CACHE_TTL_MS),
+  ))
+  const now = Date.now()
+  if (
+    typescriptFallbackCache &&
+    typescriptFallbackCache.key === cacheKey &&
+    now - typescriptFallbackCache.checkedAt < ttlMs
+  ) {
+    return typescriptFallbackCache.value
+  }
+
+  const resolver = typeof options.resolveCommand === "function"
+    ? options.resolveCommand
+    : resolveWindowsCommand
+  const value = deriveTypeScriptTsserverFallback(resolver("tsserver"))
+  typescriptFallbackCache = { key: cacheKey, checkedAt: now, value }
+  return value
+}
+
+function providerRuntimeOptions(provider) {
+  if (provider?.id !== "typescript-language-server") return {}
+  const fallbackPath = resolveTypeScriptTsserverFallback()
+  return fallbackPath
+    ? { initializationOptions: { tsserver: { fallbackPath } } }
+    : {}
+}
+
 function providerFor(file) {
   const ext = path.extname(file).toLowerCase()
   for (const provider of PROVIDERS) {
     if (!provider.extensions.has(ext)) continue
     for (const [command, args] of provider.commands) {
-      if (commandExists(command)) return { ...provider, command, args, languageId: provider.languageId(ext) }
+      if (commandExists(command)) {
+        return {
+          ...provider,
+          ...providerRuntimeOptions(provider),
+          command,
+          args,
+          languageId: provider.languageId(ext),
+        }
+      }
     }
     return { ...provider, command: null, args: [], languageId: provider.languageId(ext) }
   }
   return null
 }
 
+export function lspPersistencePolicy(options = {}) {
+  if (typeof options.persistent === "boolean") {
+    return { enabled: options.persistent, source: "explicit-option" }
+  }
+  const env = String(process.env.UES_LSP_PERSISTENT || "").trim()
+  if (env === "0") return { enabled: false, source: "env-disabled" }
+  if (env === "1") return { enabled: true, source: "env-enabled" }
+  if (process.env.UES_CHILD_PROCESS === "1") {
+    return { enabled: true, source: "pi-child-runtime" }
+  }
+  return { enabled: false, source: "short-lived-default" }
+}
+
 export function lspProviderStatus(file = "") {
   const ext = path.extname(String(file || "")).toLowerCase()
   const providers = PROVIDERS
@@ -75,6 +158,13 @@ export function lspProviderStatus(file = "") {
     extension: ext,
     available: providers.some((row) => row.available),
     operations: [...LSP_OPERATIONS],
+    persistentPool: {
+      ...managedLspPoolStatus({
+        includeSessions: false,
+        persistent: lspPersistencePolicy().enabled,
+      }),
+      policy: lspPersistencePolicy(),
+    },
     providers,
   }
 }
@@ -199,7 +289,7 @@ function sanitizeHierarchyCalls(base, values, direction, limit = 120) {
   })
 }
 
-async function withLspSession(root, relative, options, operation) {
+async function withEphemeralLspSession(root, relative, options, operation) {
   const target = await safeFile(root, relative)
   const provider = providerFor(target.file)
   const relativeFile = path.relative(target.base, target.file).replaceAll("\\", "/")
@@ -222,8 +312,26 @@ async function withLspSession(root, relative, options, operation) {
   const rootUri = pathToFileURL(target.base + path.sep).href
   const timeoutMs = Math.max(500, Math.min(15_000, Number(options.timeoutMs || 5000)))
 
+  const execution = process.platform === "win32"
+    ? resolveWindowsCommand(provider.command)
+    : { executable: provider.command, argsPrefix: [] }
+  if (!execution?.executable) {
+    return {
+      schemaVersion: 2,
+      file: relativeFile,
+      available: true,
+      provider: provider.id,
+      command: provider.command,
+      operation: options.operation || null,
+      reason: "spawn-error",
+      result: null,
+      stderr: null,
+      error: "unable to resolve LSP executable: " + provider.command,
+    }
+  }
+
   return await new Promise((resolve) => {
-    const child = spawn(provider.command, provider.args, {
+    const child = spawn(execution.executable, [...(execution.argsPrefix || []), ...provider.args], {
       cwd: target.base,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
@@ -364,6 +472,7 @@ async function withLspSession(root, relative, options, operation) {
             workspace: { workspaceFolders: true, applyEdit: false },
           },
           workspaceFolders: [{ uri: rootUri, name: path.basename(target.base) || "workspace" }],
+          initializationOptions: provider.initializationOptions || undefined,
         })
         notify("initialized", {})
         notify("textDocument/didOpen", {
@@ -388,13 +497,35 @@ async function withLspSession(root, relative, options, operation) {
 export async function lspOperation(root, relative, operation, options = {}) {
   const op = String(operation || "")
   if (!LSP_OPERATIONS.includes(op)) throw new Error("unsupported LSP operation: " + op)
+
+  const target = await safeFile(root, relative)
+  const provider = providerFor(target.file)
+  const relativeFile = path.relative(target.base, target.file).replaceAll("\\", "/")
+  if (!provider?.command) {
+    return {
+      schemaVersion: 2,
+      file: relativeFile,
+      available: false,
+      provider: provider?.id || null,
+      operation: op,
+      reason: provider ? "lsp-command-unavailable" : "unsupported-extension",
+      result: null,
+      persistent: false,
+    }
+  }
+
   const maxResults = Math.max(1, Math.min(500, Number(options.maxResults || 120)))
-  return withLspSession(root, relative, { ...options, operation: op }, async (session) => {
+  const execute = async (session) => {
     const pos = position(options)
     const textDocument = { uri: session.uri }
 
     if (op === "diagnostics") {
-      const params = await session.waitForNotification("textDocument/publishDiagnostics")
+      const params = await session.waitForNotification("textDocument/publishDiagnostics", {
+        predicate: (value) =>
+          (!value?.uri || value.uri === session.uri) &&
+          (value?.version == null || Number(value.version) >= Number(session.documentSync?.version || 0)),
+        afterAt: session.documentSync?.changed ? session.documentSync.syncedAt : 0,
+      })
       const values = Array.isArray(params?.diagnostics) ? params.diagnostics : []
       return { diagnostics: values.slice(0, maxResults).map(sanitizeDiagnostic) }
     }
@@ -450,7 +581,53 @@ export async function lspOperation(root, relative, operation, options = {}) {
       }
     }
     return null
-  })
+  }
+
+  const persistence = lspPersistencePolicy(options)
+  const managed = await withManagedLspSession(
+    target,
+    provider,
+    { ...options, persistent: persistence.enabled, operation: op },
+    execute,
+  ).catch((error) => ({
+    ok: false,
+    reason: "managed-lsp-exception",
+    error: String(error instanceof Error ? error.message : error).slice(0, 1200),
+  }))
+
+  if (managed?.ok) {
+    return {
+      schemaVersion: 2,
+      file: relativeFile,
+      available: true,
+      provider: provider.id,
+      command: provider.command,
+      operation: op,
+      reason: "ok",
+      result: managed.result,
+      stderr: managed.stderr || null,
+      error: null,
+      persistent: true,
+      pool: { ...managed.meta, policy: persistence },
+    }
+  }
+
+  const fallback = await withEphemeralLspSession(root, relative, { ...options, operation: op }, execute)
+  return {
+    ...fallback,
+    persistent: false,
+    fallbackFrom: managed?.reason || "managed-lsp-unavailable",
+    managedError: managed?.error || null,
+    persistencePolicy: persistence,
+  }
+}
+
+export function lspPoolStatus(options = {}) {
+  return managedLspPoolStatus(options)
+}
+
+export async function shutdownLspPool(root = null) {
+  return shutdownManagedLspPool(root)
 }
 
 export async function diagnoseCode(root, relative, options = {}) {

package/lib/compaction-resume-guard.mjs

@@ -153,6 +153,72 @@ function stateSummary(state) {
   }
 }
 
+function buildInstructionEpoch(state, tasks, receipts, gateReceipts) {
+  const rows = Array.isArray(tasks) ? tasks : []
+  const passedTaskReceipts = new Set(
+    (Array.isArray(receipts) ? receipts : [])
+      .filter((item) => item?.passed === true && item?.task)
+      .map((item) => String(item.task)),
+  )
+  const completedTaskIds = rows.filter((row) => row.status === "completed").map((row) => row.id)
+  const activeTaskIds = rows.filter((row) => row.status === "running").map((row) => row.id)
+  const failedTaskIds = rows.filter((row) => row.status === "failed").map((row) => row.id)
+  const pendingTaskIds = rows
+    .filter((row) => !["completed", "failed"].includes(String(row.status || "").toLowerCase()))
+    .map((row) => row.id)
+  const tasksWithoutPassingReceipt = completedTaskIds.filter((id) => !passedTaskReceipts.has(String(id)))
+  const decisions = (Array.isArray(state?.decisions) ? state.decisions : [])
+    .slice(-8)
+    .map((item) => ({
+      at: item?.at || null,
+      text: item?.text ? String(item.text).slice(0, 600) : null,
+      source: item?.source || null,
+      risk: item?.policy?.risk || null,
+      autoResolvable: item?.policy?.autoResolvable === true,
+      confidence: Number.isFinite(Number(item?.policy?.decision?.confidence))
+        ? Number(item.policy.decision.confidence)
+        : null,
+    }))
+
+  const body = {
+    schemaVersion: 1,
+    source: "durable-state-fold",
+    objective: state?.goal ? String(state.goal).slice(0, 1200) : null,
+    status: state?.status || null,
+    planHash: state?.planHash || null,
+    planApproved: state?.planApproved === true,
+    activeTaskIds,
+    pendingTaskIds,
+    completedTaskIds,
+    failedTaskIds,
+    blockers: (Array.isArray(state?.blockers) ? state.blockers : []).slice(-12).map((item) => String(item).slice(0, 500)),
+    recentDecisions: decisions,
+    checkpoint: state?.checkpoint ? {
+      id: state.checkpoint.id || null,
+      currentTaskId: state.checkpoint.currentTaskId || null,
+      runId: state.checkpoint.runId || null,
+      workspaceFingerprint: state.checkpoint.workspaceFingerprint || null,
+      nextAction: state.checkpoint.nextAction || null,
+    } : null,
+    nextAction: state?.nextAction || null,
+    verification: {
+      tasksWithoutPassingReceipt,
+      passingReceiptIds: (Array.isArray(receipts) ? receipts : [])
+        .filter((item) => item?.passed === true && item?.id)
+        .slice(-20)
+        .map((item) => item.id),
+      passingGateReceiptIds: (Array.isArray(gateReceipts) ? gateReceipts : [])
+        .filter((item) => String(item?.verdict || "").toUpperCase() === "PASS" && item?.id)
+        .slice(-12)
+        .map((item) => item.id),
+    },
+  }
+  return {
+    ...body,
+    epochHash: digest(JSON.stringify(body)),
+  }
+}
+
 export async function checkpointDurableWorkBeforeCompaction(root, options = {}) {
   const reason = String(options.reason || "unknown")
   const rows = await activeWorkspaces(root, options.maxWorkspaces || MAX_WORKSPACES)
@@ -197,6 +263,10 @@ export async function buildCompactionResumeGuard(root, options = {}) {
         ? path.relative(root, path.join(row.dir, "phases", "MANIFEST.json")).replaceAll("\\", "/")
         : null,
     }
+    const tasks = taskRows(plan, row.state)
+    const receipts = receiptRows(evidence)
+    const gateReceipts = gateRows(evidence)
+    const instructionEpoch = buildInstructionEpoch(row.state, tasks, receipts, gateReceipts)
     workspaces.push({
       slug: row.slug,
       sources,
@@ -208,9 +278,10 @@ export async function buildCompactionResumeGuard(root, options = {}) {
         phaseManifest: manifest ? digest(JSON.stringify(manifest)) : null,
       },
       state: stateSummary(row.state),
-      tasks: taskRows(plan, row.state),
-      receipts: receiptRows(evidence),
-      gateReceipts: gateRows(evidence),
+      instructionEpoch,
+      tasks,
+      receipts,
+      gateReceipts,
       executionContract: contract ? {
         schemaVersion: contract.schemaVersion || null,
         taskHash: contract.taskHash || null,
@@ -243,7 +314,8 @@ export function renderCompactionResumeGuard(packet, options = {}) {
     "## UES Durable Compaction Resume Guard",
     "Authoritative durable state was rebuilt from filesystem artifacts after Pi compaction.",
     "The model-generated compaction summary is advisory only for durable execution state.",
-    "If the summary conflicts with STATE.json, PLAN.json, EXECUTION_CONTRACT.json, phase artifacts, or evidence receipts below, the deterministic artifacts win.",
+    "If the summary conflicts with STATE.json, PLAN.json, EXECUTION_CONTRACT.json, phase artifacts, instructionEpoch, or evidence receipts below, the deterministic artifacts win.",
+    "Treat instructionEpoch as the compact deterministic control-plane fold: objective, active work, blockers, decisions, receipt gaps and next action.",
     "Do not mark a task/phase complete unless the rebuilt state and fresh receipts support it.",
     "Follow checkpoint.nextAction/state.nextAction and re-read the referenced artifact when more detail is required.",
     "",

package/lib/completion-auditor.mjs

@@ -42,6 +42,17 @@ function receiptPassed(row = {}) {
   return Boolean(receipt?.passed === true && Number(receipt?.exitCode) === 0)
 }
 
+function claimEvidenceStatus(value) {
+  const lines = text(value).split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  const counts = { verified: 0, inferred: 0, unknown: 0 }
+  for (const line of lines) {
+    if (/^(?:[-*]\s*)?VERIFIED\s*:/i.test(line)) counts.verified += 1
+    else if (/^(?:[-*]\s*)?INFERRED\s*:/i.test(line)) counts.inferred += 1
+    else if (/^(?:[-*]\s*)?UNKNOWN\s*:/i.test(line)) counts.unknown += 1
+  }
+  return counts
+}
+
 export function auditCompletion(input = {}) {
   const failures = []
   const warnings = []
@@ -67,6 +78,14 @@ export function auditCompletion(input = {}) {
   }
   if (Object.hasOwn(sections, "checks-not-run") && !benignEmptySection(sections["checks-not-run"])) warnings.push("verification-reports-checks-not-run")
 
+  const claimStatus = claimEvidenceStatus(sections["acceptance-criteria-proven"])
+  const claimStatusCount = claimStatus.verified + claimStatus.inferred + claimStatus.unknown
+  if (input.requireClaimEvidenceStatus === true && claimStatusCount === 0) {
+    failures.push("acceptance-criteria-evidence-status-missing")
+  }
+  if (claimStatus.inferred > 0) failures.push("acceptance-criteria-inferred-not-proven")
+  if (claimStatus.unknown > 0) failures.push("acceptance-criteria-unknown-not-proven")
+
   const snapshot = input.workspaceSnapshot || null
   if (snapshot) {
     if (snapshot.cacheable === true && !text(snapshot.fingerprint)) failures.push("workspace-fingerprint-missing")
@@ -95,6 +114,7 @@ export function auditCompletion(input = {}) {
       visual: requireVisual ? passRun(visual) : null,
       reportSections: Object.keys(sections).sort(),
       passingReceiptCount: passingReceipts.length,
+      claimEvidenceStatus: claimStatus,
       workspaceFingerprint: snapshot?.fingerprint || null,
       changedFiles: Array.isArray(snapshot?.changedFiles) ? snapshot.changedFiles.slice(0, 200) : [],
     },

package/lib/context-manifest.mjs

@@ -7,6 +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, workspaceStatusEntries } from "./workspace-fingerprint.mjs"
+import { sourceFacingPaths, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const ROOT_INSTRUCTIONS = [
   "AGENTS.md",
@@ -28,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)
@@ -148,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) {
@@ -249,9 +263,20 @@ export async function buildContextManifest(root, task, options = {}) {
   const evidenceBudget = options.evidenceBudget || null
   const declared = taskFiles(task)
   const terms = taskTerms(task)
+  let workspaceSnapshot = null
+  const suppliedFingerprint = String(options.workspaceFingerprint || "").trim()
+  if (!Array.isArray(options.changedFiles) || !suppliedFingerprint) {
+    try {
+      workspaceSnapshot = runtimeWorkspaceSnapshot(root, { workspaceState: options.workspaceState })
+    } catch {}
+  }
+  const reusableWorkspaceFingerprint = suppliedFingerprint ||
+    (workspaceSnapshot?.cacheable ? String(workspaceSnapshot.fingerprint || "") : "")
   const changed = Array.isArray(options.changedFiles)
     ? options.changedFiles.map((file) => String(file || "").replaceAll("\\", "/")).filter(Boolean)
-    : gitChangedFiles(root)
+    : Array.isArray(workspaceSnapshot?.changedFiles)
+      ? workspaceSnapshot.changedFiles
+      : gitChangedFiles(root)
   const strategy = String(options.strategy || "semantic+graph+git")
   const queryText = [
     task?.title,
@@ -260,25 +285,51 @@ 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: options.workspaceFingerprint,
-  }).catch(() => null)
+    workspaceFingerprint: reusableWorkspaceFingerprint,
+  }).catch((error) => {
+    contextDiagnostics.push(boundedFailure("semantic-snapshot", error, "performance"))
+    return null
+  })
 
-  const hierarchy = await queryContextHierarchy(root, queryText, {
-    declaredFiles: declared,
-    maxScopes: options.hierarchyMaxScopes ?? 6,
-    maxFiles: options.semanticMaxFiles ?? 6000,
-    builtIndex: semanticSnapshot || undefined,
-  }).catch(() => null)
+  const useGraph = strategy.includes("graph")
+  const [hierarchy, semantic, graph, instructions] = await Promise.all([
+    queryContextHierarchy(root, queryText, {
+      declaredFiles: declared,
+      maxScopes: options.hierarchyMaxScopes ?? 6,
+      maxFiles: options.semanticMaxFiles ?? 6000,
+      builtIndex: semanticSnapshot || undefined,
+    }).catch((error) => {
+      contextDiagnostics.push(boundedFailure("hierarchy", error))
+      return null
+    }),
+    querySemanticIndex(root, queryText, {
+      limit: 32,
+      maxFiles: options.semanticMaxFiles ?? 6000,
+      builtIndex: semanticSnapshot || undefined,
+    }).catch((error) => {
+      contextDiagnostics.push(boundedFailure("semantic-query", error))
+      return null
+    }),
+    useGraph
+      ? buildRepoGraphCached(root, {
+          maxFiles: options.maxFiles ?? 2500,
+          workspaceFingerprint: reusableWorkspaceFingerprint,
+        }).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((error) => {
+      contextDiagnostics.push(boundedFailure("instructions", error))
+      return []
+    }),
+  ])
   const hierarchyScopes = hierarchy?.scopes?.map((item) => item.path) || []
 
-  const semantic = await querySemanticIndex(root, queryText, {
-    limit: 32,
-    maxFiles: options.semanticMaxFiles ?? 6000,
-    builtIndex: semanticSnapshot || undefined,
-  }).catch(() => null)
   const scopedSemanticResults = (semantic?.results || []).map((item) => {
     const scopeRank = hierarchyScopes.findIndex((scope) =>
       scope === "." || item.path === scope || item.path.startsWith(scope + "/"),
@@ -293,13 +344,6 @@ export async function buildContextManifest(root, task, options = {}) {
   }).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
   const semanticPaths = scopedSemanticResults.map((item) => item.path)
 
-  const useGraph = strategy.includes("graph")
-  const graph = useGraph
-    ? await buildRepoGraphCached(root, {
-        maxFiles: options.maxFiles ?? 2500,
-        workspaceFingerprint: options.workspaceFingerprint,
-      })
-    : { nodes: [], edges: [], hotspots: [], scannedFiles: 0, truncated: false }
   const nodeMap = new Map(graph.nodes.map((node) => [node.path, node]))
   const incoming = new Map()
 
@@ -330,7 +374,6 @@ export async function buildContextManifest(root, task, options = {}) {
     .slice(0, 24)
     .map((item) => item.file)
 
-  const instructions = await nearbyInstructions(root, declared)
   const graphRanked = useGraph
     ? rankContextGraph(graph, {
         semanticResults: scopedSemanticResults,
@@ -388,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 = {
@@ -422,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,
@@ -437,6 +486,7 @@ export async function buildContextManifest(root, task, options = {}) {
     excerpts,
     hierarchy: hierarchy ? {
       schemaVersion: hierarchy.schemaVersion,
+      runtimeCacheHit: hierarchy.runtimeCacheHit === true,
       levels: hierarchy.levels,
       scopes: hierarchy.scopes.slice(0, 6).map((item) => ({
         path: item.path,
@@ -450,6 +500,8 @@ export async function buildContextManifest(root, task, options = {}) {
     semantic: semantic ? {
       evidenceLevel: semantic.evidenceLevel,
       resultCount: semantic.results.length,
+      runtimeCacheHit: semanticSnapshot?.runtimeCacheHit === true,
+      runtimeCacheCoalesced: semanticSnapshot?.runtimeCacheCoalesced === true,
       stats: semantic.stats,
     } : null,
     graph: {