pluribus-context 0.3.21 → 0.3.26

package/src/commands/audit.js

@@ -9,6 +9,7 @@
 
 import * as fs from 'fs'
 import * as path from 'path'
+import { createHash } from 'crypto'
 import { parsePluribusFile, validateSections, REQUIRED_SECTIONS } from '../utils/parser.js'
 import { resolveImportsAsync } from '../utils/imports.js'
 import { renderTemplate, parseSkillFile } from '../utils/renderer.js'
@@ -294,7 +295,10 @@ function buildFidelityReport({ cwd, sections, tools, loadSkill }) {
     const discovery = inferDiscovery(toolId, outputFiles)
     const represented = presentSections.filter((name) => representedSections.has(name.toLowerCase()))
 
-    const effectiveContext = inferEffectiveContext(toolId, outputFiles)
+    const rendered = renderTemplate(skill.template, sections, 'pluribus.md')
+    const loadEvidence = inferLoadEvidence(toolId, outputFiles, discovery, activation)
+    const duplicateLoadEvidence = inferDuplicateLoadEvidence(toolId, outputFiles, loadEvidence, rendered)
+    const effectiveContext = inferEffectiveContext(toolId, outputFiles, loadEvidence)
 
     return {
       toolId,
@@ -304,8 +308,10 @@ function buildFidelityReport({ cwd, sections, tools, loadSkill }) {
       genericFallback: discovery.genericFallback,
       manualActivationRequired: discovery.manualActivationRequired,
       activation,
+      loadEvidence,
+      duplicateLoadEvidence,
       effectiveContext,
-      semanticDifference: summarizeSemanticDifference({ unsupportedSections, activation, discovery, effectiveContext }),
+      semanticDifference: summarizeSemanticDifference({ unsupportedSections, activation, discovery, effectiveContext, loadEvidence, duplicateLoadEvidence }),
       representedSections: represented,
       unsupportedSections,
     }
@@ -338,6 +344,22 @@ function buildFidelityReport({ cwd, sections, tools, loadSkill }) {
     })
   }
 
