@r1z4x/tezgah 1.11.0 → 1.14.0

package/workflows/graph-map.js

@@ -77,7 +77,8 @@ focus, ranked, with the real directory path for each. Do not read file bodies -
   { label: 'survey', schema: SURVEY, effort: 'medium' },
 )
 
-if (!survey || !survey.modules || !survey.modules.length) {
+if (!survey) return { error: 'the survey agent failed - nothing was mapped; unknown, not clean', unknown: ['survey'] }
+if (!survey.modules || !survey.modules.length) {
   return { error: 'survey returned no modules - is the repo indexed? run `codegraph init` in it first' }
 }
 
@@ -88,7 +89,7 @@ if (ranked.length > picked.length) {
 }
 
 phase('Read')
-const readings = (await parallel(picked.map(m => () => agent(
+const read = await parallel(picked.map(m => () => agent(
   `Read module "${m.name}" at ${m.path}. It matters because: ${m.why}. Overall focus: ${focus}.
 ${GRAPH}
 Answer: what it is responsible for, its key symbols with file and line, which other modules call it or
@@ -96,7 +97,10 @@ it calls (use \`codegraph callers\` and \`codegraph callees\` both directions),
 and any graph-evidenced risk (dead code, a symbol with many inbound callers, missing test coverage).
 Cite file:line for every claim.`,
   { label: `read:${m.name}`, phase: 'Read', schema: READING },
-)))).filter(Boolean)
+)))
+// a failed reader is unknown, never silence: its module is unread, not empty
+const unknown = picked.filter((m, i) => !read[i]).map(m => `read:${m.name}`)
+const readings = read.filter(Boolean)
 
 log(`${readings.length}/${picked.length} modules read`)
 
@@ -119,7 +123,8 @@ document headings up as code.`,
 if (!map) {
   return { focus, modules_read: readings.map(r => r.module),
            modules_dropped: ranked.slice(MAX_MODULES).map(m => m.name),
-           map: null, gaps: [], error: 'the synthesize agent returned nothing' }
+           map: null, gaps: 'unknown - the gap check never ran', unknown: unknown.concat(['synthesize']),
+           error: 'the synthesize agent returned nothing' }
 }
 
 phase('Gap check')
@@ -148,11 +153,15 @@ list; empty list if genuinely clean.`,
   }, effort: 'high' },
 )
 
+if (!gaps) unknown.push('gap-check')
+if (unknown.length) log(`failed, reported as unknown: ${unknown.join(', ')}`)
+
 return {
   focus,
   modules_read: readings.map(r => r.module),
   modules_dropped: ranked.slice(MAX_MODULES).map(m => m.name),
   map,
-  gaps: (gaps && gaps.gaps) || [],
+  gaps: gaps ? (gaps.gaps || []) : 'unknown - the gap-check agent failed',
   coverage_note: gaps && gaps.coverage_note,
+  unknown,
 }

package/workflows/graph-review.js

@@ -114,7 +114,18 @@ const unknown = DIMENSIONS.filter((d, i) => !reviewed[i]).map(d => `review:${d.k
 const reviews = reviewed.filter(Boolean)
 
 const rank = { high: 0, medium: 1, low: 2 }
-const all = reviews.flatMap(r => r.findings || []).sort((a, b) => rank[a.severity] - rank[b.severity])
+// two lenses often raise one defect: merge on (file, line, lowercased title), keep the higher severity
+const byKey = new Map()
+let raised = 0
+reviewed.forEach((r, i) => ((r && r.findings) || []).forEach(f => {
+  raised++
+  const key = `${f.file}\u0000${f.line || ''}\u0000${String(f.title).trim().toLowerCase()}`
+  const prev = byKey.get(key)
+  const keep = prev && rank[prev.severity] <= rank[f.severity] ? prev : f
+  byKey.set(key, { ...keep, dimensions: [...new Set([...((prev && prev.dimensions) || []), DIMENSIONS[i].key])] })
+}))
+const all = [...byKey.values()].sort((a, b) => rank[a.severity] - rank[b.severity])
+const caps = { max_verified: MAX_VERIFIED, raised, deduplicated: raised - all.length }
 if (!all.length) {
   const note = !unknown.length ? 'all four dimensions came back clean'
     : !reviews.length ? 'every dimension failed - nothing was reviewed; unknown, not clean'
@@ -124,7 +135,7 @@ if (!all.length) {
 
 const toVerify = all.slice(0, MAX_VERIFIED)
 if (all.length > toVerify.length) {
-  log(`${all.length} findings raised; verifying the ${toVerify.length} most severe. NOT verified (reported as unverified): ${all.slice(MAX_VERIFIED).map(f => f.title).join('; ')}`)
+  log(`${all.length} distinct findings (${caps.deduplicated} duplicates merged); verifying the ${toVerify.length} most severe. NOT verified (reported as unverified): ${all.slice(MAX_VERIFIED).map(f => f.title).join('; ')}`)
 }
 
 phase('Verify')
@@ -167,4 +178,5 @@ return {
   unverified: unsettled.map(v => ({ ...v.finding, verdict: 'UNVERIFIED - every refuter failed' }))
     .concat(all.slice(MAX_VERIFIED).map(f => ({ ...f, verdict: 'UNVERIFIED - budget cap' }))),
   unknown,
+  caps,
 }