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

package/lib/prompt-cache.mjs

@@ -29,6 +29,8 @@ export function buildPromptEnvelope(input = {}) {
   const dynamic = {
     task: input.task || {},
     evidence: input.evidence || [],
+    memories: input.memories || [],
+    contextHints: input.contextHints || {},
     recentFailure: input.recentFailure || null,
     nextAction: input.nextAction || null,
     recentMessages: input.recentMessages || [],

package/lib/repo-graph.mjs

@@ -1,10 +1,12 @@
 import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
+import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
 
 const SKIP = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
-  "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "bin", "obj",
-  ".ues-work",
+  "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
+  ".ues-work", ".ues-cache", ".ues-traces", ".ues-learning", ".ues-dashboard",
+  ".ues-sandboxes", ".ues-memory", ".ues-evals",
 ])
 
 const SOURCE_EXTENSIONS = new Set([
@@ -133,3 +135,52 @@ export async function buildRepoGraph(root = process.cwd(), options = {}) {
       .slice(0, 50),
   }
 }
+
+const RUNTIME_GRAPH_CACHE = new Map()
+const RUNTIME_GRAPH_INFLIGHT = new Map()
+
+export async function buildRepoGraphCached(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  const maxFiles = Number(options.maxFiles ?? 2500)
+  const maxDepth = Number(options.maxDepth ?? 8)
+  let fingerprint = String(options.workspaceFingerprint || "")
+  if (!fingerprint || fingerprint === "unknown") {
+    try {
+      fingerprint = runtimeWorkspaceFingerprint(root)
+    } catch {
+      return buildRepoGraph(root, options)
+    }
+  }
+  const key = [root, fingerprint, maxFiles, maxDepth].join("\u0000")
+  if (RUNTIME_GRAPH_CACHE.has(key)) {
+    const value = RUNTIME_GRAPH_CACHE.get(key)
+    RUNTIME_GRAPH_CACHE.delete(key)
+    RUNTIME_GRAPH_CACHE.set(key, value)
+    return value
+  }
+
+  if (RUNTIME_GRAPH_INFLIGHT.has(key)) {
+    return RUNTIME_GRAPH_INFLIGHT.get(key)
+  }
+
+  const pending = buildRepoGraph(root, options)
+  RUNTIME_GRAPH_INFLIGHT.set(key, pending)
+  let graph
+  try {
+    graph = await pending
+  } finally {
+    RUNTIME_GRAPH_INFLIGHT.delete(key)
+  }
+  RUNTIME_GRAPH_CACHE.set(key, graph)
+  while (RUNTIME_GRAPH_CACHE.size > 8) {
+    const oldest = RUNTIME_GRAPH_CACHE.keys().next().value
+    if (!oldest) break
+    RUNTIME_GRAPH_CACHE.delete(oldest)
+  }
+  return graph
+}
+
+export function clearRepoGraphRuntimeCache() {
+  RUNTIME_GRAPH_CACHE.clear()
+  RUNTIME_GRAPH_INFLIGHT.clear()
+}

package/lib/runtime-config.mjs

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+function xdgConfigRoot() {
+  return process.env.XDG_CONFIG_HOME
+    ? path.resolve(process.env.XDG_CONFIG_HOME)
+    : path.join(os.homedir(), ".config")
+}
+
+export function getUesConfigDir() {
+  if (process.env.UES_CONFIG_DIR) return path.resolve(process.env.UES_CONFIG_DIR)
+
+  const nativeDir = path.join(xdgConfigRoot(), "ues")
+  const legacyDir = process.env.OPENCODE_CONFIG_DIR
+    ? path.resolve(process.env.OPENCODE_CONFIG_DIR)
+    : path.join(xdgConfigRoot(), "opencode")
+
+  const nativePolicy = path.join(nativeDir, ".ues", "model-policy.json")
+  const legacyPolicy = path.join(legacyDir, ".ues", "model-policy.json")
+
+  if (existsSync(nativePolicy)) return nativeDir
+  if (existsSync(legacyPolicy)) return legacyDir
+  return nativeDir
+}
+
+export function getLegacyOpenCodeConfigDir() {
+  return process.env.OPENCODE_CONFIG_DIR
+    ? path.resolve(process.env.OPENCODE_CONFIG_DIR)
+    : path.join(xdgConfigRoot(), "opencode")
+}

package/lib/safety.mjs

@@ -0,0 +1,132 @@
+const RULES = [
+  { id: "git-force", pattern: /\bgit\s+(?:push\b[^\n]*(?:--force(?:-with-lease)?|(?:^|\s)-f(?:\s|$))|reset\s+--hard|clean\s+-[^\n]*f)/i },
+  { id: "history-rewrite", pattern: /\bgit\s+(?:rebase\b|filter-branch\b|filter-repo\b)/i },
+  { id: "publish", pattern: /\b(?:npm\s+publish|pnpm\s+publish|yarn\s+npm\s+publish)\b/i },
+  { id: "destructive-files", pattern: /(?:^|[;&|]\s*)(?:rm\s+-[^\n]*r[^\n]*f|rmdir\s+\/s|del\s+\/s|remove-item\b[^\n]*-recurse[^\n]*-force)/i },
+  { id: "database-drop", pattern: /\b(?:drop\s+(?:database|schema|table)|truncate\s+table)\b/i },
+  { id: "deployment", pattern: /\b(?:kubectl\s+(?:delete|apply)|terraform\s+(?:apply|destroy)|helm\s+(?:install|upgrade|uninstall))\b/i },
+]
+
+export function shellCommandSegments(command) {
+  const value = String(command || "")
+  const segments = []
+  let current = ""
+  let quote = null
+  let escaped = false
+  let depth = 0
+
+  const push = (operator = null) => {
+    const text = current.trim()
+    if (text) segments.push({ text, operator })
+    current = ""
+  }
+
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index]
+    const next = value[index + 1] || ""
+
+    if (escaped) {
+      current += char
+      escaped = false
+      continue
+    }
+    if (char === "\\" && quote !== "'") {
+      current += char
+      escaped = true
+      continue
+    }
+    if (quote) {
+      current += char
+      if (char === quote) quote = null
+      continue
+    }
+    if (char === "'" || char === '"') {
+      quote = char
+      current += char
+      continue
+    }
+    if (char === "(" || char === "{" || char === "[") {
+      depth += 1
+      current += char
+      continue
+    }
+    if (char === ")" || char === "}" || char === "]") {
+      depth = Math.max(0, depth - 1)
+      current += char
+      continue
+    }
+
+    if (depth === 0 && char === "&" && next === "&") {
+      push("&&")
+      index += 1
+      continue
+    }
+    if (depth === 0 && char === "|" && next === "|") {
+      push("||")
+      index += 1
+      continue
+    }
+    if (depth === 0 && (char === ";" || char === "|")) {
+      push(char)
+      continue
+    }
+    if (depth === 0 && char === "\n") {
+      push("\n")
+      continue
+    }
+    current += char
+  }
+  push(null)
+  return segments
+}
+
+export function destructiveShellAnalysis(command) {
+  const value = String(command || "")
+  const segments = shellCommandSegments(value)
+  const findings = []
+
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index]
+    for (const rule of RULES) {
+      // Clone regex state defensively if future rules add the global flag.
+      rule.pattern.lastIndex = 0
+      if (!rule.pattern.test(segment.text)) continue
+      findings.push({
+        id: rule.id,
+        segmentIndex: index,
+        segment: segment.text,
+        operator: segment.operator,
+      })
+      break
+    }
+  }
+
+  // Retain a whole-command fallback so nested shell syntax that the bounded
+  // splitter intentionally does not fully parse still fails closed.
+  if (!findings.length) {
+    for (const rule of RULES) {
+      rule.pattern.lastIndex = 0
+      if (rule.pattern.test(value)) {
+        findings.push({ id: rule.id, segmentIndex: null, segment: value, operator: null })
+        break
+      }
+    }
+  }
+
+  return {
+    risky: findings.length > 0,
+    id: findings[0]?.id || null,
+    findings,
+    segmentCount: segments.length,
+  }
+}
+
+export function destructiveShellRisk(command) {
+  const analysis = destructiveShellAnalysis(command)
+  return {
+    risky: analysis.risky,
+    id: analysis.id,
+    segmentIndex: analysis.findings[0]?.segmentIndex ?? null,
+    segment: analysis.findings[0]?.segment || null,
+  }
+}

