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

package/lib/benchmark-confidence.mjs

@@ -125,8 +125,36 @@ export function pairedBenchmarkConfidence(results, options = {}) {
     initialInputAcceptable,
     tokensAcceptable,
   }
+
+  const baselineContaminated = pairs.filter((pair) => pair.baseline?.baselineIsolated === false).length
+  const baselineIsolationUnknown = pairs.filter((pair) => pair.baseline?.baselineIsolated !== true).length - baselineContaminated
+  const uesControllerUnproven = pairs.filter((pair) => pair.ues?.telemetry?.controllerUsed !== true).length
+  const uesFalsePasses = pairs.filter((pair) =>
+    pair.ues?.telemetry?.controllerPass === true &&
+    Number(pair.ues?.graderExit) !== 0
+  ).length
+  const qualityRegressionTolerance = Math.max(0, Number(options.qualityRegressionTolerance || 0))
+  const qualityNonRegression = delta >= -qualityRegressionTolerance
+  const efficiencySignals = [
+    durationRatio == null ? null : durationRatio < 1,
+    initialInputRatio == null ? null : initialInputRatio < 1,
+    tokenRatio == null ? null : tokenRatio < 1,
+  ].filter((value) => value !== null)
+  const efficiencyImproved = efficiencySignals.some(Boolean)
+  const turboChecks = {
+    pairedCoverage: total >= minPairs,
+    baselineIsolated: baselineContaminated === 0 && baselineIsolationUnknown === 0,
+    uesControllerUsed: uesControllerUnproven === 0,
+    qualityNonRegression,
+    noSuiteRegression,
+    noControllerFalsePass: uesFalsePasses === 0,
+    speedAcceptable,
+    initialInputAcceptable,
+    tokensAcceptable,
+    efficiencyImproved,
+  }
   return {
-    schemaVersion: 2,
+    schemaVersion: 3,
     kind: "ues-paired-benchmark-confidence",
     pairs: total,
     bothPass,
@@ -169,5 +197,16 @@ export function pairedBenchmarkConfidence(results, options = {}) {
     suites,
     checks,
     promotionEligible: Object.values(checks).every(Boolean),
+    turbo: {
+      policy: "quality-non-regression-with-efficiency-gain",
+      qualityRegressionTolerance,
+      baselineContaminated,
+      baselineIsolationUnknown,
+      uesControllerUnproven,
+      uesFalsePasses,
+      efficiencyImproved,
+      checks: turboChecks,
+      promotionEligible: Object.values(turboChecks).every(Boolean),
+    },
   }
-}
+}

package/lib/browser-mcp-routing.mjs