+  if (targets.some((target) => target.loadEvidence?.dedupeRisk === 'unknown')) {
+    warnings.push({
+      code: 'load-dedupe-not-proven',
+      target: '*',
+      message: 'Load evidence records the expected delivery path, but Pluribus does not currently prove runtime deduplication across native files, hooks, generated imports, or manual injection.',
+    })
+  }
+
+  if (targets.some((target) => target.duplicateLoadEvidence?.duplicateRisk === 'unknown')) {
+    warnings.push({
+      code: 'duplicate-load-selection-not-proven',
+      target: '*',
+      message: 'Duplicate load evidence records the Pluribus generated candidate, but does not inspect runtime scanner roots, caches, plugins, or sibling tool directories to prove which duplicate candidate the agent selected or suppressed.',
+    })
+  }
+
   const advancedSections = ['workflow', 'context', 'examples', 'anti-patterns'].filter((name) => lowerPresentSections.has(name))
   if (advancedSections.length > 0 && warnings.some((warning) => warning.code === 'section-not-rendered-by-target')) {
     warnings.push({
@@ -398,7 +420,69 @@ function inferDiscovery(toolId, outputFiles) {
   }
 }
 
-function inferEffectiveContext(toolId, outputFiles) {
+function inferLoadEvidence(toolId, outputFiles, discovery, activation) {
+  const primaryFile = outputFiles[0] || null
+  const loadedBy = discovery.genericFallback ? 'generic-agent-file' : 'native-file-discovery'
+
+  return {
+    loadedBy,
+    effectiveSource: primaryFile,
+    deliveryPath: primaryFile,
+    deliveryMechanism: discovery.genericFallback ? 'generated-generic-fallback' : 'generated-native-surface',
+    hookInstalled: false,
+    injectedOnSessionStart: false,
+    manualInjectionRequired: discovery.manualActivationRequired,
+    resumeBehavior: 'not-proven',
+    dedupeKey: primaryFile ? `${toolId}:${loadedBy}:${primaryFile}` : `${toolId}:${loadedBy}:unknown`,
+    dedupeRisk: 'unknown',
+    evidence: outputFiles,
+    note: `${toolId} load path is inferred from generated files and known discovery surfaces; verify runtime loading/deduplication in the target agent when hooks, imports, or manual injection are also used.`,
+  }
+}
+
+
+function inferDuplicateLoadEvidence(toolId, outputFiles, loadEvidence, rendered) {
+  const primaryFile = outputFiles[0] || null
+  const contentHash = typeof rendered === 'string'
+    ? `sha256:${createHash('sha256').update(rendered, 'utf8').digest('hex')}`
+    : null
+  const candidateLoads = primaryFile
+    ? [{
+        path: primaryFile,
+        contentHash,
+        toolOwner: toolId,
+        loadedBy: loadEvidence.loadedBy,
+        discoveryRoot: inferDiscoveryRoot(primaryFile),
+        priority: 'not-modeled',
+        source: 'pluribus-generated-output',
+      }]
+    : []
+
+  return {
+    contentIdentity: contentHash,
+    candidateLoads,
+    selectedLoad: candidateLoads[0]
+      ? {
+          ...candidateLoads[0],
+          selectionReason: 'only-pluribus-generated-output-for-target',
+        }
+      : null,
+    suppressedLoads: [],
+    selectionPolicy: 'not-proven-runtime-selection',
+    crossRootScanMode: 'not-inspected',
+    duplicateRisk: 'unknown',
+    invariant: 'For each session_id + logical context or skill name + content hash, inject at most one effective definition unless the second load is explicitly marked as replace or supplement.',
+    note: `${toolId} duplicate-load evidence covers the Pluribus generated output only; verify runtime scanner roots, caches, plugins, hooks, imports, and sibling tool directories before claiming duplicate suppression.`,
+  }
+}
+
+function inferDiscoveryRoot(file) {
+  if (!file) return null
+  const dirname = path.dirname(file)
+  return dirname === '.' ? 'repo-root' : dirname
+}
+
+function inferEffectiveContext(toolId, outputFiles, loadEvidence) {
   return {
     scope: 'repo-root',
     pathScoped: false,
@@ -406,11 +490,13 @@ function inferEffectiveContext(toolId, outputFiles) {
     overrideBehavior: 'none-modeled',
     isolationEvidence: 'not-modeled',
     entrypoints: outputFiles,
+    loadedBy: loadEvidence.loadedBy,
+    effectiveSource: loadEvidence.effectiveSource,
     note: `${toolId} output is audited as repo-root context only; verify subdirectory load order separately in monorepos.`,
   }
 }
 
-function summarizeSemanticDifference({ unsupportedSections, activation, discovery, effectiveContext }) {
+function summarizeSemanticDifference({ unsupportedSections, activation, discovery, effectiveContext, loadEvidence, duplicateLoadEvidence }) {
   const differences = []
 
   if (unsupportedSections.length > 0) {
@@ -433,6 +519,14 @@ function summarizeSemanticDifference({ unsupportedSections, activation, discover
     differences.push('manual-activation-required')
   }
 
+  if (loadEvidence?.dedupeRisk === 'unknown') {
+    differences.push('runtime-load-dedupe-not-proven')
+  }
+
+  if (duplicateLoadEvidence?.duplicateRisk === 'unknown') {
+    differences.push('duplicate-load-selection-not-proven')
+  }
+
   return differences.length > 0 ? differences : ['no-known-template-loss']
 }
 
@@ -452,10 +546,16 @@ function printFidelityReport(report) {
     const scope = target.effectiveContext?.scope
       ? `; effective context: ${target.effectiveContext.scope}`
       : ''
+    const loadedBy = target.loadEvidence?.loadedBy
+      ? `; loaded by: ${target.loadEvidence.loadedBy}`
+      : ''
+    const duplicateSelection = target.duplicateLoadEvidence?.duplicateRisk
+      ? `; duplicate selection: ${target.duplicateLoadEvidence.duplicateRisk}`
+      : ''
     const semantics = target.semanticDifference?.length
       ? `; semantic: ${target.semanticDifference.join(', ')}`
       : ''
-    console.log(`   • ${target.toolId}: ${target.activation.kind}${discovery}${scope}${unsupported}${semantics}`)
+    console.log(`   • ${target.toolId}: ${target.activation.kind}${discovery}${scope}${loadedBy}${duplicateSelection}${unsupported}${semantics}`)
   }
 
   for (const warning of report.warnings) {

package/src/utils/version.js

@@ -1 +1 @@
-export const VERSION = '0.3.21'
+export const VERSION = '0.3.26'