dsh-standards 1.0.3 → 1.1.2

package/40-checker/src/declarations.mjs

@@ -1,3 +1,8 @@
+import path from 'node:path'
+import { createRequire } from 'node:module'
+
+const requireVendor = createRequire(import.meta.url)
+const { parse: parseBabel } = requireVendor('../vendor/babel/index.cjs')
 import { isObject, regexHits } from './util.mjs'
 import { check, detail, worst } from './result.mjs'
 import { validateCommitments, validateDisclosure } from './permissions.mjs'
@@ -47,33 +52,509 @@ function labelList(manifest) {
   return { defined: true, list: value, error: null }
 }
 
+
+// ---------------------------------------------------------------------------
+// AST layer (vendored @babel/parser, no runtime dependency)
+// ---------------------------------------------------------------------------
+
+function parsePlugins(relative) {
+  const extension = path.extname(String(relative || '')).toLowerCase()
+  const plugins = ['estree', 'decorators-legacy', 'importAttributes']
+  if (extension === '.ts' || extension === '.tsx') plugins.push('typescript')
+  if (extension !== '.ts' && extension !== '.tsx') plugins.push('jsx')
+  if (extension === '.tsx') plugins.push('jsx')
+  return plugins
+}
+
+const SOURCE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx']
+const FUNCTION_NODES = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'])
+const TRANSPARENT_NODES = new Set([
+  'TemplateLiteral', 'TemplateElement', 'BinaryExpression', 'LogicalExpression',
+  'ConditionalExpression', 'ParenthesizedExpression', 'ChainExpression',
+])
+const EQUALITY_OPERATORS = new Set(['==', '===', '!=', '!=='])
+const GRANT_METHODS = new Set(['set', 'resolve'])
+const CONSOLE_METHODS = new Set(['log', 'info', 'warn', 'error', 'debug'])
+const DOC_PROPERTY_KEYS = new Set(['desc', 'description', 'message', 'reason', 'help', 'label', 'title', 'comment'])
+const COMMAND_PROPERTY_KEYS = new Set(['mode', 'sandboxPolicy', 'sandbox_permissions'])
+const SPAWN_ARG_METHODS = new Set(['spawn', 'spawnSync', 'exec', 'execSync', 'execFile', 'execFileSync'])
+const FS_WRITE_METHODS = new Set([
+  'writeFileSync', 'appendFileSync', 'mkdirSync', 'rmSync', 'unlinkSync', 'rmdirSync', 'renameSync',
+  'copyFileSync', 'chmodSync', 'symlinkSync', 'truncateSync', 'writeSync',
+])
+const C10_SUBPROCESS_METHODS = new Set(['execSync', 'execFileSync', 'spawnSync', 'execFile', 'spawn'])
+
+const PARSE_CACHE = new WeakMap()
+
+function parseSource(source) {
+  const cached = PARSE_CACHE.get(source)
+  if (cached) return cached
+  const record = { ast: null, error: null }
+  try {
+    const parsed = parseBabel(source.text, {
+      sourceType: 'module',
+      allowHashBang: true,
+      plugins: parsePlugins(source.relative),
+    })
+    record.ast = parsed.program ?? parsed
+  } catch (error) {
+    record.error = {
+      message: String(error?.message ?? error),
+      line: Number.isInteger(error?.loc?.line) && error.loc.line > 0 ? error.loc.line : 1,
+    }
+  }
+  PARSE_CACHE.set(source, record)
+  return record
+}
+
+function normalizeRelative(relative) {
+  return String(relative ?? '').replace(/\\/g, '/').replace(/^\.\//, '')
+}
+
+// Declaration files have no runtime behavior; parsing them for import-time
+// side effects or execution strings only creates noise.
+function isDeclarationFile(relative) {
+  return /\.d\.[cm]?ts$/i.test(String(relative ?? ''))
+}
+
+function identifierName(node) {
+  return node?.type === 'Identifier' ? node.name : null
+}
+
+function memberPropertyName(node) {
+  if (!node || node.type !== 'MemberExpression') return null
+  if (!node.computed && node.property?.type === 'Identifier') return node.property.name
+  if (node.property?.type === 'Literal' && typeof node.property.value === 'string') return node.property.value
+  return null
+}
+
+function propertyKeyName(property) {
+  if (!property.computed && property.key?.type === 'Identifier') return property.key.name
+  if (property.key?.type === 'Literal' && typeof property.key.value === 'string') return property.key.value
+  return null
+}
+
+function calledFunctionName(call) {
+  if (!call || call.type !== 'CallExpression') return null
+  if (call.callee.type === 'Identifier') return call.callee.name
+  if (call.callee.type === 'MemberExpression') return memberPropertyName(call.callee)
+  return null
+}
+
+function walkAst(root, visit) {
+  const ancestors = []
+  const walkNode = (node) => {
+    if (!node || typeof node.type !== 'string') return
+    visit(node, ancestors)
+    ancestors.push(node)
+    for (const key of Object.keys(node)) {
+      if (key === 'loc') continue
+      const value = node[key]
+      if (Array.isArray(value)) {
+        for (const child of value) if (child && typeof child.type === 'string') walkNode(child)
+      } else if (value && typeof value.type === 'string') {
+        walkNode(value)
+      }
+    }
+    ancestors.pop()
+  }
+  walkNode(root)
+}
+
+// Module scope means "runs while the module is evaluated". Function bodies and
+// class method bodies are skipped; top-level if/try/loop bodies are not.
+function walkModuleScope(ast, visit) {
+  const ancestors = []
+  const walkNode = (node) => {
+    if (!node || typeof node.type !== 'string') return
+    if (FUNCTION_NODES.has(node.type) || node.type === 'MethodDefinition') return
+    visit(node, ancestors)
+    ancestors.push(node)
+    for (const key of Object.keys(node)) {
+      if (key === 'loc') continue
+      const value = node[key]
+      if (Array.isArray(value)) {
+        for (const child of value) if (child && typeof child.type === 'string') walkNode(child)
+      } else if (value && typeof value.type === 'string') {
+        walkNode(value)
+      }
+    }
+    ancestors.pop()
+  }
+  for (const statement of ast.body) walkNode(statement)
+}
+
+function callArgumentContext(ancestors, node, predicate) {
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type !== 'CallExpression' || !predicate(ancestor)) continue
+    const child = index + 1 < ancestors.length ? ancestors[index + 1] : node
+    if (ancestor.arguments.includes(child)) return ancestor
+  }
+  return null
+}
+
+function isEqualityOperand(ancestors) {
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type === 'BinaryExpression' && EQUALITY_OPERATORS.has(ancestor.operator)) return true
+    if (!TRANSPARENT_NODES.has(ancestor.type)) return false
+  }
+  return false
+}
+
+function isGrantCallArgument(ancestors, node) {
+  return Boolean(callArgumentContext(ancestors, node, (call) => (
+    call.callee.type === 'MemberExpression' && GRANT_METHODS.has(memberPropertyName(call.callee))
+  )))
+}
+
+function isConsoleArgument(ancestors, node) {
+  return Boolean(callArgumentContext(ancestors, node, (call) => (
+    call.callee.type === 'MemberExpression'
+    && identifierName(call.callee.object) === 'console'
+    && CONSOLE_METHODS.has(memberPropertyName(call.callee))
+  )))
+}
+
+function isSpawnArrayElement(ancestors, node) {
+  for (let index = 0; index < ancestors.length; index += 1) {
+    if (ancestors[index].type !== 'ArrayExpression') continue
+    for (let outer = index + 1; outer < ancestors.length; outer += 1) {
+      const call = ancestors[outer]
+      if (call.type !== 'CallExpression') continue
+      const child = outer + 1 < ancestors.length ? ancestors[outer + 1] : node
+      if (call.arguments.includes(child) && SPAWN_ARG_METHODS.has(calledFunctionName(call))) return true
+    }
+  }
+  return false
+}
+
+function isSwitchCaseValue(ancestors, node) {
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type === 'SwitchCase') {
+      const child = index + 1 < ancestors.length ? ancestors[index + 1] : node
+      return ancestor.test === child
+    }
+    if (!TRANSPARENT_NODES.has(ancestor.type)) return false
+  }
+  return false
+}
+
+function propertyContext(ancestors, node) {
+  let child = node
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type === 'Property') {
+      if (ancestor.value !== child) return null
+      return { key: propertyKeyName(ancestor) }
+    }
+    if (ancestor.type === 'ObjectExpression' || ancestor.type === 'ArrayExpression' || TRANSPARENT_NODES.has(ancestor.type)) {
+      child = ancestor
+      continue
+    }
+    return null
+  }
+  return null
+}
+
+function hasCommandProperty(ancestors, node) {
+  let child = node
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index]
+    if (ancestor.type === 'Property') {
+      if (ancestor.value !== child) return false
+      if (COMMAND_PROPERTY_KEYS.has(propertyKeyName(ancestor))) return true
+      child = ancestor
+      continue
+    }
+    if (ancestor.type === 'ObjectExpression' || ancestor.type === 'ArrayExpression' || TRANSPARENT_NODES.has(ancestor.type)) {
+      child = ancestor
+      continue
+    }
+    return false
+  }
+  return false
+}
+
+/**
+ * Classify a string literal. Comments never reach the AST. Equality comparisons
+ * and documentation strings are ignored; grant/command contexts and unknown
+ * contexts warn (unknown stays conservative).
+ */
+function classifyLiteral(node, ancestors) {
+  if (isEqualityOperand(ancestors)) return 'ignore'
+  if (isGrantCallArgument(ancestors, node)) return 'command'
+  if (isSpawnArrayElement(ancestors, node)) return 'command'
+  if (isSwitchCaseValue(ancestors, node)) return 'command'
+  if (hasCommandProperty(ancestors, node)) return 'command'
+  const property = propertyContext(ancestors, node)
+  if (isConsoleArgument(ancestors, node)) return 'doc'
+  if (property && DOC_PROPERTY_KEYS.has(property.key)) return 'doc'
+  return 'unknown'
+}
+
+function literalStringValue(node) {
+  if (node.type === 'Literal' && typeof node.value === 'string') return node.value
+  if (node.type === 'TemplateElement' && node.value) {
+    if (typeof node.value.cooked === 'string') return node.value.cooked
+    if (typeof node.value.raw === 'string') return node.value.raw
+  }
+  return null
+}
+
+function findLiteralHits(sources, values) {
+  const wanted = new Set(values)
+  const hits = []
+  const parseErrors = []
+  let parsedCount = 0
+  for (const source of sources) {
+    if (isDeclarationFile(source.relative)) continue
+    const parsed = parseSource(source)
+    if (parsed.error) {
+      parseErrors.push({ file: source.relative, line: parsed.error.line, message: parsed.error.message })
+      continue
+    }
+    parsedCount += 1
+    walkAst(parsed.ast, (node, ancestors) => {
+      const value = literalStringValue(node)
+      if (value === null || !wanted.has(value)) return
+      const context = classifyLiteral(node, ancestors)
+      if (context === 'ignore' || context === 'doc') return
+      hits.push({ file: source.relative, line: node.loc?.start?.line ?? 1, text: value })
+    })
+  }
+  return { hits, parseErrors, parsedCount }
+}
+
+function literalCandidates(base) {
+  const candidates = [base]
+  const extension = path.posix.extname(base)
+  if (SOURCE_EXTENSIONS.includes(extension)) {
+    const stem = base.slice(0, -extension.length)
+    for (const candidate of SOURCE_EXTENSIONS) if (candidate !== extension) candidates.push(`${stem}${candidate}`)
+  } else {
+    for (const candidate of SOURCE_EXTENSIONS) candidates.push(`${base}${candidate}`)
+  }
+  for (const candidate of SOURCE_EXTENSIONS) candidates.push(path.posix.join(base, `index${candidate}`))
+  return candidates
+}
+
+function resolveLocalSpecifier(fromRelative, specifier, byRelative) {
+  const spec = String(specifier).replace(/\\/g, '/')
+  if (!(spec.startsWith('./') || spec.startsWith('../') || spec === '.' || spec === '..')) return { kind: 'package' }
+  const base = path.posix.normalize(path.posix.join(path.posix.dirname(normalizeRelative(fromRelative)), spec))
+  if (base === '.' || base === '..' || base.startsWith('../') || path.posix.isAbsolute(base)) return { kind: 'unresolved' }
+  for (const candidate of literalCandidates(base)) {
+    if (byRelative.has(candidate)) return { kind: 'local', relative: candidate }
+  }
+  return { kind: 'unresolved' }
+}
+
+function collectModuleEdges(ast) {
+  const edges = []
+  walkAst(ast, (node) => {
+    if (node.type === 'ImportDeclaration' || node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') {
+      if (node.source?.type === 'Literal' && typeof node.source.value === 'string') {
+        edges.push({ specifier: node.source.value, line: node.loc?.start?.line ?? 1 })
+      }
+    }
+  })
+  // require() is only import-time when it runs at module scope; a lazy require
+  // inside apply()/a factory must not be treated as part of the import closure.
+  walkModuleScope(ast, (node) => {
+    if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'require') {
+      const argument = node.arguments[0]
+      if (argument?.type === 'Literal' && typeof argument.value === 'string') {
+        edges.push({ specifier: argument.value, line: node.loc?.start?.line ?? 1 })
+      }
+    }
+  })
+  return edges
+}
+
+function isSetIntervalCall(call) {
+  if (call.callee.type === 'Identifier' && call.callee.name === 'setInterval') return true
+  return call.callee.type === 'MemberExpression'
+    && identifierName(call.callee.object) === 'globalThis'
+    && memberPropertyName(call.callee) === 'setInterval'
+}
+
+function isProcessOnCall(call) {
+  return call.callee.type === 'MemberExpression'
+    && identifierName(call.callee.object) === 'process'
+    && memberPropertyName(call.callee) === 'on'
+}
+
+function assignmentTargetKind(node) {
+  if (node.left.type !== 'MemberExpression') return null
+  const property = memberPropertyName(node.left)
+  if (!property) return null
+  const object = node.left.object
+  if (object.type === 'MemberExpression') {
+    return identifierName(object.object) === 'process' && memberPropertyName(object) === 'env' ? 'process.env' : null
+  }
+  return identifierName(object) === 'globalThis' ? 'globalThis' : null
+}
+
+function collectSideEffectHits(ast, file, hits) {
+  const push = (clause, pattern, node) => hits.push({ clause, pattern, file, line: node.loc?.start?.line ?? 1 })
+  walkModuleScope(ast, (node) => {
+    if (node.type === 'AwaitExpression' || (node.type === 'ForOfStatement' && node.await === true)) {
+      push('C-10.1', 'top-level await', node)
+      return
+    }
+    if (node.type === 'UnaryExpression' && node.operator === 'void' && node.argument?.type === 'CallExpression') {
+      push('C-10.2', 'top-level immediate main call', node)
+      return
+    }
+    if (node.type === 'AssignmentExpression') {
+      const kind = assignmentTargetKind(node)
+      if (kind === 'process.env') push('C-10.2', 'top-level process.env assignment', node)
+      else if (kind === 'globalThis') push('C-10.2', 'top-level globalThis assignment', node)
+      return
+    }
+    if (node.type !== 'CallExpression') return
+    if (isSetIntervalCall(node)) push('C-10.2', 'top-level setInterval', node)
+    if (isProcessOnCall(node)) push('C-10.2', 'top-level process.on', node)
+    const name = calledFunctionName(node)
+    if (name && FS_WRITE_METHODS.has(name)) push('C-10.4', 'top-level fs mutation', node)
+    if (name && C10_SUBPROCESS_METHODS.has(name)) push('C-10.4', 'top-level subprocess spawn', node)
+  })
+}
+
+function analyseImportClosure(sources, entryRelative) {
+  const byRelative = new Map()
+  for (const source of sources) byRelative.set(normalizeRelative(source.relative), source)
+  const queue = []
+  if (entryRelative) {
+    const entry = normalizeRelative(entryRelative)
+    if (!byRelative.has(entry)) return { error: `entry module ${entryRelative} was not found among scanned sources` }
+    queue.push(entry)
+  } else {
+    // Programmatic callers without an entry: keep the legacy "all sources" shape.
+    for (const relative of byRelative.keys()) queue.push(relative)
+  }
+
+  const visited = new Set()
+  const hits = []
+  const parseErrors = []
+  const coverage = []
+  const seenCoverage = new Set()
+  const localEdges = []
+  const addCoverage = (key, record) => {
+    if (seenCoverage.has(key)) return
+    seenCoverage.add(key)
+    coverage.push(record)
+  }
+
+  while (queue.length > 0) {
+    const relative = queue.shift()
+    if (visited.has(relative)) continue
+    visited.add(relative)
+    if (isDeclarationFile(relative)) {
+      addCoverage(`declaration:${relative}`, detail('C-10.3', 'NA', `not-run: declaration file ${relative} has no runtime behavior`, [relative]))
+      continue
+    }
+    const parsed = parseSource(byRelative.get(relative))
+    if (parsed.error) {
+      parseErrors.push({ file: relative, line: parsed.error.line, message: parsed.error.message })
+      continue
+    }
+    collectSideEffectHits(parsed.ast, relative, hits)
+    for (const edge of collectModuleEdges(parsed.ast)) {
+      const resolution = resolveLocalSpecifier(relative, edge.specifier, byRelative)
+      if (resolution.kind === 'local') {
+        localEdges.push({ from: relative, to: resolution.relative, line: edge.line })
+        queue.push(resolution.relative)
+      } else if (resolution.kind === 'package') {
+        addCoverage(`package:${edge.specifier}`, detail('C-10.3', 'NA', `not-run: package import '${edge.specifier}' from ${relative}:${edge.line} is outside the local closure`, [`${relative}:${edge.line}`]))
+      } else {
+        addCoverage(`unresolved:${relative}:${edge.specifier}`, detail('C-10.3', 'NA', `not-run: local import '${edge.specifier}' from ${relative}:${edge.line} could not be resolved`, [`${relative}:${edge.line}`]))
+      }
+    }
+  }
+
+  return { visited, hits, parseErrors, coverage, localEdges }
+}
+
 function hitEvidence(hits, limit = 3) {
   return hits.slice(0, limit).map(hit => `${hit.file}:${hit.line}`)
 }
 
 /** DSC-10: advisory only; never FAIL. */