@@ -0,0 +1,166 @@
+import { inferTaskCapabilities } from "./capability-registry.mjs"
+
+const BROWSER_ROLES = new Set([
+  "executor",
+  "debugger",
+  "verifier",
+  "integration-verifier",
+  "visual-verifier",
+])
+
+const VISUAL_SIGNAL =
+  /(visual fidelity|visual regression|screenshot|figma|pixel|layout|responsive|viewport|accessibility snapshot|giao diện|\bui\b|\bcss\b|styling|kiểm tra hiển thị)/i
+
+const PROVIDER_SIGNAL =
+  /(playwright|browser automation|browser mcp|chromium|webkit|firefox)/i
+
+const BROWSER_TOOL_NAME =
+  /(^|[_:.])(browser|playwright)([_:.]|$)|^browser_|^playwright_|mcp.*(?:browser|playwright)/i
+
+const ACTION_PRIORITY = [
+  ["snapshot", 18],
+  ["screenshot", 17],
+  ["console", 16],
+  ["network", 15],
+  ["navigate", 14],
+  ["viewport", 13],
+  ["click", 12],
+  ["fill", 11],
+  ["type", 10],
+  ["select", 9],
+  ["press", 8],
+  ["wait", 7],
+  ["hover", 6],
+  ["locator", 5],
+  ["evaluate", 4],
+  ["close", 1],
+]
+
+const BLOCKED_BUILTINS = new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "bash",
+  "powershell",
+  "edit",
+  "write",
+  "ues_cli",
+  "ues_execute",
+  "ues_dispatch",
+])
+
+function textForTool(tool = {}) {
+  return [
+    tool.name,
+    tool.label,
+    tool.description,
+  ].filter(Boolean).join(" ")
+}
+
+function normalizeExplicitNames(values = []) {
+  if (typeof values === "string") values = values.split(",")
+  return [...new Set(
+    (Array.isArray(values) ? values : [])
+      .map((value) => String(value || "").trim())
+      .filter(Boolean),
+  )]
+}
+
+export function visualEvidenceNeeded(text = "") {
+  const value = String(text || "")
+  const capabilities = inferTaskCapabilities(value, { coding: true })
+  return capabilities.required.vision === true || VISUAL_SIGNAL.test(value)
+}
+
+export function browserEvidenceNeeded(text = "", role = "") {
+  const normalizedRole = String(role || "").replace(/^ues-/, "")
+  if (!BROWSER_ROLES.has(normalizedRole)) return false
+  if (normalizedRole === "visual-verifier") return true
+
+  const capabilities = inferTaskCapabilities(String(text || ""), { coding: true })
+  return (
+    capabilities.required.browser === true ||
+    capabilities.required.vision === true ||
+    VISUAL_SIGNAL.test(String(text || ""))
+  )
+}
+
+export function selectBrowserMcpToolNames(tools = [], options = {}) {
+  const limit = Math.max(1, Math.min(Number(options.limit || 14), 32))
+  const explicit = normalizeExplicitNames(options.explicitNames)
+  const rows = []
+  const available = new Map()
+
+  for (const raw of Array.isArray(tools) ? tools : []) {
+    const name = String(raw?.name || "").trim()
+    if (!name || BLOCKED_BUILTINS.has(name) || name.startsWith("ues_")) continue
+    available.set(name, raw)
+
+    const descriptor = textForTool(raw)
+    const providerHit = PROVIDER_SIGNAL.test(descriptor)
+    const nameHit = BROWSER_TOOL_NAME.test(name)
+    if (!providerHit && !nameHit) continue
+
+    let score = providerHit ? 100 : 70
+    if (/playwright/i.test(descriptor)) score += 30
+    if (/^browser_|(?:^|[_:.])browser[_:.]/i.test(name)) score += 20
+    for (const [signal, weight] of ACTION_PRIORITY) {
+      if (name.toLowerCase().includes(signal)) {
+        score += weight
+        break
+      }
+    }
+    rows.push({ name, score })
+  }
+
+  const selected = []
+  for (const name of explicit) {
+    if (available.has(name) && !selected.includes(name)) selected.push(name)
+  }
+
+  for (const row of rows.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))) {
+    if (selected.length >= limit) break
+    if (!selected.includes(row.name)) selected.push(row.name)
+  }
+
+  return selected.slice(0, limit)
+}
+
+export function selectBrowserToolsForTask(names = [], text = "", role = "") {
+  const value = String(text || "").toLowerCase()
+  const normalizedRole = String(role || "").replace(/^ues-/, "")
+  const visual = visualEvidenceNeeded(text) || normalizedRole === "visual-verifier"
+  const interactive = /(click|fill|type|select|press|submit|login|checkout|flow|interaction|form|navigate|đăng nhập|nhấn|điền|chọn)/i.test(value)
+  const diagnostics = /(console|network|request|response|error|failed|api|socket|log)/i.test(value)
+
+  const keep = []
+  const addIf = (name, predicate) => {
+    const lower = name.toLowerCase()
+    if (predicate(lower) && !keep.includes(name)) keep.push(name)
+  }
+
+  for (const name of names) {
+    addIf(name, (lower) => /snapshot|accessibility|navigate|close/.test(lower))
+  }
+  if (visual) {
+    for (const name of names) addIf(name, (lower) => /screenshot|viewport|snapshot|accessibility/.test(lower))
+  }
+  if (interactive) {
+    for (const name of names) addIf(name, (lower) => /click|fill|type|select|press|wait|hover|locator|navigate/.test(lower))
+  }
+  if (diagnostics || normalizedRole === "verifier" || normalizedRole === "integration-verifier") {
+    for (const name of names) addIf(name, (lower) => /console|network|request|response/.test(lower))
+  }
+
+  // Keep a small escape hatch for providers whose naming does not expose action semantics.
+  if (keep.length < 3) {
+    for (const name of names) {
+      if (!keep.includes(name)) keep.push(name)
+      if (keep.length >= Math.min(6, names.length)) break
+    }
+  }
+
+  const limit = visual || interactive ? 10 : 6
+  return keep.slice(0, limit)
+}