package/lib/semantic-index.mjs

@@ -11,8 +11,8 @@ 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", "bin", "obj",
-  ".ues-work", ".ues-learning", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces",
+  "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
+  ".ues-work", ".ues-learning", ".ues-memory", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces",
 ])
 const STOP_IDENTIFIERS = new Set([
   "const","let","var","function","class","interface","type","export","import","from","return",
@@ -233,7 +233,7 @@ function queryTerms(query) {
 export async function querySemanticIndex(root, query, options = {}) {
   const terms = queryTerms(query)
   if (!terms.length) return { query: String(query || ""), terms: [], results: [], stats: null }
-  const built = await buildSemanticIndex(root, options)
+  const built = options.builtIndex || await buildSemanticIndex(root, options)
   const lowerTerms = terms.map((term) => term.toLowerCase())
   const results = []
 
@@ -316,3 +316,52 @@ export async function semanticIndexStatus(root = process.cwd()) {
     truncated: Boolean(cached?.truncated),
   }
 }
+
+const RUNTIME_SEMANTIC_CACHE = new Map()
+const RUNTIME_SEMANTIC_INFLIGHT = new Map()
+
+export async function buildSemanticIndexCached(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  const fingerprint = String(options.workspaceFingerprint || "")
+  if (!fingerprint || fingerprint === "unknown") {
+    return buildSemanticIndex(root, options)
+  }
+
+  const maxFiles = Number(options.maxFiles ?? 6000)
+  const maxDepth = Number(options.maxDepth ?? 14)
+  const maxBytes = Number(options.maxBytes ?? 768 * 1024)
+  const key = [root, fingerprint, maxFiles, maxDepth, maxBytes].join("\u0000")
+  if (RUNTIME_SEMANTIC_CACHE.has(key)) {
+    const value = RUNTIME_SEMANTIC_CACHE.get(key)
+    RUNTIME_SEMANTIC_CACHE.delete(key)
+    RUNTIME_SEMANTIC_CACHE.set(key, value)
+    return { ...value, runtimeCacheHit: true }
+  }
+
+  if (RUNTIME_SEMANTIC_INFLIGHT.has(key)) {
+    const value = await RUNTIME_SEMANTIC_INFLIGHT.get(key)
+    return { ...value, runtimeCacheHit: true, runtimeCacheCoalesced: true }
+  }
+
+  const pending = buildSemanticIndex(root, options)
+    .then((built) => ({ ...built, runtimeCacheHit: false }))
+  RUNTIME_SEMANTIC_INFLIGHT.set(key, pending)
+
+  try {
+    const value = await pending
+    RUNTIME_SEMANTIC_CACHE.set(key, value)
+    while (RUNTIME_SEMANTIC_CACHE.size > 6) {
+      const oldest = RUNTIME_SEMANTIC_CACHE.keys().next().value
+      if (!oldest) break
+      RUNTIME_SEMANTIC_CACHE.delete(oldest)
+    }
+    return value
+  } finally {
+    RUNTIME_SEMANTIC_INFLIGHT.delete(key)
+  }
+}
+
+export function clearSemanticIndexRuntimeCache() {
+  RUNTIME_SEMANTIC_CACHE.clear()
+  RUNTIME_SEMANTIC_INFLIGHT.clear()
+}

package/lib/skill-compiler.mjs

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const SKILLS_ROOT = path.join(PACKAGE_ROOT, "global-config", "skills")
+const SKILL_SOURCE_CACHE = new Map()
+const COMPILED_SKILL_CACHE = new Map()
+
+const DOMAIN_SKILLS = Object.freeze({
+  "auth-security": "auth-security",
+  payment: "payment-engineering",
+  database: "database-engineering",
+  "api-contract": "api-contract",
+  "react-native": "react-native-engineering",
+  nextjs: "nextjs-engineering",
+  react: "react-engineering",
+  devops: "devops-engineering",
+})
+
+const ROLE_SKILLS = Object.freeze({
+  architect: ["software-architect", "task-planner"],
+  "codebase-mapper": ["repo-explorer", "context-engineering"],
+  critic: ["code-review", "change-impact-analysis"],
+  debugger: ["bug-diagnosis", "test-verification"],
+  executor: ["implementation-engineer"],
+  "integration-verifier": ["test-verification", "change-impact-analysis"],
+  "merge-arbiter": ["git-safety", "change-impact-analysis"],
+  "plan-checker": ["task-planner", "change-impact-analysis"],
+  researcher: ["research-verification"],
+  reviewer: ["code-review"],
+  verifier: ["test-verification"],
+  "visual-verifier": ["visual-fidelity", "responsive-verification", "browser-qa"],
+})
+
+function stripFrontmatter(raw) {
+  return String(raw || "").replace(/^---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n/, "")
+}
+
+function priorityLine(line) {
+  return /^#{1,4}\s/.test(line) ||
+    /^[-*]\s+/.test(line) ||
+    /\b(must|never|always|verify|prefer|avoid|require|do not|don't|fail|evidence|security|safety|rollback|idempot|transaction|accessib)/i.test(line)
+}
+
+function compileText(raw, maxChars) {
+  const source = stripFrontmatter(raw)
+  const lines = source.split(/\r?\n/).map((line) => line.trimEnd())
+  const selected = []
+  let chars = 0
+
+  // Keep a short orientation prefix, then the highest-value rules/checklists.
+  for (const line of lines.slice(0, 20)) {
+    if (!line.trim()) continue
+    if (chars + line.length + 1 > Math.floor(maxChars * 0.35)) break
+    selected.push(line)
+    chars += line.length + 1
+  }
+  for (const line of lines) {
+    if (!line.trim() || !priorityLine(line) || selected.includes(line)) continue
+    if (chars + line.length + 1 > maxChars) break
+    selected.push(line)
+    chars += line.length + 1
+  }
+  return selected.join("\n").slice(0, maxChars)
+}
+
+export function selectSkillNames(taskPolicy = {}, role = "executor", options = {}) {
+  const maxSkills = Math.max(1, Math.min(5, Number(options.maxSkills || taskPolicy.maxSkills || 3)))
+  const names = []
+  for (const name of ROLE_SKILLS[role] || []) names.push(name)
+  for (const domain of taskPolicy.domains || []) {
+    const mapped = DOMAIN_SKILLS[domain]
+    if (mapped) names.push(mapped)
+  }
+  return [...new Set(names)].slice(0, maxSkills)
+}
+
+async function skillSource(name) {
+  if (SKILL_SOURCE_CACHE.has(name)) return SKILL_SOURCE_CACHE.get(name)
+  const file = path.join(SKILLS_ROOT, name, "SKILL.md")
+  if (!existsSync(file)) {
+    SKILL_SOURCE_CACHE.set(name, "")
+    return ""
+  }
+  const raw = await readFile(file, "utf8").catch(() => "")
+  SKILL_SOURCE_CACHE.set(name, raw)
+  return raw
+}
+
+export async function compileSkillContext(taskPolicy = {}, role = "executor", options = {}) {
+  const names = selectSkillNames(taskPolicy, role, options)
+  const totalChars = Math.max(800, Math.min(8_000, Number(options.totalChars || 3_200)))
+  const perSkill = Math.max(450, Math.floor(totalChars / Math.max(1, names.length)))
+  const cacheKey = JSON.stringify([role, names, totalChars, perSkill])
+  if (COMPILED_SKILL_CACHE.has(cacheKey)) {
+    return { ...COMPILED_SKILL_CACHE.get(cacheKey), cacheHit: true }
+  }
+
+  const skills = []
+  for (const name of names) {
+    const raw = await skillSource(name)
+    if (!raw) continue
+    const text = compileText(raw, perSkill)
+    if (text) skills.push({ name, text })
+  }
+
+  const result = {
+    schemaVersion: 1,
+    role,
+    requested: names,
+    loaded: skills.map((item) => item.name),
+    chars: skills.reduce((sum, item) => sum + item.text.length, 0),
+    text: skills
+      .map((item) => `### Skill: ${item.name}\n${item.text}`)
+      .join("\n\n")
+      .slice(0, totalChars),
+    cacheHit: false,
+  }
+  COMPILED_SKILL_CACHE.set(cacheKey, result)
+  return result
+}
+
+export function clearSkillCompilerCache() {
+  SKILL_SOURCE_CACHE.clear()
+  COMPILED_SKILL_CACHE.clear()
+}

package/lib/skill-quality.mjs

@@ -15,9 +15,53 @@ function similarity(a, b) {
   return union.size ? intersection / union.size : 0
 }
 
+export function validateFrontmatterSource(source, options = {}) {
+  const text = String(source || "")
+  const errors = []
+  if (!text.startsWith("---\n") && !text.startsWith("---\r\n")) {
+    return { valid: false, errors: [{ issue: "missing-frontmatter-open", file: options.file || null }] }
+  }
+
+  const match = text.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/)
+  if (!match) {
+    return { valid: false, errors: [{ issue: "missing-frontmatter-close", file: options.file || null }] }
+  }
+
+  const lines = match[1].split(/\r?\n/)
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]
+    if (!line.trim() || /^\s/.test(line) || line.trimStart().startsWith("#")) continue
+    if (/\t/.test(line)) {
+      errors.push({ issue: "frontmatter-tab", line: index + 2, file: options.file || null })
+      continue
+    }
+    const field = line.match(/^([A-Za-z0-9_-]+):(?:\s*(.*))?$/)
+    if (!field) {
+      errors.push({ issue: "invalid-frontmatter-line", line: index + 2, file: options.file || null })
+      continue
+    }
+    const value = String(field[2] || "").trim()
+    if (!value) continue
+    const quoted = (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    const blockScalar = value === "|" || value === ">"
+    const flowValue = value.startsWith("[") || value.startsWith("{")
+    if (!quoted && !blockScalar && !flowValue && /:\s/.test(value)) {
+      errors.push({
+        issue: "unquoted-colon-in-scalar",
+        field: field[1],
+        line: index + 2,
+        file: options.file || null,
+      })
+    }
+  }
+
+  return { valid: errors.length === 0, errors }
+}
+
 function frontmatter(source) {
-  const name = source.match(/^name:\s*([^\r\n]+)/m)?.[1]?.trim() || null
-  const description = source.match(/^description:\s*([^\r\n]+)/m)?.[1]?.trim() || null
+  const name = source.match(/^name:\s*([^\r\n]+)/m)?.[1]?.trim()?.replace(/^(["'])(.*)\1$/, "$2") || null
+  const description = source.match(/^description:\s*([^\r\n]+)/m)?.[1]?.trim()?.replace(/^(["'])(.*)\1$/, "$2") || null
   return { name, description }
 }
 
@@ -36,6 +80,8 @@ export async function lintSkillCatalog(root = process.cwd(), options = {}) {
       continue
     }
     const source = await readFile(file, "utf8")
+    const yaml = validateFrontmatterSource(source, { file })
+    for (const error of yaml.errors) errors.push({ skill: entry.name, ...error })
     const meta = frontmatter(source)
     const body = source.replace(/^---[\s\S]*?---\s*/m, "")
     const row = {

package/lib/task-engine.mjs

@@ -15,6 +15,8 @@ import { putEvidence } from "./evidence-store.mjs"
 import { inferTaskCapabilities } from "./capability-registry.mjs"
 import { buildPromptEnvelope } from "./prompt-cache.mjs"
 import { externalizeContextExcerpts } from "./context-engine-v11.mjs"
+import { recordVerifiedTaskMemory, retrieveMemories } from "./memory-engine.mjs"
+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"
@@ -174,7 +176,7 @@ function gitCapture(root, args) {
 }
 
 const FINGERPRINT_SKIP_DIRS = new Set([
-  ".git", ".ues-work", ".ues-learning", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces",
+  ".git", ".ues-work", ".ues-learning", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces", ".ues-memory",
   "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".cache", ".turbo", "target", "bin", "obj",
 ])
@@ -256,9 +258,9 @@ export function workspaceFingerprint(root) {
   const parts = []
   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"],
-    ["diff", "--binary", "--no-ext-diff", "--", ".", ":(exclude).ues-work", ":(exclude).ues-learning", ":(exclude).ues-dashboard", ":(exclude).ues-sandboxes", ":(exclude).ues-cache", ":(exclude).ues-traces"],
-    ["diff", "--cached", "--binary", "--no-ext-diff", "--", ".", ":(exclude).ues-work", ":(exclude).ues-learning", ":(exclude).ues-dashboard", ":(exclude).ues-sandboxes", ":(exclude).ues-cache", ":(exclude).ues-traces"],
+    ["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"],
   ]
   for (const args of commands) {
     const result = gitCapture(root, args)
@@ -1087,7 +1089,20 @@ export async function finalizeWork(root, slug, evidence) {
     await writeJson(loaded.paths.evidence, loaded.evidence)
     await writeJson(loaded.paths.state, loaded.state)
     await journal(loaded.paths, "work.finalized", { fingerprint: currentFingerprint })
-    return { state: loaded.state, evidence: loaded.evidence.entries.at(-1) }
+
+    const memory = await recordVerifiedTaskMemory(loaded.paths.root, {
+      task: loaded.state.goal || loaded.plan.goal || `Completed durable work: ${slug}`,
+      files: [...new Set(loaded.plan.tasks.flatMap((task) => taskFiles(task)))],
+      verifier: verification.receipt?.verifier || "ues-integration-verifier",
+      verifierOutput: [verification.evidence, verification.report].filter(Boolean).join("\n"),
+      integrationOutput: evidenceText,
+      sourceTask: `work:${slug}`,
+      taskClass: "long-horizon",
+      type: "episodic",
+      scope: "project",
+    }).catch(() => null)
+
+    return { state: loaded.state, evidence: loaded.evidence.entries.at(-1), memory }
   })
 }
 
@@ -1161,6 +1176,24 @@ async function buildContextPack(loaded, taskID) {
     [task.title, task.summary, ...(task.acceptance || [])].join(" "),
   ).catch(() => [])
 
+  const memoryRetrieval = await retrieveMemories(loaded.paths.root, taskText, {
+    files: taskFiles(task),
+    limit: 6,
+    taskClass: contextPolicy.executionProfile || contextPolicy.profile?.name || contextPolicy.mode || null,
+    touch: true,
+  }).catch(() => ({ schemaVersion: 1, query: taskText, eligible: 0, results: [] }))
+  const memories = memoryRetrieval.results || []
+  const fabric = await capabilityFabricStatus(loaded.paths.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 specStored = spec
     ? await putEvidence(loaded.paths.root, spec, {
         kind: "work-spec",
@@ -1183,6 +1216,23 @@ async function buildContextPack(loaded, taskID) {
       ...(contextManifest?.evidencePointers || []).map((item) => item.ref),
       ...(contextManifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
     ],
+    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: (contextManifest?.hierarchy?.scopes || []).slice(0, 6).map((item) => ({
+        path: item.path,
+        score: item.score,
+        l0: item.l0,
+      })),
+      providers: providerHints,
+    },
     recentFailure: recovery.stage === "initial" ? null : loaded.state.tasks?.[taskID]?.lastError || null,
     nextAction: loaded.state.checkpoint?.nextAction || loaded.state.nextAction || null,
   })
@@ -1220,6 +1270,17 @@ async function buildContextPack(loaded, taskID) {
     planApproval: loaded.state.planApproval || null,
     contextManifest,
     acceptedLearnings: learnings,
+    memories,
+    memoryRetrieval: {
+      schemaVersion: memoryRetrieval.schemaVersion || 1,
+      eligible: memoryRetrieval.eligible || 0,
+      returned: memories.length,
+    },
+    capabilityFabric: {
+      healthyCapabilities: fabric?.healthyCapabilities || 0,
+      totalCapabilities: fabric?.totalCapabilities || 0,
+      providers: providerHints,
+    },
     workingState: {
       status: loaded.state.status,
       task: loaded.state.tasks?.[taskID],