dsh-error-atlas 0.11.2 → 0.11.26

package/index.js

@@ -33,9 +33,9 @@ import { dirname, join } from 'node:path'
 export const name = 'error-atlas'
 
 const DEFAULTS = {
-  maxRecords: 1200,
-  maxLog: 400,
-  maxNodes: 240,
+  maxRecords: 4000,
+  maxLog: 2000,
+  maxNodes: 2400,
   maxRetros: 200,
   messageChars: 260,
   retroChars: 420,
@@ -52,7 +52,7 @@ const CODING_TOOLS = new Set(['write', 'edit', 'pwsh', 'bash', 'run_code', 'plug
  * with one of these prefixes never becomes a node. `cd`/`pwd` noise is the reason this
  * exists — it would otherwise eat the node budget and pollute the relapse count.
  */
-const PREF_DEFAULTS = { minCount: 1, ignore: [], prompt: true, inject: true }
+const PREF_DEFAULTS = { minCount: 1, ignore: [], prompt: true, inject: true, showNoise: false }
 
 function normalizeIgnore(value, limit = 24) {
   if (!Array.isArray(value)) return []
@@ -125,6 +125,76 @@ function normalizeMessage(value, limit) {
   return text.length > limit ? text.slice(0, limit - 1) + '…' : text
 }
 
+/**
+ * The identity of a failing command, not its whole command line.
+ *
+ * The shell hands us compound lines ("cd X; & node script.js"), and using that as the
+ * record message split one recurring failure into dozens of near-duplicate signatures.
+ * This keeps the executable, its meaningful sub command, and the script it ran.
+ */
+function commandFingerprint(command) {
+  const KNOWN = /^(node|npm|pnpm|yarn|git|gh|rg|python|python3|pwsh|powershell|cmd|deno|bun|cargo|go|dotnet|tsc|vite|eslint|jest|vitest)$/
+  const EXE = /\.(exe|cmd|bat|ps1)$/i
+  const flat = String(command || '').replace(/\s+/g, ' ').trim()
+  if (!flat) return ''
+  const segments = flat
+    .split(/;|&&|\|\||\n/)
+    .map((part) => part.trim())
+    .filter(Boolean)
+  const exeOf = (segment) => {
+    const tokens = segment.match(/"[^"]*"|'[^']*'|\S+/g) || []
+    const clean = tokens.map((token) => token.replace(/^["']|["']$/g, ''))
+    const head = clean[0]
+    if (!head) return null
+    const bare = head.split(/[\\/]/).pop()
+    const name = bare.replace(EXE, '').toLowerCase()
+    if (!KNOWN.test(name)) return null
+    return { name, rest: clean.slice(1) }
+  }
+  // The failing command is the last one in the pipeline; heredoc bodies and script
+  // fragments are not commands, so walk backwards to the last real executable.
+  let found = null
+  for (let i = segments.length - 1; i >= 0; i -= 1) {
+    const candidate = segments[i].replace(/^&\s*/, '').replace(/^@'\s*/, '')
+    const parsed = exeOf(candidate)
+    if (parsed) {
+      found = parsed
+      break
+    }
+  }
+  if (!found) return 'shell'
+  const inline = found.rest[0] || ''
+  if (/^-(e|c|m)$/i.test(inline)) return found.name + ' ' + inline
+  // `npm run <script>` is the useful half of a package-manager failure.
+  if (/^(npm|pnpm|yarn|bun)$/.test(found.name) && found.rest[0] === 'run' && found.rest[1]) {
+    return found.name + ' run ' + found.rest[1]
+  }
+  const qualifier = found.rest.find((token) => token && !token.startsWith('-'))
+  if (!qualifier) return found.name
+  const file = qualifier.split(/[\\/]/).pop()
+  return found.name + ' ' + (file || qualifier)
+}
+
+/** The first useful line of stderr: the part of a failure that is not the command. */
+function exitDetailOf(result) {
+  const blocks = Array.isArray(result && result.content) ? result.content : []
+  const lines = []
+  for (const block of blocks) {
+    if (!block || block.type !== 'text' || typeof block.text !== 'string') continue
+    for (const raw of block.text.split(/\r?\n/)) {
+      const line = raw.trim()
+      if (!line) continue
+      if (/^\[exit code: -?\d+\]$/.test(line)) continue
+      if (/^\[\d+ms\]$/.test(line)) continue
+      lines.push(line)
+    }
+  }
+  // stderr trails stdout, so the last meaningful line is the error itself.
+  const last = lines.length > 0 ? lines[lines.length - 1] : ''
+  if (!last) return ''
+  return clip(last.replace(/^\s*(error|fatal|Error|FATAL):\s*/, ''), 90)
+}
+
 function summarizeArguments(args) {
   if (!args || typeof args !== 'object') return ''
   const keys = ['command', 'cmd', 'script', 'file_path', 'path', 'query', 'url', 'name']
@@ -316,6 +386,7 @@ function createStore(config) {
             cause: clip(entry.cause, config.retroChars),
             fix: clip(entry.fix, config.retroChars),
             lesson: clip(entry.lesson, config.retroChars),
+            essence: clip(entry.essence, 160) || undefined,
             tags: Array.isArray(entry.tags) ? entry.tags.filter((t) => typeof t === 'string').slice(0, 8) : [],
             tools: Array.isArray(entry.tools) ? entry.tools.filter((t) => typeof t === 'string').slice(0, 12) : [],
             files: Array.isArray(entry.files) ? entry.files.filter((t) => typeof t === 'string').slice(0, 12) : [],
@@ -340,9 +411,68 @@ function createStore(config) {
           state.prefs.minCount = Math.max(1, Math.min(50, Math.floor(parsed.prefs.minCount)))
         }
         if (Array.isArray(parsed.prefs.ignore)) state.prefs.ignore = normalizeIgnore(parsed.prefs.ignore)
-    if (typeof parsed.prefs.prompt === 'boolean') state.prefs.prompt = parsed.prefs.prompt
-    if (typeof parsed.prefs.inject === 'boolean') state.prefs.inject = parsed.prefs.inject
+        if (typeof parsed.prefs.showNoise === 'boolean') state.prefs.showNoise = parsed.prefs.showNoise
+        if (typeof parsed.prefs.prompt === 'boolean') state.prefs.prompt = parsed.prefs.prompt
+        if (typeof parsed.prefs.inject === 'boolean') state.prefs.inject = parsed.prefs.inject
       }
+      let migrated = false
+      // ── store v3: exit messages become command fingerprints ────────────────
+      // Before this, an exit record carried the whole command line, so one recurring
+      // failure arrived as dozens of near-identical signatures. Fold them once, and
+      // remap every retrospective that pointed at a merged-away id.
+      if (Number.isFinite(parsed.version) && parsed.version < 3) {
+        const remap = new Map()
+        const canonical = new Map()
+        for (const entry of [...state.records.values()]) {
+          if (entry.kind !== 'exit') continue
+          const parts = String(entry.message || '').split(' · ')
+          const code = parts[0] || 'exit code 1'
+          const command = parts.slice(1).join(' · ')
+          const fingerprint = commandFingerprint(command) || command
+          const detail = parts.length > 2 ? parts[parts.length - 1] : ''
+          const message = code + (fingerprint ? ' · ' + fingerprint : '') + (detail ? ' · ' + detail : '')
+          const key = 'exit\u0000' + entry.name + '\u0000' + message
+          const target = canonical.get(key)
+          if (!target) {
+            const merged = Object.assign({}, entry, { message, key })
+            canonical.set(key, merged)
+            if (merged !== entry) state.records.delete(entry.key)
+            state.records.set(key, merged)
+            remap.set(entry.id, merged.id)
+            continue
+          }
+          target.count += entry.count
+          target.first = Math.min(target.first, entry.first)
+          target.last = Math.max(target.last, entry.last)
+          for (const session of entry.sessions || []) {
+            if (target.sessions.length < 12 && !target.sessions.includes(session)) target.sessions.push(session)
+          }
+          state.records.delete(entry.key)
+          remap.set(entry.id, target.id)
+        }
+        const alive = new Set([...state.records.values()].map((entry) => entry.id))
+        for (const retro of state.retros) {
+          if (!Array.isArray(retro.errorIds) || retro.errorIds.length === 0) continue
+          const next = []
+          for (const id of retro.errorIds) {
+            const mapped = remap.get(id) || id
+            if (alive.has(mapped) && !next.includes(mapped)) next.push(mapped)
+          }
+          retro.errorIds = next.slice(0, 12)
+        }
+        migrated = true
+      }
+
+      for (const retro of state.retros) {
+        if (!retro.essence) {
+          const derived = deriveEssence(retro)
+          if (derived) {
+            retro.essence = clip(derived, 160)
+            migrated = true
+          }
+        }
+      }
+      if (migrated) save()
       // A store written before lesson links existed carries only failure text on its
       // retrospectives; give those pipelines back once.
       if (state.retros.length > 0 && state.records.size > 0) {
@@ -361,7 +491,7 @@ function createStore(config) {
     try {
       mkdirSync(dir, { recursive: true })
       const payload = JSON.stringify({
-        version: 2,
+        version: 3,
         updatedAt: state.updatedAt,
         records: [...state.records.values()],
         log: state.log,
@@ -491,6 +621,17 @@ function createStore(config) {
     if (state.retros.length > config.maxRetros) state.retros.length = config.maxRetros
   }
 
+  /** A lesson is only worth injecting if it says what to do next, in one line. */
+  function deriveEssence(retro) {
+    const raw = String((retro && (retro.essence || retro.lesson)) || '').trim()
+    if (!raw) return ''
+    const flat = raw.replace(/\s+/g, ' ')
+    const trimmed = flat.length > 96 ? flat.slice(0, 95) + '…' : flat
+    return /→/.test(trimmed) || /^(如果|当|别|不要|先|记得|用|把|每次|任何|永远|写|改|加|删|查|量|先量)/.test(trimmed)
+      ? trimmed
+      : '规则：' + trimmed
+  }
+
   function addRetro(input) {
     const at = Date.now()
     state.retroSeq += 1
@@ -498,6 +639,7 @@ function createStore(config) {
       id: 'r' + state.retroSeq.toString(36),
       at,
       auto: input.auto === true,
+      essence: clip(input.essence || '', 160) || undefined,
       title: clip(input.title, 120) || '未命名任务',
       done: clip(input.done, config.retroChars),
       cause: clip(input.cause, config.retroChars),
@@ -544,6 +686,7 @@ function createStore(config) {
     existing.cause = pick(input.cause, existing.cause, config.retroChars)
     existing.fix = pick(input.fix, existing.fix, config.retroChars)
     existing.lesson = pick(input.lesson, existing.lesson, config.retroChars)
+    existing.essence = pick(input.essence, existing.essence, 160)
     existing.tags = list(input.tags, existing.tags, 8)
     existing.tools = list(input.tools, existing.tools, 12)
     existing.files = list(input.files, existing.files, 12)
@@ -574,6 +717,7 @@ function createStore(config) {
       ignore: [...state.prefs.ignore],
       prompt: state.prefs.prompt,
       inject: state.prefs.inject,
+      showNoise: state.prefs.showNoise,
     }
   }
 
@@ -585,11 +729,24 @@ function createStore(config) {
     if (Array.isArray(patch.ignore)) state.prefs.ignore = normalizeIgnore(patch.ignore)
     if (typeof patch.prompt === 'boolean') state.prefs.prompt = patch.prompt
     if (typeof patch.inject === 'boolean') state.prefs.inject = patch.inject
+    if (typeof patch.showNoise === 'boolean') state.prefs.showNoise = patch.showNoise
     state.updatedAt = Date.now()
     save()
     return prefs()
   }
 
+  /**
+   * A failure whose only evidence is the exit code, repeated enough times to be churn.
+   * Real failures bring stderr with them; bare repeats are the "same command failed
+   * again" noise that used to drown the graph and poison lesson staleness.
+   */
+  function isBareExit(entry) {
+    if (!entry || entry.kind !== 'exit') return false
+    if (entry.count < 5) return false
+    const segments = String(entry.message || '').split(' · ')
+    return segments.length < 3
+  }
+
   function clear() {
     state.records.clear()
     state.log = []
@@ -597,20 +754,40 @@ function createStore(config) {
     save()
   }
 
+  /**
+   * A signature that many lessons point at is ambient environment noise — a quirk of the
+   * shell, not the mistake any single lesson was about. Its recurrence must not invalidate
+   * every lesson that happened to run in the same turn.
+   */
+  const AMBIENT_REFS = 4
+
+  function ambientIds() {
+    const counts = new Map()
+    for (const retro of state.retros) {
+      for (const id of retro.errorIds || []) counts.set(id, (counts.get(id) || 0) + 1)
+    }
+    const ambient = new Set()
+    for (const [id, count] of counts) {
+      if (count >= AMBIENT_REFS) ambient.add(id)
+    }
+    return ambient
+  }
+
   // A lesson can fail. When the very error a retrospective learned from shows up again
   // after the lesson was written, the lesson did not hold. The failure that produced the
   // retrospective is excluded by a grace window so a lesson never counts as its own relapse.
   const RETRO_GRACE_MS = 90 * 1000
 
-  function recurrenceOf(retro, recordById) {
+  function recurrenceOf(retro, recordById, ambient) {
     const ids = Array.isArray(retro.errorIds) ? retro.errorIds : []
     if (ids.length === 0) return null
     const cutoff = (Number(retro.at) || 0) + RETRO_GRACE_MS
     const keys = new Set()
     let lastAt = 0
     for (const id of ids) {
+      if (ambient && ambient.has(id)) continue
       const entry = recordById.get(id)
-      if (!entry) continue
+      if (!entry || isBareExit(entry)) continue
       keys.add(entry.key)
       if (entry.last > cutoff) lastAt = Math.max(lastAt, entry.last)
     }
@@ -672,9 +849,10 @@ function createStore(config) {
       const needle = typeof query === 'string' ? query.trim().toLowerCase() : ''
       const recordById = new Map()
       for (const entry of state.records.values()) recordById.set(entry.id, entry)
+      const ambient = ambientIds()
       const lessons = []
       for (const retro of state.retros) {
-        const relapse = recurrenceOf(retro, recordById)
+        const relapse = recurrenceOf(retro, recordById, ambient)
         const programs = []
         for (const file of retro.files || []) {
           const project = projectOf(file, retro.cwd)
@@ -698,6 +876,7 @@ function createStore(config) {
           at: retro.at,
           auto: !!retro.auto,
           title: retro.title,
+          essence: retro.essence || deriveEssence(retro),
           lesson: retro.lesson || '',
           cause: retro.cause || '',
           fix: retro.fix || '',
@@ -721,17 +900,22 @@ function createStore(config) {
       // Switched off in the panel: an empty string makes the context section vanish, so
       // a user who does not want injected lessons pays nothing per request.
       if (state.prefs.inject === false) return ''
-      const lessons = lessonList()
+      // Auto skeletons are bookkeeping, not lessons learned: they never make it in.
+      const lessons = lessonList().filter((item) => !item.auto)
       if (lessons.length === 0) return ''
       // Two traps plus two fresh rules is about the most a model will actually use;
       // the full text stays one tool call away.
-      const stale = lessons.filter((item) => item.stale > 0).slice(0, 2)
+      // Only a lesson that points at a real error can be disproved; a skeleton without
+      // errorIds can never come back, so it can never be a trap either.
+      const stale = lessons.filter((item) => item.stale > 0 && item.errorIds.length > 0).slice(0, 1)
       const recent = lessons
         .filter((item) => item.stale === 0)
         .slice(0, Math.max(1, limit - stale.length))
       const line = (item, prefix) => {
-        const where = item.programs.length > 0 ? '[' + item.programs.join('/') + '] ' : ''
-        const text = item.lesson || item.done || item.title
+        const where = item.programs.length > 0 ? '[' + item.programs[0] + '] ' : ''
+        // Essence, not the essay: one actionable line per lesson, so three of them fit
+        // in the same budget the old five-paragraph version used.
+        const text = clip(item.essence || item.lesson || item.title, 110)
         return '- ' + prefix + where + text
       }
       const lines = ['## Error atlas: recorded lessons']
@@ -747,13 +931,71 @@ function createStore(config) {
       return lines.join('\n')
     }
 
+    // What the lessons bought, in numbers that are honest about being proxies: a lesson
+    // counts as "judged" only when it names failures that are still in the store, and only
+    // then can its signatures be watched afterwards. Everything else is bookkeeping.
+    function impactOf(days = 30) {
+      const span = Math.max(1, Math.min(365, Math.floor(days || 30)))
+      const windowMs = span * 24 * 60 * 60 * 1000
+      const since = Date.now() - windowMs
+      const recordById = new Map()
+      for (const entry of state.records.values()) recordById.set(entry.id, entry)
+      const ambient = ambientIds()
+      const linked = new Set()
+      let model = 0
+      let auto = 0
+      let judgeable = 0
+      let failed = 0
+      let firstLessonAt = Infinity
+      for (const retro of state.retros) {
+        if (retro.auto) auto += 1
+        else model += 1
+        if (!retro.auto && Number.isFinite(retro.at) && retro.at < firstLessonAt) firstLessonAt = retro.at
+        const ids = (retro.errorIds || []).filter((id) => recordById.has(id))
+        for (const id of ids) linked.add(id)
+        if (retro.auto || ids.length === 0) continue
+        judgeable += 1
+        const relapse = recurrenceOf(retro, recordById, ambient)
+        if (relapse && relapse.times > 0) failed += 1
+      }
+      let hits = 0
+      let hitsInWindow = 0
+      let afterFirstLesson = 0
+      for (const event of state.log) {
+        hits += 1
+        if (event.at >= since) hitsInWindow += 1
+        if (Number.isFinite(firstLessonAt) && event.at > firstLessonAt) afterFirstLesson += 1
+      }
+      const distinct = state.records.size
+      return {
+        days: span,
+        lessons: model + auto,
+        model,
+        auto,
+        judgeable,
+        failed,
+        held: judgeable - failed,
+        rate: judgeable > 0 ? Math.round((failed / judgeable) * 100) : 0,
+        distinct,
+        withLesson: linked.size,
+        coverage: distinct > 0 ? Math.round((linked.size / distinct) * 100) : 0,
+        hits,
+        hitsInWindow,
+        afterFirstLesson,
+        firstLessonAt: Number.isFinite(firstLessonAt) ? firstLessonAt : 0,
+      }
+    }
+
   function snapshot() {
     const all = [...state.records.values()].sort((a, b) => b.count - a.count || b.last - a.last)
     const recordById = new Map()
     for (const entry of all) recordById.set(entry.id, entry)
+    const ambient = ambientIds()
     // Muted signatures still feed relapse detection (a lesson that failed on a noisy
     // command is still a failed lesson), they just do not become nodes.
-    const visible = all.filter(
+    const noisy = all.filter((entry) => isBareExit(entry))
+    const quiet = state.prefs.showNoise ? all : all.filter((entry) => !isBareExit(entry))
+    const visible = quiet.filter(
       (entry) => entry.count >= state.prefs.minCount && !isNoise(entry, state.prefs.ignore),
     )
     const muted = all.length - visible.length
@@ -764,6 +1006,11 @@ function createStore(config) {
       byKind[entry.kind] = (byKind[entry.kind] || 0) + entry.count
     }
 
+    // Recurrence is judged against what the graph actually shows, so muting a noisy
+    // signature also stops it from flagging healthy lessons as failed.
+    recordById.clear()
+    for (const entry of visible) recordById.set(entry.id, entry)
+
     const picked = visible.slice(0, config.maxNodes)
     // A retrospective must never point at a node the cap dropped: its lesson edge would
     // vanish and the atlas would quietly claim that every lesson held. Reserve the space.
@@ -885,7 +1132,7 @@ function createStore(config) {
     // anchored to the DSH core like every other leaf.
     const retroNodes = []
     for (const retro of state.retros.slice(0, config.maxRetros)) {
-      const relapse = recurrenceOf(retro, recordById)
+      const relapse = recurrenceOf(retro, recordById, ambient)
       retroNodes.push({
         id: 'rt:' + retro.id,
         kind: 'retro',
@@ -940,6 +1187,7 @@ function createStore(config) {
     function lessonBoard() {
       const recordById = new Map()
       for (const entry of state.records.values()) recordById.set(entry.id, entry)
+      const ambient = ambientIds()
       const tags = new Map()
       const programs = new Map()
       const failedRows = []
@@ -951,7 +1199,7 @@ function createStore(config) {
         bucket.set(name, cell)
       }
       for (const retro of state.retros) {
-        const relapse = recurrenceOf(retro, recordById)
+        const relapse = recurrenceOf(retro, recordById, ambient)
         const stale = relapse ? relapse.times : 0
         total += 1
         const retroPrograms = []
@@ -1005,6 +1253,9 @@ function createStore(config) {
         matched: visible.length,
         truncated,
         muted,
+        // Bare repeats the graph hides by default; a non-zero count explains the gap
+        // between distinct and matched instead of leaking it silently.
+        noise: noisy.length,
         sessions: sessionTotals.size,
         tools: toolTotals.size,
         projects: [...projectErrors.values()].filter((set) => set.size > 0).length,
@@ -1016,6 +1267,7 @@ function createStore(config) {
       prefs: prefs(),
       trend: trendOf(Date.now()),
       lessons: lessonBoard(),
+      impact: impactOf(30),
       nodes,
       links,
       retros: state.retros.slice(0, config.maxRetros),
@@ -1037,6 +1289,7 @@ function createStore(config) {
     applyPrefs,
     lessonList,
     lessonBriefing,
+    impactOf,
   }
 }
 
@@ -1264,11 +1517,16 @@ export function apply(ctx, config = {}) {
       } else {
         const code = exitCodeOf(result)
         if (code === undefined) return
-        const detail = summarizeArguments(exec.arguments)
+        const fingerprint = commandFingerprint(exec.arguments && exec.arguments.command)
+        const detail = exitDetailOf(result)
         entry = store.record({
           kind: 'exit',
           name: exec.name || 'tool',
-          message: 'exit code ' + code + (detail ? ' · ' + detail : ''),
+          message:
+            'exit code ' +
+            code +
+            (fingerprint ? ' · ' + fingerprint : '') +
+            (detail ? ' · ' + detail : ''),
           sessionId,
         })
       }
@@ -1474,6 +1732,11 @@ export function apply(ctx, config = {}) {
                 cause: { type: 'string', description: 'Root cause of the failure or the decision that mattered.' },
                 fix: { type: 'string', description: 'What solved it.' },
                 lesson: { type: 'string', description: 'The reusable rule that prevents this next time.' },
+                essence: {
+                  type: 'string',
+                  description:
+                    'One line, at most ~70 characters: "<if this situation> -> <root cause class> -> <what to do next time>". This is the only line other sessions will see, so make it a rule, not a summary.',
+                },
                 tags: { type: 'array', items: { type: 'string' }, description: 'Short labels, e.g. render, plugin, build.' },
                 errorIds: {
                   type: 'array',
@@ -1514,6 +1777,7 @@ export function apply(ctx, config = {}) {
                 cause: args.cause,
                 fix: args.fix,
                 lesson: args.lesson,
+                essence: args.essence,
                 tags: args.tags,
                 tools: buffer ? buffer.tools.slice(0, 12) : [],
                 files: buffer ? buffer.files.slice(0, 12) : [],
@@ -1609,6 +1873,78 @@ export function apply(ctx, config = {}) {
           }),
         'error-atlas: lesson tool',
       )
+
+      // Whether the mechanism pays for itself: how many lessons exist, how many can be
+      // judged at all, and how many of those had their signatures come back anyway.
+      scope.effect(
+        () =>
+          scope.tools.register({
+            name: 'atlas_impact',
+            description:
+              'Report what the recorded lessons bought: how many exist, how many can be judged (they name failures that are still in the store), how many of those were followed by the same failure returning, and how much of the store the lessons cover. These are counts from the local store, not a controlled experiment.',
+            parameters: {
+              type: 'object',
+              properties: {
+                days: { type: 'number', description: 'Window for the failure counts, 1 to 365; defaults to 30.' },
+              },
+              additionalProperties: false,
+            },
+            output: {
+              schema: {
+                type: 'object',
+                properties: {
+                  days: { type: 'number' },
+                  lessons: { type: 'number' },
+                  model: { type: 'number' },
+                  auto: { type: 'number' },
+                  judgeable: { type: 'number' },
+                  failed: { type: 'number' },
+                  held: { type: 'number' },
+                  rate: { type: 'number' },
+                  distinct: { type: 'number' },
+                  withLesson: { type: 'number' },
+                  coverage: { type: 'number' },
+                  hits: { type: 'number' },
+                  hitsInWindow: { type: 'number' },
+                  afterFirstLesson: { type: 'number' },
+                  firstLessonAt: { type: 'number' },
+                },
+                required: ['days', 'lessons', 'judgeable', 'failed', 'held', 'rate', 'coverage'],
+                additionalProperties: false,
+              },
+              render(_args, value) {
+                if (value.lessons === 0) return [{ type: 'text', text: 'no lessons recorded yet' }]
+                if (value.judgeable === 0) {
+                  return [
+                    {
+                      type: 'text',
+                      text:
+                        value.lessons +
+                        ' lesson(s), none judgeable yet: a lesson is judged only once it names failures that are still recorded',
+                    },
+                  ]
+                }
+                return [
+                  {
+                    type: 'text',
+                    text: [
+                      'impact · ' + value.days + ' day window',
+                      'lessons: ' + value.lessons + ' (' + value.model + ' model · ' + value.auto + ' auto) · ' + value.judgeable + ' judgeable',
+                      'verdict: ' + value.failed + ' of ' + value.judgeable + ' judged lessons recurred (' + value.rate + '% failed · ' + (100 - value.rate) + '% held)',
+                      'coverage: ' + value.withLesson + ' of ' + value.distinct + ' signatures carry a lesson (' + value.coverage + '%)',
+                      'failures: ' + value.hitsInWindow + ' in window · ' + value.afterFirstLesson + ' since the first lesson',
+                    ].join('\n'),
+                  },
+                ]
+              },
+            },
+            execute(args) {
+              const days = Number.isFinite(args.days) ? Math.max(1, Math.min(365, Math.floor(args.days))) : 30
+              return Promise.resolve(store.impactOf(days))
+            },
+          }),
+        'error-atlas: impact tool',
+      )
     })
 
     ctx.inject(['systemPrompt'], (scope) => {
@@ -1622,7 +1958,7 @@ export function apply(ctx, config = {}) {
                 ? ''
                 : [
                     '## Task retrospectives',
-                    'A coding turn (files written, a command run, a failure diagnosed) ends with one `atlas_retro` call before the final answer: `title`, `done` (what changed, where), `cause`, `fix`, `lesson` (the rule that prevents a repeat), `tags`. Skip plain chat, reading and questions.',
+                    'A coding turn (files written, a command run, a failure diagnosed) ends with one `atlas_retro` call before the final answer: `title`, `done` (what changed, where), `cause`, `fix`, `lesson`, and `essence` — one line shaped "<if this happens> -> <root cause> -> <what to do next time>", because that line is what other sessions get injected. Skip plain chat, reading and questions.',
                   ].join('\n'),
           }),
         'error-atlas: retrospective prompt section',

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Error Atlas",
-    "description": "Records runtime errors and coding-task retrospectives, links each lesson back to the failures it came from, groups errors under the program directory a task touched, searches the graph by error, tool, program or session, charts failure activity over the last 24 hours and 30 days, reports truncated or muted signatures honestly, and opens the source session from any node; renders everything as an interactive GPU knowledge graph and exports Markdown. The panel copy follows the DSH language setting (Chinese / English). Lessons are injected into the model context and queryable through the atlas_lessons tool. A collapsible lesson-effectiveness board ranks tags and programs by failure rate. Two memory switches in the panel turn the reminder and the injected lessons off instantly"
+    "description": "Records runtime errors and coding-task retrospectives, links each lesson back to the failures it came from, groups errors under the program directory a task touched, searches the graph by error, tool, program or session, charts failure activity over the last 24 hours and 30 days, reports truncated or muted signatures honestly, and opens the source session from any node; renders everything as an interactive GPU knowledge graph and exports Markdown. The panel copy follows the DSH language setting (Chinese / English). Lessons are injected into the model context and queryable through the atlas_lessons tool. A collapsible lesson-effectiveness board ranks tags and programs by failure rate. Session windows sit around the DSH core as islands with their own failures, programs orbit outside them, and the graph holds about 2400 nodes. Two memory switches in the panel turn the reminder and the injected lessons off instantly. Repeated failures of one command collapse into a command fingerprint, bare exit codes with no stderr are muted as noise, and every lesson is distilled into a single rule line that is what gets injected into the context. Signatures shared by many lessons are treated as environment noise, so they stop marking lessons as failed"
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "错误星图",
-    "description": "记录运行时错误与编程任务复盘，把每条教训连回它来自的错误，并在教训失效（同类错误复发）时标红告警；把错误按任务改过的程序目录聚成程序枢纽，可按错误、工具、程序或会话搜索图谱，并用柱状图看最近 24 小时与 30 天的活动量；图被截断或签名被静音时如实告知，节点可双击跳回来源会话；用 GPU 渲染成可交互的知识图谱，可一键导出 Markdown；界面文案跟随 DSH 语言设置（中文 / English）；教训会主动注入到模型的上下文中，并可通过 atlas_lessons 工具查询；内置一面「教训有效性」榜单，按标签与程序统计复发率，可收起；面板底部可随时关闭「收尾提示」与「注入教训」两枚记忆开关"
+    "description": "记录运行时错误与编程任务复盘，把每条教训连回它来自的错误，并在教训失效（同类错误复发）时标红告警；把错误按任务改过的程序目录聚成程序枢纽，可按错误、工具、程序或会话搜索图谱，并用柱状图看最近 24 小时与 30 天的活动量；图被截断或签名被静音时如实告知，节点可双击跳回来源会话；用 GPU 渲染成可交互的知识图谱，可一键导出 Markdown；界面文案跟随 DSH 语言设置（中文 / English）；教训会主动注入到模型的上下文中，并可通过 atlas_lessons 工具查询；内置一面「教训有效性」榜单，按标签与程序统计复发率，可收起；中间是 DSH 本体，往外每个会话窗口是一座岛、自己的错误围在周围，程序卫星挂在外层轨道，可容纳约 2400 个节点；面板底部可随时关闭「收尾提示」与「注入教训」两枚记忆开关；同一条命令在不同目录下的失败会被归并成命令指纹，没有 stderr 的裸退出码按噪声静音；每条教训会被压成一行的「本质规则」，注入上下文时只发这一行；被多条复盘共同引用的环境噪声不再把教训判为失效"
   }
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-error-atlas",
-  "version": "0.11.2",
+  "version": "0.11.26",
   "type": "module",
-  "description": "Records runtime errors and coding-task retrospectives, and renders them as an interactive GPU knowledge graph (WebGL) with lesson links, recurrence flags, program hubs, search, activity trends, and a caption switch.",
+  "description": "Records runtime errors and coding-task retrospectives, collapses noisy shell failures into command fingerprints, distils each lesson into one injected rule, and renders the whole thing as an interactive GPU knowledge graph (WebGL) with lesson links, recurrence flags, program satellites, session islands, orbit-any-node camera, search and activity trends.",
   "icon": "icon.svg",
   "license": "MIT",
   "author": "chaos-miku",
@@ -42,7 +42,9 @@
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
-    "docs/*.jpg"
+    "docs/*.jpg",
+    "docs/*.png",
+    "CHANGELOG.md"
   ],
   "bin": {
     "atlas-retro": "bin/atlas-retro.mjs",
@@ -62,5 +64,9 @@
       "immediately": true,
       "inject": []
     }
+  },
+  "devDependencies": {
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
   }
 }