-export function checkImportTimeAdvisory(sources) {
-  const patterns = [
-    { name: 'top-level await', pattern: /^await\s/m },
-    { name: 'top-level setInterval', pattern: /^setInterval\s*\(/m },
-    { name: 'top-level process.on', pattern: /^process\.on\s*\(/m },
-    { name: 'top-level process.env assignment', pattern: /^process\.env\.[A-Za-z_][A-Za-z0-9_]*\s*=/m },
-    { name: 'top-level globalThis assignment', pattern: /^globalThis\.[A-Za-z_][A-Za-z0-9_]*\s*=/m },
-  ]
-  const hits = []
-  for (const item of patterns) {
-    for (const hit of regexHits(sources, item.pattern)) hits.push({ ...hit, pattern: item.name })
+export function checkImportTimeAdvisory(sources, entryRelative = null) {
+  if (sources.length === 0) {
+    return check({
+      id: 'DSC-10',
+      clause: 'C-10',
+      layer: 'L0',
+      result: 'NA',
+      advisory: true,
+      coverage: 'not-run',
+      reason: 'no source files scanned; C-10 not-run',
+      details: [],
+      evidence: [],
+    })
+  }
+
+  const analysis = analyseImportClosure(sources, entryRelative)
+  if (analysis.error) {
+    const evidence = normalizeRelative(entryRelative)
+    return check({
+      id: 'DSC-10',
+      clause: 'C-10',
+      layer: 'L0',
+      result: 'ERROR',
+      advisory: true,
+      coverage: 'not-run',
+      reason: `${analysis.error}; C-10 not-run`,
+      details: [detail('C-10', 'ERROR', `not-run: ${analysis.error}`, [evidence])],
+      evidence: [evidence],
+    })
+  }
+
+  const { visited, hits, parseErrors, coverage, localEdges } = analysis
+  const details = hits.slice(0, 20).map(hit => detail(hit.clause, 'WARN', `${hit.pattern} at ${hit.file}:${hit.line}`, [`${hit.file}:${hit.line}`]))
+  details.push(...coverage.slice(0, 10))
+  if (localEdges.length > 0) {
+    details.push(detail('C-10.3', 'PASS', `local relative import closure analysed (${visited.size} module(s))`, [...visited].slice(0, 5)))
+  }
+  for (const error of parseErrors) {
+    details.push(detail('C-10', 'ERROR', `not-run: AST parse failed in ${error.file}:${error.line} (${error.message})`, [`${error.file}:${error.line}`]))
+  }
+
+  let result
+  let reason
+  if (parseErrors.length > 0) {
+    result = 'ERROR'
+    reason = `AST parse failed in ${parseErrors.length} file(s); C-10 not-run`
+    if (hits.length > 0) reason += `; ${hits.length} side-effect clue(s) found before the gap`
+  } else if (hits.length > 0) {
+    result = 'WARN'
+    reason = `advisory: ${hits.length} import-time side-effect clue(s)`
+  } else {
+    result = 'PASS'
+    reason = ''
   }
-  const result = hits.length > 0 ? 'WARN' : sources.length === 0 ? 'WARN' : 'PASS'
+
+  const evidence = hits.length > 0
+    ? hitEvidence(hits)
+    : parseErrors.length > 0
+      ? hitEvidence(parseErrors)
+      : coverage.flatMap(item => item.evidence).slice(0, 3)
+
   return check({
     id: 'DSC-10',
     clause: 'C-10',
     layer: 'L0',
     result,
     advisory: true,
-    reason: hits.length > 0 ? `advisory: ${hits.length} import-time side-effect clue(s)` : sources.length === 0 ? 'no source files scanned' : '',
-    details: hits.slice(0, 20).map(hit => detail('C-10.1/2', 'WARN', `${hit.pattern} at ${hit.file}:${hit.line}`, [`${hit.file}:${hit.line}`])),
-    evidence: hitEvidence(hits),
+    coverage: result === 'ERROR' ? 'not-run' : 'full',
+    reason,
+    details,
+    evidence,
   })
 }
 
@@ -116,13 +597,20 @@ export function checkCapabilities(manifest, sources, patch) {
   if (patch?.enabledPluginManagerTools) {
     details.push(detail('C-11.3', 'FAIL', 'bundle patch enables @deepseek-ai/dsh-plugin-manager/tools', ['dsh.bundle.patch']))
   }
-  const dangerHits = regexHits(sources, /danger-full-access/g)
-  if (dangerHits.length > 0) details.push(detail('C-11.4', 'WARN', 'danger-full-access literal found', hitEvidence(dangerHits)))
+  const dangerScan = findLiteralHits(sources, ['danger-full-access'])
+  if (dangerScan.hits.length > 0) {
+    details.push(detail('C-11.4', 'WARN', `danger-full-access literal in ${dangerScan.hits.length} execution context(s)`, hitEvidence(dangerScan.hits)))
+  }
+  const dangerUnparsableAll = dangerScan.parseErrors.length > 0 && dangerScan.parsedCount === 0
+  if (dangerScan.parseErrors.length > 0) {
+    details.push(detail('C-11.4', dangerUnparsableAll ? 'ERROR' : 'NA', `not-run: ${dangerScan.parseErrors.length} source file(s) could not be parsed for string literals (${dangerScan.parseErrors[0].file}:${dangerScan.parseErrors[0].line})`, hitEvidence(dangerScan.parseErrors)))
+  }
   if (details.length === 0) details.push(detail('C-11.1', 'PASS', 'dsh.capabilities is declared and consistent with static triggers'))
 
   const result = worst(details.map(item => item.result))
   return check({
     id: 'DSC-11', clause: 'C-11', layer: 'L0', result,
+    coverage: dangerUnparsableAll ? 'not-run' : dangerScan.parseErrors.length > 0 ? 'partial' : 'full',
     reason: details.filter(item => item.result !== 'PASS').map(item => `${item.item}: ${item.reason}`).join(' | '),
     details,
     evidence: ['package.json#dsh.capabilities', 'dsh.bundle.patch'],
@@ -171,13 +659,20 @@ export function checkCredentials(manifest, sources) {
 
   const providerHits = regexHits(sources, /ctx\.provide\(\s*['"](?:shell|credentials|sandboxPolicy|sandbox|deepseekAccount)['"]/g)
   if (providerHits.length > 0) details.push(detail('C-12.3', 'WARN', 'global seam provider registration detected; declaration ownership needs review', hitEvidence(providerHits)))
-  const dangerHits = regexHits(sources, /danger-full-access|--add-dir/g)
-  if (dangerHits.length > 0) details.push(detail('C-12.4', 'WARN', 'danger-full-access/--add-dir literal found', hitEvidence(dangerHits)))
+  const literalScan = findLiteralHits(sources, ['danger-full-access', '--add-dir'])
+  if (literalScan.hits.length > 0) {
+    details.push(detail('C-12.4', 'WARN', `danger-full-access/--add-dir literal in ${literalScan.hits.length} execution context(s)`, hitEvidence(literalScan.hits)))
+  }
+  const literalUnparsableAll = literalScan.parseErrors.length > 0 && literalScan.parsedCount === 0
+  if (literalScan.parseErrors.length > 0) {
+    details.push(detail('C-12.4', literalUnparsableAll ? 'ERROR' : 'NA', `not-run: ${literalScan.parseErrors.length} source file(s) could not be parsed for string literals (${literalScan.parseErrors[0].file}:${literalScan.parseErrors[0].line})`, hitEvidence(literalScan.parseErrors)))
+  }
   details.push(...validateCommitments(manifest), ...validateDisclosure(manifest))
 
   const result = worst(details.map(item => item.result))
   return check({
     id: 'DSC-12', clause: 'C-12', layer: 'L0', result,
+    coverage: literalUnparsableAll ? 'not-run' : literalScan.parseErrors.length > 0 ? 'partial' : 'full',
     reason: details.filter(item => item.result !== 'PASS' && item.result !== 'NA').map(item => `${item.item}: ${item.reason}`).join(' | '),
     details,
     evidence: ['package.json#dsh.capabilities'],

package/40-checker/src/manifest.mjs

@@ -204,6 +204,11 @@ export function runManifestChecks(dir, options = {}) {
     manifestDetails.push(detail('C-1.2', 'PASS', `entry resolves via ${entry.source}: ${entry.relative}`, [entry.relative]))
   } else if (entry.buildHint) {
     manifestDetails.push(detail('C-1.2', 'WARN', `entry not present in checkout; source/build hint exists (${entry.sourceEntry ?? 'build script'})`, ['package.json#scripts']))
+  } else if (kind === 'bundle' && patch.present) {
+    // 2026-11-04: a bundle that ships only a cordis.patch.yml has no runtime entry
+    // by design (dsh.bundle.patch is the carrier). Report NA, not WARN, so the
+    // mandatory coverage is not charged for something the package never claimed.
+    manifestDetails.push(detail('C-1.2', 'NA', 'patch-only bundle; no runtime entry by design', patch.files.map(f => f.relative)))
   } else if (kind === 'bundle' || kind === 'client') {
     manifestDetails.push(detail('C-1.2', 'WARN', `no runtime entry; ${kind} packages may be patch/client only`, ['package.json#exports']))
   } else if (Array.isArray(manifest.workspaces) || (manifest.workspaces && typeof manifest.workspaces === 'object')) {