@try-works/dsh-memory 0.1.18 → 0.1.20

package/src/entry.js

@@ -1,179 +1,179 @@
-// Entry format (Format 2), parsing, and id allocation. Pure (no fs) — unit-testable.
-export const LAYER_CODES = { semantic: 'sem', episodic: 'epi', procedural: 'pro', learning: 'learning', codebase: 'code', history: 'hist', decision: 'dec' }
-export const LAYER_FILES = { semantic: 'semantic.md', episodic: 'episodic.md', procedural: 'procedural.md', learning: 'learnings.md', codebase: 'codebase.md', history: 'history.md', decision: 'decisions.md' }
-export const LAYERS = Object.keys(LAYER_CODES)
-
-/** Sub-directory holding the per-topic files for each layered kind. */
-export const LAYER_DIRS = { semantic: 'semantic', episodic: 'episodic', procedural: 'procedural', learning: 'learnings', codebase: 'codebase', history: 'history', decision: 'decisions' }
-
-/** Layered kinds, in a stable order. */
-export const LAYERED = Object.keys(LAYER_DIRS)
-
-/**
- * Kinds that only make sense inside a repository. The codebase map describes ONE repo, so a
- * global map would mix unrelated projects together - the same reason working memory is
- * per-workspace.
- */
-export const WORKSPACE_ONLY_LAYERS = ['codebase', 'history']
-
-/** Layered kinds available in a scope. */
-export const GLOBAL_LAYERED = LAYERED.filter((layer) => !WORKSPACE_ONLY_LAYERS.includes(layer))
-
-/** The layered kinds that exist in a given scope. */
-export function layersForScope(scope) { return scope === 'global' ? GLOBAL_LAYERED : LAYERED }
-
-/** True when this kind may only be written to a workspace. */
-export function isWorkspaceOnly(layer) { return WORKSPACE_ONLY_LAYERS.includes(layer) }
-
-/**
- * How fast an entry's content decays. This is a property OF THE ENTRY, not a global setting:
- * a language choice stays true for years, a port number can change tomorrow, and only the
- * writer knows which it is. Freshness thresholds are derived from this rather than assumed.
- */
-export const VOLATILITY = { stable: 'stable', normal: 'normal', volatile: 'volatile' }
-
-/** Days after which an entry of each volatility is worth re-checking. */
-export const VOLATILITY_DAYS = { stable: 365, normal: 30, volatile: 3 }
-
-/** Valid volatility values, in increasing decay order. */
-export const VOLATILITIES = Object.keys(VOLATILITY_DAYS)
-
-/** Coerce a volatility to a known value; unknown or absent becomes normal. */
-export function normalizeVolatility(value) {
-  const text = String(value ?? '').trim().toLowerCase()
-  return Object.hasOwn(VOLATILITY_DAYS, text) ? text : VOLATILITY.normal
-}
-
-/** Scope id embedded in an entry Id: 'global' or the workspace key. */
-export function scopeIdFor(scope, key) {
-  return scope === 'global' ? 'global' : (key ?? 'global')
-}
-
-export function nowIso() { return new Date().toISOString() }
-
-/**
- * Allocate the next NNNN for a (scopeId, layer) pair by scanning existing **Id:** lines.
- * scopeId + layer are already slug-safe (alnum + hyphen), so no regex escaping is needed.
- */
-export function allocateId(text, scopeId, layer) {
-  const code = LAYER_CODES[layer] ?? layer
-  const re = new RegExp('\\*\\*Id:\\*\\*\\s*' + scopeId + '-' + code + '-(\\d+)', 'g')
-  let max = 0
-  let m
-  while ((m = re.exec(text)) !== null) max = Math.max(max, Number(m[1]))
-  return scopeId + '-' + code + '-' + String(max + 1).padStart(4, '0')
-}
-
-/** Build the metadata block for a new entry (one field per line; no heading — the writer adds it). */
-export function formatEntry({ id, source, date, importance = 2, status = 'active', until, volatility, verified, content }) {
-  const lines = [
-    '**Id:** ' + id,
-    '**Source:** ' + source,
-    '**Date:** ' + date,
-    '**Updated:** ' + date,
-    '**Importance:** ' + importance,
-    '**Status:** ' + status,
-  ]
-  // Self-describing freshness: the entry states how fast it decays and when it was last
-  // confirmed true, so staleness is determinable from the file alone - no external clock,
-  // no global assumption, and after a clone the metadata travels with the text.
-  if (volatility) lines.push('**Volatility:** ' + normalizeVolatility(volatility))
-  if (verified) lines.push('**Verified:** ' + verified)
-  if (until) lines.push('**Valid-until:** ' + until)
-  lines.push('**Format:** 2')
-  return lines.join('\n') + '\n\n' + content
-}
-
-/**
- * Parse a layer file into entries: each '## heading' starts an entry, following
- * '**Key:** value' lines populate its metadata and the rest is the body. Returns
- * entries with stable line ranges (for ledger -> line-span mapping) and body content
- * (for freshness time-bounded detection and the context card).
- */
-export function parseEntries(text) {
-  const entries = []
-  const lines = String(text).split('\n')
-  let current = null
-  const push = () => { if (current) { current.endLine = current.lastLine ?? current.startLine; entries.push(current) } }
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const h = line.match(/^##\s+(.+)$/)
-    if (h) { push(); current = { heading: h[1].trim(), startLine: i + 1, endLine: undefined, lastLine: i + 1, meta: {}, body: [] }; continue }
-    if (!current) continue
-    current.lastLine = i + 1
-    const m = line.match(/^\*\*([A-Za-z-]+):\*\*\s*(.*)$/)
-    if (m) current.meta[m[1]] = m[2].trim()
-    else current.body.push(line)
-  }
-  push()
-  return entries
-    .filter((e) => e.meta['Id'])
-    .map((e) => ({
-      id: e.meta['Id'],
-      heading: e.heading,
-      importance: e.meta['Importance'] ? Number(e.meta['Importance']) : 2,
-      status: e.meta['Status'] ?? 'active',
-      date: e.meta['Date'],
-      updated: e.meta['Updated'] ?? e.meta['Date'],
-      until: e.meta['Valid-until'],
-      volatility: e.meta['Volatility'] ? normalizeVolatility(e.meta['Volatility']) : undefined,
-      verified: e.meta['Verified'],
-      source: e.meta['Source'],
-      content: e.body.join('\n').trim(),
-      startLine: e.startLine,
-      endLine: e.endLine,
-    }))
-}
-
-/**
- * Flip an entry's Status (and optionally add a SupersededBy pointer) in place.
- * Pure: returns the new file text; used by forget.
- */
-export function setEntryStatus(text, id, status, supersededBy) {
-  const lines = String(text).split('\n')
-  const idIdx = lines.findIndex((l) => l.includes('**Id:** ' + id))
-  if (idIdx < 0) return String(text)
-  let end = lines.length
-  for (let i = idIdx + 1; i < lines.length; i++) { if (/^##\s+/.test(lines[i])) { end = i; break } }
-  for (let i = idIdx; i < end; i++) {
-    if (/^\*\*Status:\*\*/.test(lines[i])) {
-      lines[i] = '**Status:** ' + status
-      if (supersededBy) lines.splice(i + 1, 0, '**SupersededBy:** ' + supersededBy)
-      break
-    }
-  }
-  return lines.join('\n')
-}
-
-/**
- * Replace an entry's body (below the metadata block) and bump its Updated stamp.
- * Pure: returns the new file text; used by the refresh pass.
- */
-export function setEntryBody(text, id, newBody) {
-  const lines = String(text).split('\n')
-  const idIdx = lines.findIndex((l) => l.includes('**Id:** ' + id))
-  if (idIdx < 0) return String(text)
-  let end = lines.length
-  for (let i = idIdx + 1; i < lines.length; i++) { if (/^##\s+/.test(lines[i])) { end = i; break } }
-  // A refresh rewrites the body because the fact was RE-CONFIRMED, so it must reset the
-  // freshness clock too. Verified is the age basis, so bumping only Updated would leave a
-  // rewritten entry permanently stale - the refresh pass could never cure anything.
-  const stamp = nowIso()
-  let sawVerified = false
-  for (let i = idIdx; i < end; i++) {
-    if (/^\*\*Updated:\*\*/.test(lines[i])) lines[i] = '**Updated:** ' + stamp
-    else if (/^\*\*Verified:\*\*/.test(lines[i])) { lines[i] = '**Verified:** ' + stamp; sawVerified = true }
-  }
-  if (!sawVerified) {
-    // Entries written before the field existed still need their clock reset.
-    const updatedAt = lines.findIndex((l, i) => i > idIdx && i < end && /^\*\*Updated:\*\*/.test(l))
-    if (updatedAt >= 0) lines.splice(updatedAt + 1, 0, '**Verified:** ' + stamp)
-  }
-  let bodyStart = end
-  for (let i = idIdx; i < end; i++) {
-    if (/^\*\*Format:\*\*/.test(lines[i])) { bodyStart = i + 1; break }
-  }
-  while (bodyStart < end && lines[bodyStart].trim() === '') bodyStart++
-  lines.splice(bodyStart, end - bodyStart, ...String(newBody).split('\n'))
-  return lines.join('\n')
-}
+// Entry format (Format 2), parsing, and id allocation. Pure (no fs) — unit-testable.
+export const LAYER_CODES = { semantic: 'sem', episodic: 'epi', procedural: 'pro', learning: 'learning', codebase: 'code', history: 'hist', decision: 'dec' }
+export const LAYER_FILES = { semantic: 'semantic.md', episodic: 'episodic.md', procedural: 'procedural.md', learning: 'learnings.md', codebase: 'codebase.md', history: 'history.md', decision: 'decisions.md' }
+export const LAYERS = Object.keys(LAYER_CODES)
+
+/** Sub-directory holding the per-topic files for each layered kind. */
+export const LAYER_DIRS = { semantic: 'semantic', episodic: 'episodic', procedural: 'procedural', learning: 'learnings', codebase: 'codebase', history: 'history', decision: 'decisions' }
+
+/** Layered kinds, in a stable order. */
+export const LAYERED = Object.keys(LAYER_DIRS)
+
+/**
+ * Kinds that only make sense inside a repository. The codebase map describes ONE repo, so a
+ * global map would mix unrelated projects together - the same reason working memory is
+ * per-workspace.
+ */
+export const WORKSPACE_ONLY_LAYERS = ['codebase', 'history']
+
+/** Layered kinds available in a scope. */
+export const GLOBAL_LAYERED = LAYERED.filter((layer) => !WORKSPACE_ONLY_LAYERS.includes(layer))
+
+/** The layered kinds that exist in a given scope. */
+export function layersForScope(scope) { return scope === 'global' ? GLOBAL_LAYERED : LAYERED }
+
+/** True when this kind may only be written to a workspace. */
+export function isWorkspaceOnly(layer) { return WORKSPACE_ONLY_LAYERS.includes(layer) }
+
+/**
+ * How fast an entry's content decays. This is a property OF THE ENTRY, not a global setting:
+ * a language choice stays true for years, a port number can change tomorrow, and only the
+ * writer knows which it is. Freshness thresholds are derived from this rather than assumed.
+ */
+export const VOLATILITY = { stable: 'stable', normal: 'normal', volatile: 'volatile' }
+
+/** Days after which an entry of each volatility is worth re-checking. */
+export const VOLATILITY_DAYS = { stable: 365, normal: 30, volatile: 3 }
+
+/** Valid volatility values, in increasing decay order. */
+export const VOLATILITIES = Object.keys(VOLATILITY_DAYS)
+
+/** Coerce a volatility to a known value; unknown or absent becomes normal. */
+export function normalizeVolatility(value) {
+  const text = String(value ?? '').trim().toLowerCase()
+  return Object.hasOwn(VOLATILITY_DAYS, text) ? text : VOLATILITY.normal
+}
+
+/** Scope id embedded in an entry Id: 'global' or the workspace key. */
+export function scopeIdFor(scope, key) {
+  return scope === 'global' ? 'global' : (key ?? 'global')
+}
+
+export function nowIso() { return new Date().toISOString() }
+
+/**
+ * Allocate the next NNNN for a (scopeId, layer) pair by scanning existing **Id:** lines.
+ * scopeId + layer are already slug-safe (alnum + hyphen), so no regex escaping is needed.
+ */
+export function allocateId(text, scopeId, layer) {
+  const code = LAYER_CODES[layer] ?? layer
+  const re = new RegExp('\\*\\*Id:\\*\\*\\s*' + scopeId + '-' + code + '-(\\d+)', 'g')
+  let max = 0
+  let m
+  while ((m = re.exec(text)) !== null) max = Math.max(max, Number(m[1]))
+  return scopeId + '-' + code + '-' + String(max + 1).padStart(4, '0')
+}
+
+/** Build the metadata block for a new entry (one field per line; no heading — the writer adds it). */
+export function formatEntry({ id, source, date, importance = 2, status = 'active', until, volatility, verified, content }) {
+  const lines = [
+    '**Id:** ' + id,
+    '**Source:** ' + source,
+    '**Date:** ' + date,
+    '**Updated:** ' + date,
+    '**Importance:** ' + importance,
+    '**Status:** ' + status,
+  ]
+  // Self-describing freshness: the entry states how fast it decays and when it was last
+  // confirmed true, so staleness is determinable from the file alone - no external clock,
+  // no global assumption, and after a clone the metadata travels with the text.
+  if (volatility) lines.push('**Volatility:** ' + normalizeVolatility(volatility))
+  if (verified) lines.push('**Verified:** ' + verified)
+  if (until) lines.push('**Valid-until:** ' + until)
+  lines.push('**Format:** 2')
+  return lines.join('\n') + '\n\n' + content
+}
+
+/**
+ * Parse a layer file into entries: each '## heading' starts an entry, following
+ * '**Key:** value' lines populate its metadata and the rest is the body. Returns
+ * entries with stable line ranges (for ledger -> line-span mapping) and body content
+ * (for freshness time-bounded detection and the context card).
+ */
+export function parseEntries(text) {
+  const entries = []
+  const lines = String(text).split('\n')
+  let current = null
+  const push = () => { if (current) { current.endLine = current.lastLine ?? current.startLine; entries.push(current) } }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const h = line.match(/^##\s+(.+)$/)
+    if (h) { push(); current = { heading: h[1].trim(), startLine: i + 1, endLine: undefined, lastLine: i + 1, meta: {}, body: [] }; continue }
+    if (!current) continue
+    current.lastLine = i + 1
+    const m = line.match(/^\*\*([A-Za-z-]+):\*\*\s*(.*)$/)
+    if (m) current.meta[m[1]] = m[2].trim()
+    else current.body.push(line)
+  }
+  push()
+  return entries
+    .filter((e) => e.meta['Id'])
+    .map((e) => ({
+      id: e.meta['Id'],
+      heading: e.heading,
+      importance: e.meta['Importance'] ? Number(e.meta['Importance']) : 2,
+      status: e.meta['Status'] ?? 'active',
+      date: e.meta['Date'],
+      updated: e.meta['Updated'] ?? e.meta['Date'],
+      until: e.meta['Valid-until'],
+      volatility: e.meta['Volatility'] ? normalizeVolatility(e.meta['Volatility']) : undefined,
+      verified: e.meta['Verified'],
+      source: e.meta['Source'],
+      content: e.body.join('\n').trim(),
+      startLine: e.startLine,
+      endLine: e.endLine,
+    }))
+}
+
+/**
+ * Flip an entry's Status (and optionally add a SupersededBy pointer) in place.
+ * Pure: returns the new file text; used by forget.
+ */
+export function setEntryStatus(text, id, status, supersededBy) {
+  const lines = String(text).split('\n')
+  const idIdx = lines.findIndex((l) => l.includes('**Id:** ' + id))
+  if (idIdx < 0) return String(text)
+  let end = lines.length
+  for (let i = idIdx + 1; i < lines.length; i++) { if (/^##\s+/.test(lines[i])) { end = i; break } }
+  for (let i = idIdx; i < end; i++) {
+    if (/^\*\*Status:\*\*/.test(lines[i])) {
+      lines[i] = '**Status:** ' + status
+      if (supersededBy) lines.splice(i + 1, 0, '**SupersededBy:** ' + supersededBy)
+      break
+    }
+  }
+  return lines.join('\n')
+}
+
+/**
+ * Replace an entry's body (below the metadata block) and bump its Updated stamp.
+ * Pure: returns the new file text; used by the refresh pass.
+ */
+export function setEntryBody(text, id, newBody) {
+  const lines = String(text).split('\n')
+  const idIdx = lines.findIndex((l) => l.includes('**Id:** ' + id))
+  if (idIdx < 0) return String(text)
+  let end = lines.length
+  for (let i = idIdx + 1; i < lines.length; i++) { if (/^##\s+/.test(lines[i])) { end = i; break } }
+  // A refresh rewrites the body because the fact was RE-CONFIRMED, so it must reset the
+  // freshness clock too. Verified is the age basis, so bumping only Updated would leave a
+  // rewritten entry permanently stale - the refresh pass could never cure anything.
+  const stamp = nowIso()
+  let sawVerified = false
+  for (let i = idIdx; i < end; i++) {
+    if (/^\*\*Updated:\*\*/.test(lines[i])) lines[i] = '**Updated:** ' + stamp
+    else if (/^\*\*Verified:\*\*/.test(lines[i])) { lines[i] = '**Verified:** ' + stamp; sawVerified = true }
+  }
+  if (!sawVerified) {
+    // Entries written before the field existed still need their clock reset.
+    const updatedAt = lines.findIndex((l, i) => i > idIdx && i < end && /^\*\*Updated:\*\*/.test(l))
+    if (updatedAt >= 0) lines.splice(updatedAt + 1, 0, '**Verified:** ' + stamp)
+  }
+  let bodyStart = end
+  for (let i = idIdx; i < end; i++) {
+    if (/^\*\*Format:\*\*/.test(lines[i])) { bodyStart = i + 1; break }
+  }
+  while (bodyStart < end && lines[bodyStart].trim() === '') bodyStart++
+  lines.splice(bodyStart, end - bodyStart, ...String(newBody).split('\n'))
+  return lines.join('\n')
+}

package/src/eval.js

@@ -1,72 +1,72 @@
-// Sufficiency eval + validation: search probes (fact recall), a judge layer
-// (answerability from retrieved context), and deterministic anchor checks.
-import { readFileSync } from 'node:fs'
-import { indexedFiles } from './files.js'
-import { search } from './search.js'
-
-export function runProbe(store, probe) {
-  const hits = search(store, probe.question, { limit: probe.limit ?? 10, scope: probe.scope, key: probe.key })
-  const required = probe.requiredFacts ?? []
-  let found = 0
-  const missing = []
-  for (const f of required) {
-    const ok = hits.some((h) => (f.id && h.id === f.id) || (f.file && h.file === f.file))
-    if (ok) found++
-    else missing.push(f.id ?? f.file)
-  }
-  const recall = required.length ? found / required.length : 1
-  return { id: probe.id, found, required: required.length, recall, sufficient: recall >= 1, missing }
-}
-
-export function evalProbes(store, probes) {
-  const results = probes.map((p) => runProbe(store, p))
-  const factRecall = results.length ? results.reduce((a, r) => a + r.recall, 0) / results.length : 1
-  const sufficient = results.filter((r) => r.sufficient).length
-  return { factRecall, sufficient, total: results.length, results }
-}
-
-const ANCHOR_PATTERNS = [
-  /\b[a-z]+-[a-z]{2,8}-\d{2,4}\b/gi,           // entry ids: global-sem-0001
-  /\b\d{6}_[a-z0-9_]+\b/gi,                     // experiment ids: 123456_abc
-  /\b[a-z_][\w]*\.[a-z_][\w]*\b/gi,             // qualified names: table.column
-  /\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2})?)?\b/g, // ISO dates
-  /\bhttps?:\/\/[^\s]+\b/gi,                    // URLs
-  /\b\d+(?:\.\d+)?\s*(?:GB|MB|KB|TB|ms|s|%)\b/gi, // numbers with units
-]
-
-/** Extract stable, greppable anchors from free text (for validated consolidation). */
-export function extractAnchors(text) {
-  const set = new Set()
-  for (const re of ANCHOR_PATTERNS) {
-    for (const m of String(text ?? '').matchAll(re)) set.add(m[0])
-  }
-  return [...set]
-}
-
-/** Which anchors are present (vs missing) in the committed layer files. */
-export function checkAnchors(anchors, store) {
-  const all = indexedFiles(store.root).map((f) => readFileSync(f, 'utf8')).join('\n')
-  const found = []
-  const missing = []
-  for (const a of anchors) (all.includes(a) ? found : missing).push(a)
-  return { found, missing }
-}
-
-/**
- * Judge layer: for each probe, retrieve the top-k context, then ask a judge LLM
- * whether the question is answerable from that context alone. Sufficiency = the
- * share of probes the judge deems answerable (not just a single hit landing).
- */
-export async function judgeSufficiency(store, probes, llm) {
-  const verdicts = []
-  for (const probe of probes) {
-    const hits = search(store, probe.question, { limit: 8, scope: probe.scope, key: probe.key })
-    const context = hits.map((h) => h.file + ':' + h.line + ' ' + h.snippet).join('\n')
-    const prompt = 'Question: ' + probe.question + '\n\nRetrieved context:\n' + (context || '(none)')
-      + '\n\nUsing ONLY the retrieved context, can you answer the question? Reply exactly "yes" or "no".'
-    const answer = String(await llm(prompt)).trim().toLowerCase()
-    verdicts.push({ id: probe.id, answerable: answer.startsWith('yes') })
-  }
-  const sufficiency = verdicts.length ? verdicts.filter((v) => v.answerable).length / verdicts.length : 1
-  return { sufficiency, verdicts }
-}
+// Sufficiency eval + validation: search probes (fact recall), a judge layer
+// (answerability from retrieved context), and deterministic anchor checks.
+import { readFileSync } from 'node:fs'
+import { indexedFiles } from './files.js'
+import { search } from './search.js'
+
+export function runProbe(store, probe) {
+  const hits = search(store, probe.question, { limit: probe.limit ?? 10, scope: probe.scope, key: probe.key })
+  const required = probe.requiredFacts ?? []
+  let found = 0
+  const missing = []
+  for (const f of required) {
+    const ok = hits.some((h) => (f.id && h.id === f.id) || (f.file && h.file === f.file))
+    if (ok) found++
+    else missing.push(f.id ?? f.file)
+  }
+  const recall = required.length ? found / required.length : 1
+  return { id: probe.id, found, required: required.length, recall, sufficient: recall >= 1, missing }
+}
+
+export function evalProbes(store, probes) {
+  const results = probes.map((p) => runProbe(store, p))
+  const factRecall = results.length ? results.reduce((a, r) => a + r.recall, 0) / results.length : 1
+  const sufficient = results.filter((r) => r.sufficient).length
+  return { factRecall, sufficient, total: results.length, results }
+}
+
+const ANCHOR_PATTERNS = [
+  /\b[a-z]+-[a-z]{2,8}-\d{2,4}\b/gi,           // entry ids: global-sem-0001
+  /\b\d{6}_[a-z0-9_]+\b/gi,                     // experiment ids: 123456_abc
+  /\b[a-z_][\w]*\.[a-z_][\w]*\b/gi,             // qualified names: table.column
+  /\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2})?)?\b/g, // ISO dates
+  /\bhttps?:\/\/[^\s]+\b/gi,                    // URLs
+  /\b\d+(?:\.\d+)?\s*(?:GB|MB|KB|TB|ms|s|%)\b/gi, // numbers with units
+]
+
+/** Extract stable, greppable anchors from free text (for validated consolidation). */
+export function extractAnchors(text) {
+  const set = new Set()
+  for (const re of ANCHOR_PATTERNS) {
+    for (const m of String(text ?? '').matchAll(re)) set.add(m[0])
+  }
+  return [...set]
+}
+
+/** Which anchors are present (vs missing) in the committed layer files. */
+export function checkAnchors(anchors, store) {
+  const all = indexedFiles(store.root).map((f) => readFileSync(f, 'utf8')).join('\n')
+  const found = []
+  const missing = []
+  for (const a of anchors) (all.includes(a) ? found : missing).push(a)
+  return { found, missing }
+}
+
+/**
+ * Judge layer: for each probe, retrieve the top-k context, then ask a judge LLM
+ * whether the question is answerable from that context alone. Sufficiency = the
+ * share of probes the judge deems answerable (not just a single hit landing).
+ */
+export async function judgeSufficiency(store, probes, llm) {
+  const verdicts = []
+  for (const probe of probes) {
+    const hits = search(store, probe.question, { limit: 8, scope: probe.scope, key: probe.key })
+    const context = hits.map((h) => h.file + ':' + h.line + ' ' + h.snippet).join('\n')
+    const prompt = 'Question: ' + probe.question + '\n\nRetrieved context:\n' + (context || '(none)')
+      + '\n\nUsing ONLY the retrieved context, can you answer the question? Reply exactly "yes" or "no".'
+    const answer = String(await llm(prompt)).trim().toLowerCase()
+    verdicts.push({ id: probe.id, answerable: answer.startsWith('yes') })
+  }
+  const sufficiency = verdicts.length ? verdicts.filter((v) => v.answerable).length / verdicts.length : 1
+  return { sufficiency, verdicts }
+}

package/src/files.js

@@ -1,60 +1,60 @@
-// Store file discovery for indexing/ledger. Node built-ins only.
-import { existsSync, readdirSync, statSync } from 'node:fs'
-import { join, relative } from 'node:path'
-import { globalDir, workspacesDir } from './store.js'
-import { LAYER_DIRS, LAYER_FILES } from './entry.js'
-
-// Which files are searchable truth. junk.md (archaeology) and working.md (transient
-// current-state) are deliberately excluded from FTS + the ledger. A layered kind is
-// represented by BOTH its index file and the per-topic files it points at.
-export const INDEXED_FILES = new Set(['INDEX.md', ...Object.values(LAYER_FILES)])
-
-/** Depth cap for discovery: root scope dir -> layer dir -> topic file. */
-const MAX_DEPTH = 4
-
-/** Every markdown file under global/ and the workspace scopes. */
-export function listLayerFiles(root) {
-  const out = []
-  const walk = (dir, depth) => {
-    if (depth > MAX_DEPTH || !existsSync(dir)) return
-    let names = []
-    try { names = readdirSync(dir) } catch { return }
-    for (const name of names) {
-      const full = join(dir, name)
-      let stat
-      try { stat = statSync(full) } catch { continue }
-      if (stat.isDirectory()) walk(full, depth + 1)
-      else if (name.endsWith('.md')) out.push(full)
-    }
-  }
-  walk(globalDir(root), 1)
-  walk(workspacesDir(root), 1)
-  return out.sort()
-}
-
-/**
- * Which layer a file belongs to: its name when it is a layer index, otherwise the layer
- * directory that holds it. Returns undefined for INDEX.md, junk.md, working.md, meta.json.
- */
-export function layerOfFile(root, file) {
-  const rel = relative(root, file).replace(/\\/g, '/')
-  const parts = rel.split('/')
-  const base = parts[parts.length - 1]
-  for (const [layer, name] of Object.entries(LAYER_FILES)) if (base === name) return layer
-  const parent = parts.length >= 2 ? parts[parts.length - 2] : undefined
-  for (const [layer, dir] of Object.entries(LAYER_DIRS)) if (parent === dir) return layer
-  return undefined
-}
-
-/** Files that feed the FTS index and the ledger. */
-export function indexedFiles(root) {
-  return listLayerFiles(root).filter((file) => {
-    const base = file.replace(/\\/g, '/').split('/').pop()
-    return INDEXED_FILES.has(base) || layerOfFile(root, file) !== undefined
-  })
-}
-
-/** The store-level topic map, excluded from entries but kept for navigation. */
-export function isTopicMap(root, file) {
-  return file.replace(/\\/g, '/').split('/').pop() === 'INDEX.md'
-}
+// Store file discovery for indexing/ledger. Node built-ins only.
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import { globalDir, workspacesDir } from './store.js'
+import { LAYER_DIRS, LAYER_FILES } from './entry.js'
+
+// Which files are searchable truth. junk.md (archaeology) and working.md (transient
+// current-state) are deliberately excluded from FTS + the ledger. A layered kind is
+// represented by BOTH its index file and the per-topic files it points at.
+export const INDEXED_FILES = new Set(['INDEX.md', ...Object.values(LAYER_FILES)])
+
+/** Depth cap for discovery: root scope dir -> layer dir -> topic file. */
+const MAX_DEPTH = 4
+
+/** Every markdown file under global/ and the workspace scopes. */
+export function listLayerFiles(root) {
+  const out = []
+  const walk = (dir, depth) => {
+    if (depth > MAX_DEPTH || !existsSync(dir)) return
+    let names = []
+    try { names = readdirSync(dir) } catch { return }
+    for (const name of names) {
+      const full = join(dir, name)
+      let stat
+      try { stat = statSync(full) } catch { continue }
+      if (stat.isDirectory()) walk(full, depth + 1)
+      else if (name.endsWith('.md')) out.push(full)
+    }
+  }
+  walk(globalDir(root), 1)
+  walk(workspacesDir(root), 1)
+  return out.sort()
+}
+
+/**
+ * Which layer a file belongs to: its name when it is a layer index, otherwise the layer
+ * directory that holds it. Returns undefined for INDEX.md, junk.md, working.md, meta.json.
+ */
+export function layerOfFile(root, file) {
+  const rel = relative(root, file).replace(/\\/g, '/')
+  const parts = rel.split('/')
+  const base = parts[parts.length - 1]
+  for (const [layer, name] of Object.entries(LAYER_FILES)) if (base === name) return layer
+  const parent = parts.length >= 2 ? parts[parts.length - 2] : undefined
+  for (const [layer, dir] of Object.entries(LAYER_DIRS)) if (parent === dir) return layer
+  return undefined
+}
+
+/** Files that feed the FTS index and the ledger. */
+export function indexedFiles(root) {
+  return listLayerFiles(root).filter((file) => {
+    const base = file.replace(/\\/g, '/').split('/').pop()
+    return INDEXED_FILES.has(base) || layerOfFile(root, file) !== undefined
+  })
+}
+
+/** The store-level topic map, excluded from entries but kept for navigation. */
+export function isTopicMap(root, file) {
+  return file.replace(/\\/g, '/').split('/').pop() === 'INDEX.md'
+}