opencode-agent-skill 15.0.0 → 15.1.0

package/lib/compaction-resume-guard.mjs

@@ -0,0 +1,255 @@
+import { createHash } from "node:crypto"
+import { existsSync } from "node:fs"
+import { readdir, readFile } from "node:fs/promises"
+import path from "node:path"
+import { checkpointWork } from "./task-engine.mjs"
+
+const WORK_DIR = ".ues-work"
+const MAX_WORKSPACES = 3
+const MAX_TASKS = 28
+const MAX_RECEIPTS = 20
+
+function digest(value) {
+  return createHash("sha256").update(String(value || "")).digest("hex").slice(0, 20)
+}
+
+async function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"))
+  } catch (error) {
+    if (error?.code === "ENOENT") return fallback
+    return fallback
+  }
+}
+
+function inside(base, target) {
+  const root = path.resolve(base)
+  const resolved = path.resolve(target)
+  return resolved === root || resolved.startsWith(root + path.sep)
+}
+
+function normalizePhasePath(value) {
+  return String(value || "").replaceAll("\\", "/").replace(/^\.\/+/, "")
+}
+
+async function activeWorkspaces(root, max = MAX_WORKSPACES) {
+  const base = path.join(path.resolve(root), WORK_DIR)
+  if (!existsSync(base)) return []
+  const entries = await readdir(base, { withFileTypes: true }).catch(() => [])
+  const rows = []
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const dir = path.join(base, entry.name)
+    const state = await readJson(path.join(dir, "STATE.json"), null)
+    if (!state || String(state.status || "").toLowerCase() === "completed") continue
+    rows.push({
+      slug: entry.name,
+      dir,
+      state,
+      updatedAt: Date.parse(state.updatedAt || state.createdAt || "") || 0,
+    })
+  }
+  return rows
+    .sort((a, b) => b.updatedAt - a.updatedAt || a.slug.localeCompare(b.slug))
+    .slice(0, Math.max(1, Math.min(10, Number(max || MAX_WORKSPACES))))
+}
+
+function taskRows(plan, state) {
+  const tasks = Array.isArray(plan?.tasks) ? plan.tasks : []
+  const rows = tasks.map((task) => {
+    const runtime = state?.tasks?.[task.id] || {}
+    return {
+      id: task.id,
+      title: String(task.title || "").slice(0, 240),
+      status: runtime.status || "unknown",
+      attempts: Number(runtime.attempts || 0),
+      runId: runtime.runId || null,
+      dependsOn: Array.isArray(task.dependsOn) ? task.dependsOn.slice(0, 24) : [],
+      evidenceStrength: runtime.evidenceStrength || null,
+      report: runtime.report || null,
+      lastError: runtime.lastError ? String(runtime.lastError).slice(0, 800) : null,
+    }
+  })
+  rows.sort((a, b) => {
+    const rank = (row) => row.status === "running" ? 0 : row.status === "completed" ? 2 : 1
+    return rank(a) - rank(b) || String(a.id).localeCompare(String(b.id))
+  })
+  return rows.slice(0, MAX_TASKS)
+}
+
+function receiptRows(evidence) {
+  return (Array.isArray(evidence?.receipts) ? evidence.receipts : [])
+    .slice(-MAX_RECEIPTS)
+    .map((item) => ({
+      id: item.id || null,
+      kind: item.kind || "verification-receipt",
+      task: item.task || null,
+      runId: item.runId || null,
+      passed: item.passed === true,
+      verdict: item.verdict || (item.passed === true ? "PASS" : null),
+      command: item.command || null,
+      workspaceAfter: item.workspaceAfter || null,
+      recordedAt: item.recordedAt || item.finishedAt || null,
+    }))
+}
+
+function gateRows(evidence) {
+  return (Array.isArray(evidence?.gateReceipts) ? evidence.gateReceipts : [])
+    .slice(-12)
+    .map((item) => ({
+      id: item.id || null,
+      kind: item.kind || null,
+      verdict: item.verdict || null,
+      verifier: item.verifier || null,
+      planHash: item.planHash || null,
+      workspaceFingerprint: item.workspaceFingerprint || null,
+      recordedAt: item.recordedAt || null,
+    }))
+}
+
+async function phaseRows(dir, manifest) {
+  const artifacts = Array.isArray(manifest?.artifacts) ? manifest.artifacts : []
+  const rows = []
+  for (const relative of artifacts.slice(0, 32)) {
+    const normalized = normalizePhasePath(relative)
+    const target = path.resolve(dir, normalized)
+    if (!normalized || !inside(dir, target)) continue
+    const phase = await readJson(target, null)
+    if (!phase) continue
+    rows.push({
+      artifact: normalized,
+      phase: phase.phase ?? null,
+      title: String(phase.title || "").slice(0, 240),
+      status: phase.status || "UNKNOWN",
+      sourceBodyHash: phase.sourceBodyHash || null,
+      evidenceCount: Array.isArray(phase.evidence) ? phase.evidence.length : 0,
+      finalVerdicts: phase.finalVerdicts || null,
+    })
+  }
+  return rows
+}
+
+function stateSummary(state) {
+  return {
+    status: state?.status || null,
+    goal: state?.goal ? String(state.goal).slice(0, 800) : null,
+    updatedAt: state?.updatedAt || null,
+    planHash: state?.planHash || null,
+    planApproved: state?.planApproved === true,
+    nextAction: state?.nextAction || null,
+    checkpoint: state?.checkpoint ? {
+      id: state.checkpoint.id || null,
+      reason: state.checkpoint.reason || null,
+      createdAt: state.checkpoint.createdAt || null,
+      currentTaskId: state.checkpoint.currentTaskId || null,
+      runId: state.checkpoint.runId || null,
+      planHash: state.checkpoint.planHash || null,
+      workspaceFingerprint: state.checkpoint.workspaceFingerprint || null,
+      nextAction: state.checkpoint.nextAction || null,
+      evidencePointers: Array.isArray(state.checkpoint.evidencePointers)
+        ? state.checkpoint.evidencePointers.slice(-20)
+        : [],
+    } : null,
+  }
+}
+
+export async function checkpointDurableWorkBeforeCompaction(root, options = {}) {
+  const reason = String(options.reason || "unknown")
+  const rows = await activeWorkspaces(root, options.maxWorkspaces || MAX_WORKSPACES)
+  const results = []
+  for (const row of rows) {
+    try {
+      const checkpoint = await checkpointWork(root, row.slug, {
+        reason: `pi-compaction:${reason}`,
+      })
+      results.push({ slug: row.slug, checkpoint, ok: true })
+    } catch (error) {
+      results.push({
+        slug: row.slug,
+        checkpoint: null,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+  return results
+}
+
+export async function buildCompactionResumeGuard(root, options = {}) {
+  const rows = await activeWorkspaces(root, options.maxWorkspaces || MAX_WORKSPACES)
+  const workspaces = []
+  for (const row of rows) {
+    const [plan, evidence, contract, manifest] = await Promise.all([
+      readJson(path.join(row.dir, "PLAN.json"), null),
+      readJson(path.join(row.dir, "EVIDENCE.json"), {}),
+      readJson(path.join(row.dir, "EXECUTION_CONTRACT.json"), null),
+      readJson(path.join(row.dir, "phases", "MANIFEST.json"), null),
+    ])
+    const phases = await phaseRows(row.dir, manifest)
+    const sources = {
+      state: path.relative(root, path.join(row.dir, "STATE.json")).replaceAll("\\", "/"),
+      plan: path.relative(root, path.join(row.dir, "PLAN.json")).replaceAll("\\", "/"),
+      evidence: path.relative(root, path.join(row.dir, "EVIDENCE.json")).replaceAll("\\", "/"),
+      executionContract: contract
+        ? path.relative(root, path.join(row.dir, "EXECUTION_CONTRACT.json")).replaceAll("\\", "/")
+        : null,
+      phaseManifest: manifest
+        ? path.relative(root, path.join(row.dir, "phases", "MANIFEST.json")).replaceAll("\\", "/")
+        : null,
+    }
+    workspaces.push({
+      slug: row.slug,
+      sources,
+      sourceHashes: {
+        state: digest(JSON.stringify(row.state)),
+        plan: digest(JSON.stringify(plan || {})),
+        evidence: digest(JSON.stringify(evidence || {})),
+        executionContract: contract ? digest(JSON.stringify(contract)) : null,
+        phaseManifest: manifest ? digest(JSON.stringify(manifest)) : null,
+      },
+      state: stateSummary(row.state),
+      tasks: taskRows(plan, row.state),
+      receipts: receiptRows(evidence),
+      gateReceipts: gateRows(evidence),
+      executionContract: contract ? {
+        schemaVersion: contract.schemaVersion || null,
+        taskHash: contract.taskHash || null,
+        gates: contract.gates || null,
+        phaseCount: Array.isArray(contract.phases) ? contract.phases.length : 0,
+        approvedInheritedDirtyPaths: Array.isArray(contract.approvedInheritedDirtyPaths)
+          ? contract.approvedInheritedDirtyPaths.slice(0, 40)
+          : [],
+      } : null,
+      phases,
+    })
+  }
+
+  return {
+    schemaVersion: 1,
+    kind: "ues-durable-compaction-resume-guard",
+    generatedAt: new Date().toISOString(),
+    compactionReason: options.reason || null,
+    source: "deterministic-filesystem-artifacts",
+    modelSummaryTrustedForDurableState: false,
+    workspaceCount: workspaces.length,
+    workspaces,
+  }
+}
+
+export function renderCompactionResumeGuard(packet, options = {}) {
+  if (!packet?.workspaces?.length) return ""
+  const maxChars = Math.max(8000, Math.min(48000, Number(options.maxChars || 28000)))
+  const preface = [
+    "## 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.",
+    "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.",
+    "",
+  ].join("\n")
+  const encoded = JSON.stringify(packet, null, 2)
+  if (preface.length + encoded.length <= maxChars) return preface + encoded
+  return preface + encoded.slice(0, Math.max(0, maxChars - preface.length - 120)) +
+    "\n...[resume packet bounded; re-read referenced .ues-work artifacts for exact detail]"
+}

package/lib/context-engine-v11.mjs

@@ -101,6 +101,16 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
   const policy = options.policy || {}
   const capabilities = options.capabilities || inferTaskCapabilities(taskText(task), options.facts || {})
   const evidenceBudget = options.evidenceBudget || planEvidenceBudget(policy, task, capabilities.required)
+  const contextBuildStartedAt = Date.now()
+  const memoryPromise = 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 fabricPromise = capabilityFabricStatus(root).catch(() => null)
+
+  const manifestStartedAt = Date.now()
   const manifest = await buildContextManifest(root, task, {
     budget: evidenceBudget.total,
     evidenceBudget,
@@ -110,21 +120,18 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
     changedFiles: options.changedFiles,
     workspaceFingerprint: options.workspaceFingerprint,
   })
+  const manifestMs = Date.now() - manifestStartedAt
 
+  const externalizeStartedAt = Date.now()
   const externalized = await externalizeContextExcerpts(root, manifest, {
     task,
     threshold: options.externalizeThreshold,
     inlineChars: options.inlineChars,
   })
+  const externalizeMs = Date.now() - externalizeStartedAt
 
-  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 [memoryRetrieval, fabric] = await Promise.all([memoryPromise, fabricPromise])
   const memories = memoryRetrieval.results || []
-  const fabric = await capabilityFabricStatus(root).catch(() => null)
   const providerHints = (fabric?.rows || [])
     .filter((row) => row.selected)
     .slice(0, 12)
@@ -202,6 +209,12 @@ export async function buildAdaptiveTaskContext(root, task, options = {}) {
       entries: externalized.externalized,
     },
     promptEnvelope,
+    performance: {
+      parallelContextPreparation: true,
+      manifestMs,
+      externalizeMs,
+      totalMs: Date.now() - contextBuildStartedAt,
+    },
     promptCache: {
       stablePrefixHash: promptEnvelope.stablePrefixHash,
       dynamicHash: promptEnvelope.dynamicHash,

package/lib/execution-contract.mjs

@@ -174,26 +174,39 @@ export function detectInheritedDirtyViolations(root, snapshot, approvedPaths = [
   }
 }
 
-export function captureInheritedDirtyState(root) {
+export function captureInheritedDirtyState(root, options = {}) {
   const resolved = path.resolve(root)
-  const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
-    cwd: resolved,
-    encoding: "utf8",
-    maxBuffer: 16 * 1024 * 1024,
-  })
-  if (probe.status !== 0) {
-    return {
-      schemaVersion: 1,
-      available: false,
-      clean: false,
-      root: resolved,
-      entries: [],
-      paths: [],
-      error: String(probe.stderr || probe.stdout || "git status failed").trim(),
+  let statusOutput = ""
+  const workspaceState = options.workspaceState || null
+  if (
+    workspaceState &&
+    typeof workspaceState === "object" &&
+    workspaceState.root &&
+    path.resolve(workspaceState.root) === resolved &&
+    typeof workspaceState.statusOutput === "string"
+  ) {
+    statusOutput = workspaceState.statusOutput
+  } else {
+    const probe = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+      cwd: resolved,
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+    })
+    if (probe.status !== 0) {
+      return {
+        schemaVersion: 1,
+        available: false,
+        clean: false,
+        root: resolved,
+        entries: [],
+        paths: [],
+        error: String(probe.stderr || probe.stdout || "git status failed").trim(),
+      }
     }
+    statusOutput = String(probe.stdout || "")
   }
 
-  const tokens = String(probe.stdout || "").split("\0").filter(Boolean)
+  const tokens = statusOutput.split("\0").filter(Boolean)
   const entries = []
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index]

package/lib/memory-engine.mjs

@@ -4,6 +4,7 @@ import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { evidenceExists, putEvidence } from "./evidence-store.mjs"
+import { buildRepoGraphCached } from "./repo-graph.mjs"
 
 const MEMORY_DIR = ".ues-memory"
 const MEMORY_FILE = "MEMORY.json"
@@ -44,15 +45,35 @@ function normalizedContent(value) {
   return String(value || "").trim().replace(/\s+/g, " ")
 }
 
+function scopedIdentityFiles(scope, files = []) {
+  if (!["file", "module"].includes(String(scope || ""))) return []
+  return uniq((files || []).map(normalizeFile)).sort()
+}
+
 function idFor(input) {
+  const scope = input.scope || "project"
+  const scopedFiles = scopedIdentityFiles(scope, input.files)
   const key = input.key || [
-    input.scope || "project",
+    scope,
     input.type || "episodic",
+    scopedFiles.length ? scopedFiles.join(",") : "",
     normalizedContent(input.content),
   ].join(":")
   return createHash("sha256").update(String(key)).digest("hex").slice(0, 20)
 }
 
+function sameMemoryIdentity(item, input) {
+  if (!item) return false
+  if (String(item.scope || "project") !== String(input.scope || "project")) return false
+  if (String(item.type || "episodic") !== String(input.type || "episodic")) return false
+  if (normalizedContent(item.content) !== normalizedContent(input.content)) return false
+  const expectedFiles = scopedIdentityFiles(input.scope, input.files)
+  if (!expectedFiles.length) return true
+  const actualFiles = scopedIdentityFiles(item.scope, item.files)
+  return actualFiles.length === expectedFiles.length &&
+    actualFiles.every((file, index) => file === expectedFiles[index])
+}
+
 function memoryPath(root) {
   return path.join(path.resolve(root), MEMORY_DIR, MEMORY_FILE)
 }
@@ -100,7 +121,8 @@ export async function proposeMemory(root, input = {}) {
   const state = await readMemoryState(root)
   const id = idFor({ ...input, type, scope, content })
   const timestamp = now()
-  const existing = state.memories.find((item) => item.id === id)
+  const existing = state.memories.find((item) => item.id === id) ||
+    state.memories.find((item) => sameMemoryIdentity(item, { ...input, type, scope, content }))
   if (existing) {
     const reinforced = {
       ...existing,
@@ -108,6 +130,7 @@ export async function proposeMemory(root, input = {}) {
       reinforcementCount: Number(existing.reinforcementCount || 1) + 1,
       evidenceRefs: uniq([...(existing.evidenceRefs || []), ...(input.evidenceRefs || [])]),
       files: uniq([...(existing.files || []), ...(input.files || []).map(normalizeFile)]),
+      dependencies: uniq([...(existing.dependencies || []), ...(input.dependencies || []).map(normalizeFile)]),
       tags: uniq([...(existing.tags || []), ...(input.tags || [])]),
       confidence: Math.max(clamp(existing.confidence), clamp(input.confidence, existing.confidence ?? 0.7)),
       taskClass: input.taskClass || existing.taskClass || null,
@@ -127,6 +150,7 @@ export async function proposeMemory(root, input = {}) {
     confidence: clamp(input.confidence),
     evidenceRefs: uniq(input.evidenceRefs || []),
     files: uniq((input.files || []).map(normalizeFile)),
+    dependencies: uniq((input.dependencies || []).map(normalizeFile)),
     tags: uniq(input.tags || []),
     sourceTask: input.sourceTask || null,
     sourceCommit: input.sourceCommit || null,
@@ -312,6 +336,7 @@ export function buildMemorySnapshot(memories = []) {
       content: normalizedContent(item.content),
       confidence: clamp(item.confidence),
       files: uniq((item.files || []).map(normalizeFile)).sort(),
+      dependencies: uniq((item.dependencies || []).map(normalizeFile)).sort(),
       taskClass: item.taskClass || null,
       verifiedAt: item.verifiedAt || null,
       evidenceRefs: uniq(item.evidenceRefs || []).sort(),
@@ -330,6 +355,96 @@ export function buildMemorySnapshot(memories = []) {
   }
 }
 
+function dependencyAdjacency(edges = []) {
+  const graph = new Map()
+  const connect = (left, right) => {
+    if (!left || !right) return
+    if (!graph.has(left)) graph.set(left, new Set())
+    graph.get(left).add(right)
+  }
+  for (const edge of edges || []) {
+    const from = normalizeFile(edge?.from)
+    const to = normalizeFile(edge?.to)
+    if (!from || !to) continue
+    // Retrieval uses dependency proximity, not ownership direction, so both
+    // importers and imported modules are useful neighbors.
+    connect(from, to)
+    connect(to, from)
+  }
+  return graph
+}
+
+function dependencyGraphAffinity(queryFiles, memoryFiles, adjacency, maxDepth = 3) {
+  if (!queryFiles.length || !memoryFiles.length || !adjacency?.size) return 0
+  const targets = new Set(memoryFiles.map(normalizeFile))
+  let best = 0
+  for (const source of queryFiles.map(normalizeFile)) {
+    if (targets.has(source)) return 1
+    let frontier = new Set([source])
+    const seen = new Set(frontier)
+    for (let depth = 1; depth <= maxDepth && frontier.size; depth += 1) {
+      const next = new Set()
+      for (const current of frontier) {
+        for (const neighbor of adjacency.get(current) || []) {
+          if (targets.has(neighbor)) {
+            const score = depth === 1 ? 0.95 : depth === 2 ? 0.7 : 0.45
+            best = Math.max(best, score)
+          }
+          if (!seen.has(neighbor)) {
+            seen.add(neighbor)
+            next.add(neighbor)
+          }
+        }
+      }
+      frontier = next
+    }
+  }
+  return best
+}
+
+function exactFileAffinity(queryFiles, memoryFiles) {
+  const wanted = new Set(queryFiles.map(normalizeFile))
+  return memoryFiles.some((file) => wanted.has(normalizeFile(file))) ? 1 : 0
+}
+
+function scopeEligible(item, queryFiles, pathGraph) {
+  if (!queryFiles.length) return true
+  const memoryFiles = uniq((item.files || []).map(normalizeFile))
+  if (item.scope === "file") return exactFileAffinity(queryFiles, memoryFiles) === 1
+  if (item.scope === "module") return pathGraph >= 0.45
+  return true
+}
+
+function memoryAgeDays(item) {
+  const timestamp = Date.parse(item.lastSeenAt || item.verifiedAt || item.createdAt || "")
+  if (!timestamp) return 0
+  return Math.max(0, (Date.now() - timestamp) / 86_400_000)
+}
+
+function memoryHalfLifeDays(item) {
+  const base = {
+    failure: 45,
+    episodic: 75,
+    decision: 120,
+    procedural: 180,
+    semantic: 240,
+  }[item.type] || 120
+  const reinforcement = Math.max(1, Number(item.reinforcementCount || 1))
+  return base * (1 + Math.log2(reinforcement) * 0.2)
+}
+
+function agingScore(item) {
+  const age = memoryAgeDays(item)
+  const halfLife = memoryHalfLifeDays(item)
+  return Math.pow(0.5, age / Math.max(1, halfLife))
+}
+
+function reinforcementScore(item) {
+  const reinforcement = Math.max(0, Number(item.reinforcementCount || 0))
+  const use = Math.max(0, Number(item.useCount || 0))
+  return Math.min(1, (Math.log1p(reinforcement) + 0.55 * Math.log1p(use)) / 4)
+}
+
 export async function retrieveMemories(root, query, options = {}) {
   const state = await readMemoryState(root)
   const memories = state.memories.filter((item) => item.status === "verified" && !item.supersededBy && !isExpired(item))
@@ -337,47 +452,99 @@ export async function retrieveMemories(root, query, options = {}) {
   const queryVector = tokenVector(query)
   const queryFiles = uniq((options.files || []).map(normalizeFile))
   const lexical = bm25Scores(memories, queryTokens)
-  const rows = memories.map((item, index) => ({
-    item,
-    lexical: lexical[index] || 0,
-    semantic: Math.max(0, cosine(queryVector, tokenVector(item.content))),
-    graph: graphAffinity(queryFiles, item.files || []),
-    taskClass: taskClassAffinity(options.taskClass, item.taskClass),
-    recency: recencyScore(item.lastUsedAt || item.lastSeenAt || item.verifiedAt || item.createdAt),
-    confidence: clamp(item.confidence),
-    scope: 0,
-  }))
-  for (const row of rows) row.scope = scopeAffinity(row.item.scope, row.graph)
+
+  let repoGraph = null
+  if (queryFiles.length && memories.length && options.dependencyGraph !== false) {
+    repoGraph = await buildRepoGraphCached(root, {
+      maxFiles: Math.max(100, Math.min(6000, Number(options.maxGraphFiles || 2500))),
+      ...(options.workspaceFingerprint ? { workspaceFingerprint: options.workspaceFingerprint } : {}),
+    }).catch(() => null)
+  }
+  const adjacency = dependencyAdjacency(repoGraph?.edges || [])
+
+  const rows = memories.map((item, index) => {
+    const memoryFiles = uniq((item.files || []).map(normalizeFile))
+    const pathGraph = graphAffinity(queryFiles, memoryFiles)
+    const dependency = dependencyGraphAffinity(
+      queryFiles,
+      uniq([...memoryFiles, ...(item.dependencies || []).map(normalizeFile)]),
+      adjacency,
+    )
+    const graph = Math.max(pathGraph, dependency)
+    const aging = agingScore(item)
+    const reinforcement = reinforcementScore(item)
+    return {
+      item,
+      lexical: lexical[index] || 0,
+      semantic: Math.max(0, cosine(queryVector, tokenVector([item.content, ...(item.tags || []), ...memoryFiles].join(" ")))),
+      graph,
+      pathGraph,
+      dependency,
+      taskClass: taskClassAffinity(options.taskClass, item.taskClass),
+      recency: recencyScore(item.lastUsedAt || item.lastSeenAt || item.verifiedAt || item.createdAt),
+      aging,
+      reinforcement,
+      confidence: clamp(item.confidence) * (0.65 + 0.35 * aging),
+      scope: 0,
+      scopeEligible: true,
+    }
+  })
+  for (const row of rows) {
+    row.scope = scopeAffinity(row.item.scope, row.pathGraph)
+    row.scopeEligible = options.strictScope === false
+      ? true
+      : scopeEligible(row.item, queryFiles, row.pathGraph)
+  }
   const ranks = {
     lexical: rankMap(rows, "lexical"),
     semantic: rankMap(rows, "semantic"),
     graph: rankMap(rows, "graph"),
+    dependency: rankMap(rows, "dependency"),
     taskClass: rankMap(rows, "taskClass"),
     recency: rankMap(rows, "recency"),
+    aging: rankMap(rows, "aging"),
+    reinforcement: rankMap(rows, "reinforcement"),
   }
   for (const row of rows) {
     let rrf = 0
-    for (const key of ["lexical", "semantic", "graph", "taskClass", "recency"]) {
+    for (const key of ["lexical", "semantic", "graph", "dependency", "taskClass", "recency", "aging", "reinforcement"]) {
       const rank = ranks[key].get(row.item.id)
       if (rank) rrf += 1 / (60 + rank)
     }
-    row.score = rrf + row.confidence * 0.01 + row.graph * 0.01 + row.scope * 0.006 + row.taskClass * 0.008
+    row.score =
+      rrf +
+      row.confidence * 0.01 +
+      row.graph * 0.01 +
+      row.dependency * 0.012 +
+      row.scope * 0.006 +
+      row.taskClass * 0.008 +
+      row.reinforcement * 0.006 +
+      row.aging * 0.004
   }
   const limit = Math.max(1, Math.min(Number(options.limit || 6), 30))
   const results = rows
-    .filter((row) => row.lexical > 0 || row.semantic > 0.05 || row.graph > 0)
+    .filter((row) =>
+      row.scopeEligible &&
+      (row.lexical > 0 || row.semantic > 0.05 || row.graph > 0 || row.dependency > 0)
+    )
     .sort((a, b) => b.score - a.score || b.confidence - a.confidence || a.item.id.localeCompare(b.item.id))
     .slice(0, limit)
     .map((row) => ({
       ...row.item,
       retrieval: {
+        version: 2,
         score: Number(row.score.toFixed(8)),
         lexical: Number(row.lexical.toFixed(6)),
         semantic: Number(row.semantic.toFixed(6)),
         graph: Number(row.graph.toFixed(6)),
+        pathGraph: Number(row.pathGraph.toFixed(6)),
+        dependency: Number(row.dependency.toFixed(6)),
         taskClass: Number(row.taskClass.toFixed(6)),
         scope: Number(row.scope.toFixed(6)),
         recency: Number(row.recency.toFixed(6)),
+        aging: Number(row.aging.toFixed(6)),
+        reinforcement: Number(row.reinforcement.toFixed(6)),
+        effectiveConfidence: Number(row.confidence.toFixed(6)),
       },
     }))
   if (options.touch === true && results.length) {
@@ -389,8 +556,14 @@ export async function retrieveMemories(root, query, options = {}) {
   }
   return {
     schemaVersion: SCHEMA_VERSION,
+    retrievalVersion: 2,
     query: String(query || ""),
     eligible: memories.length,
+    dependencyGraph: repoGraph ? {
+      scannedFiles: repoGraph.scannedFiles || 0,
+      edgeCount: Array.isArray(repoGraph.edges) ? repoGraph.edges.length : 0,
+      truncated: repoGraph.truncated === true,
+    } : null,
     results,
     snapshot: buildMemorySnapshot(results),
   }