package/lib/capability-fabric.mjs

@@ -0,0 +1,336 @@
+import { existsSync } from "node:fs"
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
+import { spawnSync } from "node:child_process"
+import path from "node:path"
+
+const HEALTH_WEIGHT = { healthy: 40, degraded: 15, unknown: 0, unavailable: -1000 }
+const COST_PENALTY = { low: 0, medium: 5, high: 12 }
+const LATENCY_PENALTY = { fast: 0, medium: 3, slow: 8 }
+const OBSERVATION_FILE = "CAPABILITY-OBSERVATIONS.json"
+
+function observationPath(root) {
+  return path.join(path.resolve(root), ".ues-learning", OBSERVATION_FILE)
+}
+async function atomicJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true })
+  const temp = file + "." + process.pid + "." + Date.now() + ".tmp"
+  await writeFile(temp, JSON.stringify(value, null, 2) + "\n", "utf8")
+  try { await rename(temp, file) } catch (error) { await rm(temp, { force: true }).catch(() => {}); throw error }
+}
+export async function readCapabilityObservations(root = process.cwd()) {
+  try {
+    const parsed = JSON.parse(await readFile(observationPath(root), "utf8"))
+    return { schemaVersion: 1, updatedAt: parsed.updatedAt || null, capabilities: parsed.capabilities && typeof parsed.capabilities === "object" ? parsed.capabilities : {} }
+  } catch { return { schemaVersion: 1, updatedAt: null, capabilities: {} } }
+}
+export async function recordCapabilityObservation(root, capability, providerId, input = {}) {
+  if (!capability || !providerId) throw new Error("capability observation requires capability and provider id")
+  const state = await readCapabilityObservations(root)
+  const previous = state.capabilities?.[capability]?.[providerId] || {}
+  const success = input.success === true, failure = input.success === false
+  const samples = Number(previous.samples || 0) + (success || failure ? 1 : 0)
+  const successes = Number(previous.successes || 0) + (success ? 1 : 0)
+  const failures = Number(previous.failures || 0) + (failure ? 1 : 0)
+  const latencyMs = Number.isFinite(Number(input.latencyMs)) ? Math.max(0, Number(input.latencyMs)) : null
+  const previousLatencySamples = Number(previous.latencySamples || 0)
+  const latencySamples = previousLatencySamples + (latencyMs == null ? 0 : 1)
+  const avgLatencyMs = latencyMs == null ? (previous.avgLatencyMs ?? null) : ((Number(previous.avgLatencyMs || 0) * previousLatencySamples) + latencyMs) / Math.max(1, latencySamples)
+  const next = {
+    samples, successes, failures,
+    successRate: samples ? successes / samples : 0,
+    failureRate: samples ? failures / samples : 0,
+    latencySamples, avgLatencyMs: avgLatencyMs == null ? null : Number(avgLatencyMs.toFixed(2)),
+    lastLatencyMs: latencyMs, lastObservedAt: new Date().toISOString(),
+    lastError: input.error ? String(input.error).slice(0, 500) : null,
+  }
+  const capabilities = { ...state.capabilities, [capability]: { ...(state.capabilities?.[capability] || {}), [providerId]: next } }
+  await atomicJson(observationPath(root), { schemaVersion: 1, updatedAt: next.lastObservedAt, capabilities })
+  return next
+}
+
+function clamp(value, min = 0, max = 1, fallback = 0) {
+  const number = Number(value)
+  return Number.isFinite(number) ? Math.max(min, Math.min(max, number)) : fallback
+}
+
+const COMMAND_PROBE_TTL_MS = 60_000
+const commandProbeCache = new Map()
+
+function commandExists(command) {
+  if (!command) return false
+  const now = Date.now()
+  const cached = commandProbeCache.get(command)
+  if (cached && now - cached.checkedAt < COMMAND_PROBE_TTL_MS) return cached.available
+  const finder = process.platform === "win32" ? "where" : "which"
+  const result = spawnSync(finder, [command], { stdio: "ignore", windowsHide: true })
+  const available = result.status === 0
+  commandProbeCache.set(command, { available, checkedAt: now })
+  return available
+}
+
+async function packageDeclared(root, name) {
+  try {
+    const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"))
+    return Boolean(
+      pkg.dependencies?.[name] ||
+      pkg.devDependencies?.[name] ||
+      pkg.optionalDependencies?.[name] ||
+      pkg.peerDependencies?.[name],
+    )
+  } catch {
+    return false
+  }
+}
+
+function normalizeProvider(provider = {}, index = 0) {
+  return {
+    id: String(provider.id || `provider-${index + 1}`),
+    kind: provider.kind || "builtin",
+    capability: provider.capability || null,
+    priority: Number.isFinite(Number(provider.priority)) ? Number(provider.priority) : 50,
+    quality: clamp(provider.quality, 0, 1, 0.5),
+    costClass: ["low", "medium", "high"].includes(provider.costClass) ? provider.costClass : "medium",
+    latencyClass: ["fast", "medium", "slow"].includes(provider.latencyClass) ? provider.latencyClass : "medium",
+    command: provider.command || null,
+    path: provider.path || null,
+    package: provider.package || null,
+    metadata: provider.metadata || {},
+  }
+}
+
+export function defaultCapabilityRegistry(root = process.cwd()) {
+  return {
+    schemaVersion: 1,
+    root: path.resolve(root),
+    capabilities: {
+      "code.search": [
+        { id: "ues-semantic-index", kind: "builtin", priority: 100, quality: 0.9, costClass: "low", latencyClass: "fast" },
+      ],
+      memory: [
+        { id: "ues-memory", kind: "builtin", priority: 100, quality: 0.9, costClass: "low", latencyClass: "fast" },
+      ],
+      evidence: [
+        { id: "ues-evidence-store", kind: "builtin", priority: 100, quality: 0.95, costClass: "low", latencyClass: "fast" },
+      ],
+      "output.compaction": [
+        {
+          id: "ues-reversible-compactor",
+          kind: "builtin",
+          priority: 100,
+          quality: 0.98,
+          costClass: "low",
+          latencyClass: "fast",
+          metadata: { default: true, reversible: true, lossy: false, scope: "model-visible UES output" },
+        },
+        {
+          id: "rtk-cli",
+          kind: "command",
+          command: "rtk",
+          priority: 82,
+          quality: 0.9,
+          costClass: "low",
+          latencyClass: "fast",
+          metadata: { default: false, external: true, experimental: false, scope: "shell-output", upstream: "rtk-ai/rtk" },
+        },
+        {
+          id: "caveman-cli",
+          kind: "command",
+          command: "caveman",
+          priority: 55,
+          quality: 0.82,
+          costClass: "medium",
+          latencyClass: "medium",
+          metadata: {
+            default: false,
+            external: true,
+            experimental: true,
+            reversible: true,
+            upstream: "JuliusBrussee/caveman",
+            licenseNote: "External runtime includes BSL-1.1 engine components; do not vendor them into the MIT core.",
+          },
+        },
+        {
+          id: "headroom-cli",
+          kind: "command",
+          command: "headroom",
+          priority: 50,
+          quality: 0.82,
+          costClass: "medium",
+          latencyClass: "medium",
+          metadata: {
+            default: false,
+            external: true,
+            experimental: true,
+            reversible: true,
+            outputShaper: false,
+            upstream: "headroomlabs-ai/headroom",
+          },
+        },
+      ],
+      filesystem: [
+        { id: "node-fs", kind: "builtin", priority: 100, quality: 0.95, costClass: "low", latencyClass: "fast" },
+      ],
+      git: [
+        { id: "git-cli", kind: "command", command: "git", priority: 100, quality: 0.95, costClass: "low", latencyClass: "fast" },
+      ],
+      "agent.host": [
+        { id: "pi-cli", kind: "command", command: "pi", priority: 100, quality: 0.95, costClass: "low", latencyClass: "fast" },
+      ],
+      github: [
+        { id: "gh-cli", kind: "command", command: "gh", priority: 80, quality: 0.85, costClass: "low", latencyClass: "fast" },
+      ],
+      browser: [
+        { id: "project-playwright", kind: "package", package: "playwright", priority: 90, quality: 0.9, costClass: "medium", latencyClass: "medium" },
+        { id: "project-playwright-core", kind: "package", package: "playwright-core", priority: 70, quality: 0.75, costClass: "medium", latencyClass: "medium" },
+      ],
+    },
+  }
+}
+
+async function readCapabilityConfig(root, file) {
+  const target = file
+    ? path.resolve(file)
+    : process.env.UES_CAPABILITY_CONFIG
+      ? path.resolve(process.env.UES_CAPABILITY_CONFIG)
+      : path.join(path.resolve(root), ".ues-capabilities.json")
+  if (!existsSync(target)) return null
+  try {
+    const parsed = JSON.parse(await readFile(target, "utf8"))
+    return parsed && typeof parsed === "object" ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+function mergeRegistry(base, extra) {
+  if (!extra?.capabilities || typeof extra.capabilities !== "object") return base
+  const capabilities = { ...base.capabilities }
+  for (const [name, values] of Object.entries(extra.capabilities)) {
+    const custom = Array.isArray(values) ? values : []
+    const seen = new Set(custom.map((item) => item?.id).filter(Boolean))
+    const inherited = (capabilities[name] || []).filter((item) => !seen.has(item.id))
+    capabilities[name] = [...custom, ...inherited]
+  }
+  return { ...base, capabilities }
+}
+
+export async function loadCapabilityRegistry(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  const base = options.registry || defaultCapabilityRegistry(root)
+  if (options.registry) return base
+  return mergeRegistry(base, await readCapabilityConfig(root, options.configFile))
+}
+
+export async function probeCapabilityProvider(provider, root = process.cwd()) {
+  const normalized = normalizeProvider(provider)
+  const checkedAt = new Date().toISOString()
+  if (normalized.kind === "builtin") {
+    return { ...normalized, status: "healthy", reason: "built-in", checkedAt }
+  }
+  if (normalized.kind === "command") {
+    const available = commandExists(normalized.command)
+    return {
+      ...normalized,
+      status: available ? "healthy" : "unavailable",
+      reason: available ? `command:${normalized.command}` : `missing-command:${normalized.command}`,
+      checkedAt,
+    }
+  }
+  if (normalized.kind === "path") {
+    const target = normalized.path ? path.resolve(root, normalized.path) : null
+    const available = Boolean(target && existsSync(target))
+    return {
+      ...normalized,
+      status: available ? "healthy" : "unavailable",
+      reason: available ? `path:${normalized.path}` : `missing-path:${normalized.path || ""}`,
+      checkedAt,
+    }
+  }
+  if (normalized.kind === "package") {
+    const declared = normalized.package ? await packageDeclared(root, normalized.package) : false
+    const installed = normalized.package
+      ? existsSync(path.join(root, "node_modules", normalized.package))
+      : false
+    const available = installed || declared
+    return {
+      ...normalized,
+      status: installed ? "healthy" : declared ? "degraded" : "unavailable",
+      reason: installed
+        ? `installed-package:${normalized.package}`
+        : declared
+          ? `declared-package:${normalized.package}`
+          : `missing-package:${normalized.package || ""}`,
+      checkedAt,
+    }
+  }
+  return { ...normalized, status: "unknown", reason: `unknown-kind:${normalized.kind}`, checkedAt }
+}
+
+export function selectCapabilityProvider(capability, providers = [], options = {}) {
+  const observations = options.observations || {}
+  const allowUnknown = options.allowUnknown === true
+  const rows = providers.map((provider, index) => {
+    const normalized = normalizeProvider(provider, index)
+    const status = provider.status || "unknown"
+    const observation = observations[normalized.id] || {}
+    const failureRate = clamp(observation.failureRate, 0, 1, 0)
+    const successRate = clamp(observation.successRate, 0, 1, 0)
+    const samples = Math.max(0, Number(observation.samples || 0))
+    const observationConfidence = samples > 0 ? Math.min(1, samples / 5) : 0
+    const successBoost = successRate * 12 * observationConfidence
+    const failurePenalty = failureRate * 35 * observationConfidence
+    const healthWeight = HEALTH_WEIGHT[status] ?? HEALTH_WEIGHT.unknown
+    const eligible = status === "healthy" || status === "degraded" || (allowUnknown && status === "unknown")
+    const score =
+      normalized.priority +
+      normalized.quality * 20 +
+      successBoost +
+      healthWeight -
+      (COST_PENALTY[normalized.costClass] ?? 5) -
+      (LATENCY_PENALTY[normalized.latencyClass] ?? 3) -
+      failurePenalty
+    return { ...normalized, status, eligible, samples, successRate, failureRate, observationConfidence: Number(observationConfidence.toFixed(3)), score: Number(score.toFixed(3)), reason: provider.reason || null }
+  })
+  const eligible = rows.filter((item) => item.eligible).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+  return {
+    schemaVersion: 1,
+    capability,
+    selected: eligible[0] || null,
+    fallbacks: eligible.slice(1),
+    candidates: rows.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id)),
+    fallbackNeeded: eligible.length === 0,
+  }
+}
+
+export async function capabilityFabricStatus(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  const registry = await loadCapabilityRegistry(root, options)
+  const persistedObservations = options.observations ? null : await readCapabilityObservations(root)
+  const capabilities = {}
+  const rows = []
+  for (const [name, providers] of Object.entries(registry.capabilities || {})) {
+    const probed = []
+    for (const provider of providers || []) probed.push(await probeCapabilityProvider(provider, root))
+    const selected = selectCapabilityProvider(name, probed, {
+      observations: options.observations?.[name] || persistedObservations?.capabilities?.[name] || {},
+      allowUnknown: options.allowUnknown,
+    })
+    capabilities[name] = selected
+    rows.push({
+      capability: name,
+      selected: selected.selected?.id || null,
+      status: selected.selected?.status || "unavailable",
+      fallbacks: selected.fallbacks.map((item) => item.id),
+    })
+  }
+  return {
+    schemaVersion: 1,
+    root,
+    generatedAt: new Date().toISOString(),
+    rows,
+    capabilities,
+    healthyCapabilities: rows.filter((item) => item.selected).length,
+    totalCapabilities: rows.length,
+    observationState: persistedObservations ? { updatedAt: persistedObservations.updatedAt, capabilities: Object.keys(persistedObservations.capabilities || {}).length } : null,
+  }
+}

package/lib/capability-registry.mjs

@@ -107,3 +107,12 @@ export function modelCandidatesFromPolicy(policy = {}) {
 export function roleCapabilityRequirements(role) {
   return { ...(ROLE_REQUIREMENTS[role] || {}) }
 }
+
+
+export {
+  capabilityFabricStatus,
+  defaultCapabilityRegistry,
+  loadCapabilityRegistry,
+  probeCapabilityProvider,
+  selectCapabilityProvider,
+} from "./capability-fabric.mjs"

package/lib/context-engine-v11.mjs

@@ -4,6 +4,8 @@ import { putEvidence } from "./evidence-store.mjs"
 import { inferTaskCapabilities } from "./capability-registry.mjs"
 import { buildPromptEnvelope, comparePromptEnvelopes } from "./prompt-cache.mjs"
 import { measureContextQuality } from "./context-quality.mjs"
+import { retrieveMemories } from "./memory-engine.mjs"
+import { capabilityFabricStatus } from "./capability-fabric.mjs"
 
 function taskText(task = {}) {
   return [
@@ -14,6 +16,20 @@ function taskText(task = {}) {
   ].filter(Boolean).join(" ")
 }
 
+function taskFilesForMemory(task = {}) {
+  const files = task.files
+  const values = []
+  if (Array.isArray(files)) values.push(...files)
+  else if (files && typeof files === "object") {
+    for (const value of Object.values(files)) {
+      if (Array.isArray(value)) values.push(...value)
+      else if (typeof value === "string") values.push(value)
+    }
+  }
+  if (Array.isArray(task.requiredFiles)) values.push(...task.requiredFiles)
+  return [...new Set(values.filter(Boolean))]
+}
+
 function rankExcerpt(item = {}, task = {}) {
   const text = taskText(task).toLowerCase()
   const pathValue = String(item.path || "").toLowerCase()
@@ -91,6 +107,8 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
     strategy: options.strategy || policy?.profile?.contextStrategy || "incremental-semantic+git",
     semanticMaxFiles: options.semanticMaxFiles,
     maxFiles: options.maxFiles,
+    changedFiles: options.changedFiles,
+    workspaceFingerprint: options.workspaceFingerprint,
   })
 
   const externalized = await externalizeContextExcerpts(root, manifest, {
@@ -99,6 +117,24 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
     inlineChars: options.inlineChars,
   })
 
+  const memoryRetrieval = await retrieveMemories(root, taskText(task), {
+    files: taskFilesForMemory(task),
+    limit: options.memoryLimit ?? 6,
+    taskClass: options.taskClass || task.type || policy.executionProfile || policy.profile?.name || null,
+    touch: options.touchMemories !== false,
+  }).catch(() => ({ schemaVersion: 1, query: taskText(task), eligible: 0, results: [] }))
+  const memories = memoryRetrieval.results || []
+  const fabric = await capabilityFabricStatus(root).catch(() => null)
+  const providerHints = (fabric?.rows || [])
+    .filter((row) => row.selected)
+    .slice(0, 12)
+    .map((row) => ({
+      capability: row.capability,
+      selected: row.selected,
+      status: row.status,
+      fallbacks: (row.fallbacks || []).slice(0, 3),
+    }))
+
   const promptEnvelope = buildPromptEnvelope({
     invariants: options.invariants || "evidence-first; scoped edits; fresh verification; no unsupported completion claims",
     role: options.role || "executor",
@@ -114,6 +150,23 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
       ...(externalized.manifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
       ...(options.evidence || []),
     ],
+    memories: memories.map((item) => ({
+      id: item.id,
+      type: item.type,
+      scope: item.scope,
+      content: item.content,
+      confidence: item.confidence,
+      files: item.files,
+      retrieval: item.retrieval,
+    })),
+    contextHints: {
+      hierarchy: (externalized.manifest?.hierarchy?.scopes || []).slice(0, 6).map((item) => ({
+        path: item.path,
+        score: item.score,
+        l0: item.l0,
+      })),
+      providers: providerHints,
+    },
     recentFailure: options.recentFailure || null,
     nextAction: options.nextAction || null,
     recentMessages: options.recentMessages || [],
@@ -132,6 +185,17 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
     evidenceBudget,
     contextManifest: externalized.manifest,
     contextQuality,
+    memories,
+    memoryRetrieval: {
+      schemaVersion: memoryRetrieval.schemaVersion || 1,
+      eligible: memoryRetrieval.eligible || 0,
+      returned: memories.length,
+    },
+    capabilityFabric: {
+      healthyCapabilities: fabric?.healthyCapabilities || 0,
+      totalCapabilities: fabric?.totalCapabilities || 0,
+      providers: providerHints,
+    },
     evidenceStore: {
       refs: externalized.externalized.length,
       externalizedBytes: externalized.externalizedBytes,
@@ -147,4 +211,4 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
       ...(cache || {}),
     },
   }
-}
+}