@agentskit/doc-bridge 1.6.4 → 1.7.45

package/src/config/schema.ts

@@ -171,18 +171,60 @@ export const RuleSeveritySchema = z.enum(['off', 'info', 'warn', 'error'])
 export const RulesConfigSchema = z
   .object({
     mode: z.enum(['default', 'recommended', 'strict']).optional(),
-    severity: z.record(RuleIdSchema, RuleSeveritySchema).optional(),
+    severity: z.partialRecord(RuleIdSchema, RuleSeveritySchema).optional(),
     ignore: z.array(RuleIdSchema).max(128).optional(),
     criticalEntities: z.array(z.string().min(1).max(256)).max(128).optional(),
     criticalPaths: z.array(z.string().min(1).max(512)).max(128).optional(),
-    warningThresholds: z.record(RuleIdSchema, z.number().int().min(1).max(100_000)).optional(),
+    warningThresholds: z.partialRecord(RuleIdSchema, z.number().int().min(1).max(100_000)).optional(),
   })
   .strict()
 
 export const ReconciliationConfigSchema = z
   .object({
+    /** Semantic comparison level. Raw discovery always keeps file-level relations. */
+    scope: z.enum(['file', 'module', 'package']).optional(),
     /** Relation kinds that must have documentation declarations. Omit to require all observed kinds; [] disables this signal. */
     requiredRelationKinds: z.array(z.string().min(1).max(128)).max(128).optional(),
+    /** Limit missing-declaration findings to relations whose endpoints are internal project entities. */
+    requiredRelationTargets: z.enum(['all', 'internal']).optional(),
+    includeOrphanedDocuments: z.boolean().optional(),
+  })
+  .strict()
+
+export const AnalysisConfigSchema = z
+  .object({
+    plugins: z
+      .array(
+        z
+          .object({
+            id: z.string().regex(/^[a-z][a-z0-9-]*$/).max(128),
+            enabled: z.boolean().optional(),
+            order: z.number().int().nonnegative().optional(),
+            options: z.record(z.string(), z.unknown()).optional(),
+            reason: z.string().min(1).max(1_024).optional(),
+          })
+          .strict(),
+      )
+      .max(128)
+      .optional(),
+    jsTs: z
+      .object({
+        runtimeWiringMethods: z.array(z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/).max(64)).max(64).optional(),
+        runtimeWiringAdapters: z
+          .array(
+            z
+              .object({
+                id: z.string().min(1).max(128),
+                methods: z.array(z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/).max(64)).min(1).max(64),
+              })
+              .strict(),
+          )
+          .max(32)
+          .optional(),
+        includeTestRuntimeWiring: z.boolean().optional(),
+      })
+      .strict()
+      .optional(),
   })
   .strict()
 
@@ -203,6 +245,13 @@ export const RepositorySafetyConfigSchema = z
   })
   .strict()
 
+export const ReportConfigSchema = z
+  .object({
+    /** Public report privacy mode. Private is the default; anonymized preserves topology without project identity. */
+    privacy: z.enum(['private', 'anonymized']).optional(),
+  })
+  .strict()
+
 export const SurfacesConfigSchema = z
   .object({
     cli: z
@@ -310,6 +359,11 @@ export const IntelligenceConfigSchema = z
         agentId: z.string().min(1).max(256).optional(),
         agentRoot: z.string().min(1).max(512).optional(),
         runnerModule: z.string().min(1).max(512).optional(),
+        deterministic: z.boolean().optional(),
+        timeoutMs: z.number().int().positive().max(600_000).optional(),
+        maxTokens: z.number().int().positive().max(1_000_000).optional(),
+        maxResponseBytes: z.number().int().positive().max(10_000_000).optional(),
+        maxConcurrency: z.number().int().positive().max(64).optional(),
       })
       .strict()
       .optional(),
@@ -442,9 +496,11 @@ export const DocBridgeConfigV1Schema = z
     routing: RoutingConfigSchema.optional(),
     gates: GatesConfigSchema.optional(),
     reconciliation: ReconciliationConfigSchema.optional(),
+    analysis: AnalysisConfigSchema.optional(),
     rules: RulesConfigSchema.optional(),
     workflow: WorkflowConfigSchema.optional(),
     safety: RepositorySafetyConfigSchema.optional(),
+    report: ReportConfigSchema.optional(),
     surfaces: SurfacesConfigSchema.optional(),
     intelligence: IntelligenceConfigSchema.optional(),
     federation: FederationConfigSchema.optional(),
@@ -458,8 +514,10 @@ export type HumanCorpusConfig = z.infer<typeof HumanCorpusConfigSchema>
 export type DocumentationStandardV1Config = z.infer<typeof DocumentationStandardV1ConfigSchema>
 export type DocumentationStandardRuleId = z.infer<typeof DocumentationStandardRuleIdSchema>
 export type ReconciliationConfig = z.infer<typeof ReconciliationConfigSchema>
+export type AnalysisConfig = z.infer<typeof AnalysisConfigSchema>
 export type RuleId = z.infer<typeof RuleIdSchema>
 export type RuleSeverity = z.infer<typeof RuleSeveritySchema>
 export type RulesConfig = z.infer<typeof RulesConfigSchema>
 export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>
 export type RepositorySafetyConfig = z.infer<typeof RepositorySafetyConfigSchema>
+export type ReportConfig = z.infer<typeof ReportConfigSchema>

package/src/conformance/documentation-standard-v1.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, realpathSync } from 'node:fs'
 import { isAbsolute, relative, resolve, sep } from 'node:path'
 
 import type {
@@ -95,11 +95,10 @@ const fileEvidence = (
       evidence: { path, detail: 'Path escapes the project root.' },
     }
   }
-  if (!existsSync(abs)) {
-    return { exists: false, content: '', evidence: { path, detail: 'File does not exist.' } }
-  }
+  let fd: number | undefined
   try {
-    const stat = statSync(abs)
+    fd = openSync(abs, 'r')
+    const stat = fstatSync(fd)
     if (!stat.isFile()) {
       return { exists: false, content: '', evidence: { path, detail: 'Path is not a regular file.' } }
     }
@@ -120,7 +119,7 @@ const fileEvidence = (
         evidence: { path, detail: `Text evidence exceeds ${MAX_TEXT_EVIDENCE_BYTES} bytes.` },
       }
     }
-    const content = readFileSync(abs, 'utf8')
+    const content = readFileSync(fd, 'utf8')
     return {
       exists: content.trim().length > 0,
       content,
@@ -129,8 +128,15 @@ const fileEvidence = (
         detail: content.trim().length > 0 ? 'File exists and is non-empty.' : 'File is empty.',
       },
     }
-  } catch {
-    return { exists: false, content: '', evidence: { path, detail: 'File is not readable text.' } }
+  } catch (error) {
+    const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined
+    return {
+      exists: false,
+      content: '',
+      evidence: { path, detail: code === 'ENOENT' ? 'File does not exist.' : 'File is not readable text.' },
+    }
+  } finally {
+    if (fd !== undefined) closeSync(fd)
   }
 }
 

package/src/discovery/documentation.ts

@@ -22,6 +22,8 @@ export type DocumentationDeclarationInput = {
 export type DocumentationDeclarationOptions = {
   readonly snapshot: Pick<DiscoverySnapshotV1, 'entities'>
   readonly documentId?: string
+  /** Agent corpus root used for conservative package/app path inference. */
+  readonly agentRoot?: string
 }
 
 export type DocumentationDeclarationResult = {
@@ -71,6 +73,41 @@ const scalar = (value: string): string => {
   return trimmed
 }
 
+const isFieldName = (value: string): boolean => {
+  if (!/^[A-Za-z]/.test(value)) return false
+  for (const character of value.slice(1)) {
+    if (!/[A-Za-z0-9_-]/.test(character)) return false
+  }
+  return true
+}
+
+const parseIndentedField = (raw: string, indentation: number): { readonly key: string; readonly value: string } | undefined => {
+  const prefix = ' '.repeat(indentation)
+  if (!raw.startsWith(prefix) || raw[indentation] === ' ') return undefined
+  const body = raw.slice(indentation)
+  const separator = body.indexOf(':')
+  if (separator <= 0) return undefined
+  const key = body.slice(0, separator).trim()
+  return isFieldName(key) ? { key, value: body.slice(separator + 1).trim() } : undefined
+}
+
+const parseListItem = (raw: string, indentation: number): string | undefined => {
+  const prefix = `${' '.repeat(indentation)}-`
+  if (!raw.startsWith(prefix)) return undefined
+  const rest = raw.slice(prefix.length)
+  if (rest && !/\s/.test(rest[0] ?? '')) return undefined
+  return rest.trim()
+}
+
+const conventionalPackageReference = (path: string, agentRoot: string): string | undefined => {
+  const prefix = `${agentRoot.replace(/\/$/, '')}/`
+  if (!path.startsWith(prefix)) return undefined
+  const relative = path.slice(prefix.length)
+  const [scope, file] = relative.split('/')
+  if ((scope !== 'packages' && scope !== 'apps') || !file) return undefined
+  return file.replace(/\.mdx?$/, '')
+}
+
 const list = (value: string): string[] | undefined => {
   const trimmed = value.trim()
   if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) return undefined
@@ -103,7 +140,15 @@ const resolveEntity = (
   lineStart: number,
   unresolved: Map<string, KnowledgeEntity>,
 ): KnowledgeEntity => {
-  const resolved = entities.find((entity) => entity.id === reference || entity.aliases?.includes(reference))
+  const direct = entities.find((entity) => entity.id === reference || entity.aliases?.includes(reference))
+  if (direct) return direct
+  const packageReference = reference.replace(/^package:/, '')
+  const packageCandidates = entities.filter((entity) => {
+    if (entity.kind !== 'package') return false
+    const pathName = entity.path?.split('/').pop()
+    return entity.name === reference || entity.path === reference || pathName === packageReference || entity.name.endsWith(`/${packageReference}`)
+  })
+  const resolved = packageCandidates.length === 1 ? packageCandidates[0] : undefined
   if (resolved) return resolved
   const id = `unresolved:${reference}`
   const existing = unresolved.get(id)
@@ -123,9 +168,14 @@ const relationKey = (from: string, to: string, kind: string): string => `${from}
 
 const parseBlock = (
   input: DocumentationDeclarationInput,
+  options: Pick<DocumentationDeclarationOptions, 'agentRoot'> = {},
 ): { readonly covers: readonly { value: string; line: number }[]; readonly relations: readonly RelationFields[]; readonly diagnostics: readonly DocumentationDiagnostic[]; readonly hasDocbridge: boolean } => {
+  const conventionalPath = conventionalPackageReference(input.path, options.agentRoot ?? 'docs/for-agents')
   const frontmatter = findFrontmatter(input.content)
   if (!frontmatter) {
+    if (conventionalPath && !input.content.replace(/^\uFEFF/, '').startsWith('---')) {
+      return { covers: [{ value: conventionalPath, line: 1 }], relations: [], diagnostics: [], hasDocbridge: true }
+    }
     if (input.content.replace(/^\uFEFF/, '').startsWith('---')) {
       return {
         covers: [],
@@ -138,8 +188,24 @@ const parseBlock = (
   }
 
   const { lines, end } = frontmatter
-  const docbridgeLine = lines.findIndex((line, index) => index > 0 && index < end && /^docbridge\s*:/.test(line))
-  if (docbridgeLine < 0) return { covers: [], relations: [], diagnostics: [], hasDocbridge: false }
+  let docbridgeLine = -1
+  let typeLine = -1
+  let packageLine = -1
+  let humanDocLine = -1
+  for (let index = 1; index < end; index += 1) {
+    const line = lines[index] ?? ''
+    if (docbridgeLine < 0 && /^docbridge\s*:/.test(line)) docbridgeLine = index
+    if (typeLine < 0 && /^type\s*:/.test(line)) typeLine = index
+    if (packageLine < 0 && /^package\s*:/.test(line)) packageLine = index
+    if (humanDocLine < 0 && /^humanDoc\s*:/.test(line)) humanDocLine = index
+  }
+  if (docbridgeLine < 0) {
+    const type = typeLine >= 0 ? scalar(lines[typeLine]?.slice('type:'.length) ?? '') : ''
+    const packageReference = packageLine >= 0 ? scalar(lines[packageLine]?.slice('package:'.length) ?? '') : conventionalPath ?? ''
+    if (type === 'package' && packageReference) return { covers: [{ value: packageReference, line: packageLine >= 0 ? packageLine + 1 : typeLine + 1 }], relations: [], diagnostics: [], hasDocbridge: true }
+    if (conventionalPath) return { covers: [{ value: packageReference, line: humanDocLine >= 0 ? humanDocLine + 1 : 1 }], relations: [], diagnostics: [], hasDocbridge: true }
+    return { covers: [], relations: [], diagnostics: [], hasDocbridge: false }
+  }
 
   const diagnostics: DocumentationDiagnostic[] = []
   const covers: { value: string; line: number }[] = []
@@ -168,11 +234,10 @@ const parseBlock = (
       section = undefined
       continue
     }
-    if (/^ {2}[A-Za-z][A-Za-z0-9_-]*\s*:/.test(raw)) {
+    const sectionField = parseIndentedField(raw, 2)
+    if (sectionField) {
       finishRelation()
-      const match = /^ {2}([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(raw)
-      const key = match?.[1]
-      const value = match?.[2] ?? ''
+      const { key, value } = sectionField
       if (key !== 'covers' && key !== 'relations') {
         addDiagnostic(diagnostics, input, 'DOCBRIDGE_FIELD_UNKNOWN', `Unknown docbridge field: ${key ?? '(missing)'}.`, line)
         section = undefined
@@ -189,35 +254,36 @@ const parseBlock = (
       }
       continue
     }
-    if (section === 'covers' && /^ {4}-\s*/.test(raw)) {
-      const value = scalar(raw.replace(/^ {4}-\s*/, ''))
+    const listValue = parseListItem(raw, 4)
+    if (section === 'covers' && listValue !== undefined) {
+      const value = scalar(listValue)
       if (!value) addDiagnostic(diagnostics, input, 'DOCBRIDGE_REFERENCE_MISSING', 'covers entries must not be empty.', line)
       else covers.push({ value, line })
       continue
     }
-    if (section === 'relations' && /^ {4}-\s*/.test(raw)) {
+    if (section === 'relations' && listValue !== undefined) {
       finishRelation()
-      const firstField = /^ {4}-\s*([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(raw)
+      const firstField = parseIndentedField(`    ${listValue}`, 4)
       current = { startLine: line, endLine: line, fields: new Set() }
-      if (firstField?.[1]) {
-        current.fields.add(firstField[1])
-        current[firstField[1] as 'from' | 'to' | 'kind' | 'detection'] = scalar(firstField[2] ?? '')
-      } else if (raw.replace(/^ {4}-\s*/, '').trim()) {
+      if (firstField?.key) {
+        current.fields.add(firstField.key)
+        current[firstField.key as 'from' | 'to' | 'kind' | 'detection'] = scalar(firstField.value)
+      } else if (listValue) {
         addDiagnostic(diagnostics, input, 'DOCBRIDGE_RELATION_INVALID', 'Relation entries must be field mappings.', line)
       }
       continue
     }
-    if (section === 'relations' && current && /^ {6}[A-Za-z][A-Za-z0-9_-]*\s*:/.test(raw)) {
-      const field = /^ {6}([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(raw)
-      const key = field?.[1]
+    const field = parseIndentedField(raw, 6)
+    if (section === 'relations' && current && field) {
+      const { key, value } = field
       current.endLine = line
-      if (!key || !['from', 'to', 'kind', 'detection'].includes(key)) {
-        addDiagnostic(diagnostics, input, 'DOCBRIDGE_FIELD_UNKNOWN', `Unknown relation field: ${key ?? '(missing)'}.`, line)
+      if (!['from', 'to', 'kind', 'detection'].includes(key)) {
+        addDiagnostic(diagnostics, input, 'DOCBRIDGE_FIELD_UNKNOWN', `Unknown relation field: ${key}.`, line)
       } else if (current.fields.has(key)) {
         addDiagnostic(diagnostics, input, 'DOCBRIDGE_FIELD_DUPLICATE', `Duplicate relation field: ${key}.`, line)
       } else {
         current.fields.add(key)
-        current[key as 'from' | 'to' | 'kind' | 'detection'] = scalar(field?.[2] ?? '')
+        current[key as 'from' | 'to' | 'kind' | 'detection'] = scalar(value)
       }
       continue
     }
@@ -231,7 +297,7 @@ export const parseDocumentationDeclarations = (
   input: DocumentationDeclarationInput,
   options: DocumentationDeclarationOptions,
 ): DocumentationDeclarationResult => {
-  const parsed = parseBlock(input)
+  const parsed = parseBlock(input, options)
   if (!parsed.hasDocbridge) return { hasDocbridge: false, entities: [], relations: [], diagnostics: [] }
   const diagnostics = [...parsed.diagnostics]
   const unresolved = new Map<string, KnowledgeEntity>()
@@ -300,13 +366,14 @@ export const parseDocumentationDeclarations = (
 export const applyDocumentationDeclarations = (
   snapshot: DiscoverySnapshotV1,
   documents: readonly DocumentationDeclarationInput[],
+  options: Pick<DocumentationDeclarationOptions, 'agentRoot'> = {},
 ): DocumentationAnalysisResult => {
   const entities = new Map(snapshot.entities.map((entity) => [entity.id, entity]))
   const relations = new Map(snapshot.relations.map((relation) => [relation.id, relation]))
   const diagnostics: DocumentationDiagnostic[] = []
 
   for (const document of documents) {
-    const result = parseDocumentationDeclarations(document, { snapshot })
+    const result = parseDocumentationDeclarations(document, { snapshot, ...options })
     diagnostics.push(...result.diagnostics)
     for (const entity of result.entities) entities.set(entity.id, entity)
     for (const relation of result.relations) relations.set(relation.id, relation)

package/src/discovery/repository.ts

@@ -21,6 +21,8 @@ const SOURCE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts',
 const DOCUMENT_EXTENSIONS = ['.md', '.mdx'] as const
 const DEFAULT_MAX_FILES = 10_000
 const EMPTY_HASH = '0'.repeat(64)
+const DEFAULT_RUNTIME_WIRING_METHODS = ['register', 'use', 'mount', 'attach'] as const
+const TEST_MODULE_PATTERN = /(?:\.test|\.spec|__tests__)/
 
 type JsonRecord = Record<string, unknown>
 
@@ -42,8 +44,9 @@ type ModuleInfo = {
 
 type ImportReference = {
   readonly specifier: string
-  readonly kind: 'imports' | 're-exports'
+  readonly kind: 'imports' | 're-exports' | 'runtime-wiring'
   readonly evidence: Evidence
+  readonly detection?: 'dynamic-literal' | 'runtime-wiring-static'
 }
 
 type DiscoveryOptions = {
@@ -97,6 +100,14 @@ const firstLineContaining = (text: string, pattern: string): number | undefined
   return line >= 0 ? line + 1 : undefined
 }
 
+const documentClassification = (path: string): string => {
+  if (/(^|\/)docs\/for-agents(?:\/|$)/.test(path)) return 'agent'
+  if (/(^|\/)docs-archive(?:\/|$)/.test(path)) return 'archive'
+  if (/(^|\/)docs(?:\/|$)/.test(path)) return 'human'
+  if (/(^|\/)(README|CONTRIBUTING|SECURITY|CHANGELOG)(?:\.|$)/i.test(path)) return 'project'
+  return 'unclassified'
+}
+
 const packageName = (manifest: JsonRecord, fallback: string): string | undefined =>
   typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : fallback || undefined
 
@@ -262,30 +273,114 @@ const moduleReferences = (
   root: string,
   path: string,
   sourceFile: ts.SourceFile,
-): { readonly references: readonly ImportReference[]; readonly exports: readonly string[]; readonly hasDynamic: boolean; readonly hasRuntimeWiring: boolean } => {
+  runtimeWiringMethods: ReadonlySet<string>,
+): { readonly references: readonly ImportReference[]; readonly exports: readonly string[]; readonly dynamicEvidence: readonly Evidence[]; readonly hasDynamic: boolean; readonly hasLiteralDynamic: boolean; readonly hasRuntimeWiring: boolean; readonly hasUnresolvedRuntimeWiring: boolean } => {
   const references: ImportReference[] = []
+  const dynamicEvidence: Evidence[] = []
   let hasDynamic = false
+  let hasLiteralDynamic = false
   let hasRuntimeWiring = false
-  const addReference = (specifier: ts.StringLiteralLike, kind: ImportReference['kind'], node: ts.Node): void => {
-    references.push({ specifier: specifier.text, kind, evidence: nodeEvidence(root, path, sourceFile, node) })
+  let hasUnresolvedRuntimeWiring = false
+  const importedBindings = new Map<string, string>()
+  const staticStringBindings = new Map<string, string | undefined>()
+  const localBindings = new Set<string>()
+  const resolveStaticString = (expression: ts.Expression): string | undefined => {
+    if (ts.isStringLiteralLike(expression)) return expression.text
+    if (ts.isIdentifier(expression)) return staticStringBindings.get(expression.text)
+    if (ts.isParenthesizedExpression(expression)) return resolveStaticString(expression.expression)
+    if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = resolveStaticString(expression.left)
+      const right = resolveStaticString(expression.right)
+      return left !== undefined && right !== undefined ? left + right : undefined
+    }
+    return undefined
+  }
+  const collectStaticStringBindings = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isVariableDeclarationList(node.parent) && (node.parent.flags & ts.NodeFlags.Const) !== 0) {
+      const value = resolveStaticString(node.initializer)
+      const previous = staticStringBindings.get(node.name.text)
+      staticStringBindings.set(node.name.text, !staticStringBindings.has(node.name.text) || previous === value ? value : undefined)
+    }
+    if (
+      (ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node)) &&
+      ts.isIdentifier(node.name)
+    ) localBindings.add(node.name.text)
+    if (
+      (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) &&
+      node.name
+    ) localBindings.add(node.name.text)
+    ts.forEachChild(node, collectStaticStringBindings)
+  }
+  collectStaticStringBindings(sourceFile)
+  const addImportedBindingReference = (expression: ts.Expression, node: ts.Node): boolean => {
+    if (ts.isIdentifier(expression)) {
+      const specifier = importedBindings.get(expression.text)
+      if (specifier) {
+        addReference({ text: specifier } as ts.StringLiteralLike, 'runtime-wiring', node, 'runtime-wiring-static')
+        return true
+      }
+      return false
+    }
+    if (ts.isPropertyAccessExpression(expression)) return addImportedBindingReference(expression.expression, node)
+    if (ts.isCallExpression(expression)) return addImportedBindingReference(expression.expression, node)
+    return false
+  }
+  const isKnownLocal = (expression: ts.Expression): boolean => {
+    if (ts.isIdentifier(expression)) return localBindings.has(expression.text) || importedBindings.has(expression.text)
+    if (expression.kind === ts.SyntaxKind.ThisKeyword) return true
+    if (ts.isPropertyAccessExpression(expression)) return isKnownLocal(expression.expression)
+    if (ts.isCallExpression(expression)) return isKnownLocal(expression.expression)
+    return ts.isStringLiteralLike(expression)
+  }
+  const addReference = (specifier: ts.StringLiteralLike, kind: ImportReference['kind'], node: ts.Node, detection?: ImportReference['detection']): void => {
+    references.push({ specifier: specifier.text, kind, evidence: nodeEvidence(root, path, sourceFile, node), ...(detection ? { detection } : {}) })
   }
 
   const visit = (node: ts.Node): void => {
     if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
       addReference(node.moduleSpecifier, 'imports', node)
+      const clause = node.importClause
+      if (clause?.name) importedBindings.set(clause.name.text, node.moduleSpecifier.text)
+      if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings)) importedBindings.set(clause.namedBindings.name.text, node.moduleSpecifier.text)
+      if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+        for (const element of clause.namedBindings.elements) importedBindings.set((element.name ?? element.propertyName)?.text ?? '', node.moduleSpecifier.text)
+      }
     } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
       addReference(node.moduleSpecifier, 're-exports', node)
     } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) {
       addReference(node.moduleReference.expression, 'imports', node)
+      importedBindings.set(node.name.text, node.moduleReference.expression.text)
     } else if (ts.isCallExpression(node)) {
       if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-        if (!node.arguments[0] || !ts.isStringLiteralLike(node.arguments[0])) hasDynamic = true
+        const specifier = node.arguments[0] ? resolveStaticString(node.arguments[0]) : undefined
+        if (specifier !== undefined) {
+          hasLiteralDynamic = true
+          dynamicEvidence.push(nodeEvidence(root, path, sourceFile, node))
+          addReference({ text: specifier } as ts.StringLiteralLike, 'imports', node, 'dynamic-literal')
+        } else {
+          hasDynamic = true
+          dynamicEvidence.push(nodeEvidence(root, path, sourceFile, node))
+        }
       } else if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
         const argument = node.arguments[0]
-        if (argument && ts.isStringLiteralLike(argument)) addReference(argument, 'imports', node)
-        else hasDynamic = true
-      } else if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register') {
+        const specifier = argument ? resolveStaticString(argument) : undefined
+        if (specifier !== undefined) {
+          dynamicEvidence.push(nodeEvidence(root, path, sourceFile, node))
+          addReference({ text: specifier } as ts.StringLiteralLike, 'imports', node)
+        } else {
+          hasDynamic = true
+          dynamicEvidence.push(nodeEvidence(root, path, sourceFile, node))
+        }
+      } else if (ts.isPropertyAccessExpression(node.expression) && runtimeWiringMethods.has(node.expression.name.text)) {
         hasRuntimeWiring = true
+        let hasUnresolvedTarget = false
+        for (const argument of node.arguments) {
+          if (ts.isStringLiteralLike(argument)) continue
+          if (addImportedBindingReference(argument, node)) continue
+          if (!isKnownLocal(argument)) hasUnresolvedTarget = true
+        }
+        const receiver = node.expression.expression
+        if (hasUnresolvedTarget && !isKnownLocal(receiver)) hasUnresolvedRuntimeWiring = true
       }
     }
     ts.forEachChild(node, visit)
@@ -294,8 +389,11 @@ const moduleReferences = (
   return {
     references,
     exports: exportedNames(sourceFile),
+    dynamicEvidence,
     hasDynamic,
+    hasLiteralDynamic,
     hasRuntimeWiring,
+    hasUnresolvedRuntimeWiring,
   }
 }
 
@@ -394,11 +492,11 @@ const artifact = (root: string, config: DocBridgeConfigV1 | undefined, files: re
     sourceRevision: revision.value,
     sourceRevisionKind: revision.kind,
     configurationHash: sha256NormalizedV1(config ?? {}),
-    pipelineVersion: '1.0.0',
-    analyzerVersions: { repository: '1.0.0', 'js-ts': '1.0.0' },
+    pipelineVersion: '1.1.8',
+    analyzerVersions: { repository: '1.1.1', 'js-ts': '1.3.4' },
     entities: [...entities].sort((a, b) => a.id.localeCompare(b.id)),
     relations: [...relations].sort((a, b) => a.id.localeCompare(b.id)),
-    coverage: [...coverage],
+    coverage: coverage.map((entry) => ({ ...entry, analyzerVersion: entry.analyzerVersion ?? ({ repository: '1.1.1', 'js-ts': '1.3.4' }[entry.analyzer] ?? '1.0.0') })),
   }
   return DiscoverySnapshotV1Schema.parse({ ...base, contentHash: contentHashForArtifactV1(base) })
 }
@@ -463,13 +561,13 @@ export const discoverRepository = (opts: DiscoveryOptions = {}): DiscoverySnapsh
     const sourceFile = ts.createSourceFile(absPath, text, ts.ScriptTarget.Latest, true, scriptKind(absPath))
     const exports = exportedNames(sourceFile)
     modules.set(resolve(absPath), { absPath, path, entityId: id, ...(pkg ? { packageId: pkg.id } : {}) })
-    addEntity({ id, kind: 'module', name: basename(absPath), path, provenance: 'observed', evidence: [lineEvidence('code', root, absPath, 1, sourceFile.getLineAndCharacterOfPosition(sourceFile.getEnd()).line + 1)], ...(exports.length ? { metadata: { exports, test: /(?:\.test|\.spec|__tests__)/.test(path) } } : {}) })
+    addEntity({ id, kind: 'module', name: basename(absPath), path, provenance: 'observed', evidence: [lineEvidence('code', root, absPath, 1, sourceFile.getLineAndCharacterOfPosition(sourceFile.getEnd()).line + 1)], ...(exports.length ? { metadata: { exports, test: TEST_MODULE_PATTERN.test(path) } } : {}) })
     if (pkg) addRelation({ id: entityId('relation', `${pkg.id}:contains:${id}`), kind: 'contains', from: pkg.id, to: id, provenance: 'observed', evidence: [lineEvidence('code', root, absPath, 1)] })
   }
 
   for (const absPath of documentPaths) {
     const path = relativePath(root, absPath)
-    addEntity({ id: entityId('document', path), kind: 'document', name: basename(absPath), path, provenance: 'observed', evidence: [lineEvidence('documentation', root, absPath, 1)] })
+    addEntity({ id: entityId('document', path), kind: 'document', name: basename(absPath), path, provenance: 'observed', evidence: [lineEvidence('documentation', root, absPath, 1)], metadata: { classification: documentClassification(path) } })
   }
 
   const compiler = readCompilerOptions(root)
@@ -478,8 +576,8 @@ export const discoverRepository = (opts: DiscoveryOptions = {}): DiscoverySnapsh
     { analyzer: 'repository', scope: 'package-manager', status: hasPackageManagerMetadata(root, rootManifest) ? 'complete' : 'partial', ...(!hasPackageManagerMetadata(root, rootManifest) ? { reason: `No package manager metadata found; default helper would fall back to ${detectPackageManager(root)}.` } : {}) },
     { analyzer: 'repository', scope: 'workspace-packages', status: packageResult.coverage.some((item) => item.status === 'partial') ? 'partial' : 'complete', ...(packageResult.coverage.find((item) => item.reason)?.reason ? { reason: packageResult.coverage.find((item) => item.reason)?.reason } : {}) },
     { analyzer: 'js-ts', scope: 'static-imports-and-exports', status: compiler.error ? 'partial' : 'complete', ...(compiler.error ? { reason: compiler.error } : {}) },
-    { analyzer: 'js-ts', scope: 'dynamic-imports', status: 'not-analyzed', reason: 'Dynamic import expressions and non-literal require calls are not resolved.' },
-    { analyzer: 'js-ts', scope: 'runtime-wiring', status: 'not-analyzed', reason: 'Reflection, dependency injection and runtime wiring are not inferred.' },
+    { analyzer: 'js-ts', scope: 'dynamic-imports', status: 'not-applicable', reason: 'No dynamic loading expression was observed.' },
+    { analyzer: 'js-ts', scope: 'runtime-wiring', status: 'not-applicable', reason: 'No configured runtime-wiring call was observed.' },
     { analyzer: 'js-ts', scope: 'generated-code', status: 'not-analyzed', reason: 'Generated code is not interpreted as source architecture.' },
   ]
 
@@ -492,10 +590,28 @@ export const discoverRepository = (opts: DiscoveryOptions = {}): DiscoverySnapsh
     }
   }
 
+  const dynamicCoverageIndex = coverage.findIndex((entry) => entry.scope === 'dynamic-imports')
+  const configuredRuntimeWiringMethods = new Set([
+    ...(opts.config?.analysis?.jsTs?.runtimeWiringMethods ?? []),
+    ...(opts.config?.analysis?.jsTs?.runtimeWiringAdapters?.flatMap((adapter) => adapter.methods) ?? []),
+  ])
+  if (!configuredRuntimeWiringMethods.size) for (const method of DEFAULT_RUNTIME_WIRING_METHODS) configuredRuntimeWiringMethods.add(method)
+  const includeTestRuntimeWiring = opts.config?.analysis?.jsTs?.includeTestRuntimeWiring ?? false
+  let observedLiteralDynamic = false
+  let observedUnresolvedDynamic = false
+  const observedDynamicEvidence: Evidence[] = []
+  let observedRuntimeWiring = false
+  let observedUnresolvedRuntimeWiring = false
   for (const module of modules.values()) {
     const text = readFileSync(module.absPath, 'utf8')
     const sourceFile = ts.createSourceFile(module.absPath, text, ts.ScriptTarget.Latest, true, scriptKind(module.absPath))
-    const references = moduleReferences(root, module.absPath, sourceFile)
+    const runtimeWiringMethods = includeTestRuntimeWiring || !TEST_MODULE_PATTERN.test(module.path) ? configuredRuntimeWiringMethods : new Set<string>()
+    const references = moduleReferences(root, module.absPath, sourceFile, runtimeWiringMethods)
+    observedLiteralDynamic ||= references.hasLiteralDynamic
+    observedUnresolvedDynamic ||= references.hasDynamic
+    observedDynamicEvidence.push(...references.dynamicEvidence)
+    observedRuntimeWiring ||= references.hasRuntimeWiring
+    observedUnresolvedRuntimeWiring ||= references.hasUnresolvedRuntimeWiring
     for (const reference of references.references) {
       const target = resolveReference(reference, module.absPath, modules, packageResult.packages, compiler.options)
       if (!target) continue
@@ -503,12 +619,24 @@ export const discoverRepository = (opts: DiscoveryOptions = {}): DiscoverySnapsh
         const externalName = target.targetId.replace(/^external:/, '')
         addEntity({ id: target.targetId, kind: 'external', name: externalName, provenance: 'observed', evidence: [reference.evidence] })
       }
-      addRelation({ id: entityId('relation', `${module.entityId}:${reference.kind}:${target.targetId}`), kind: reference.kind, from: module.entityId, to: target.targetId, provenance: 'observed', evidence: [reference.evidence] })
+      addRelation({ id: entityId('relation', `${module.entityId}:${reference.kind}:${target.targetId}`), kind: reference.kind, from: module.entityId, to: target.targetId, provenance: 'observed', evidence: [reference.evidence], ...(reference.detection ? { metadata: { detection: reference.detection } } : {}) })
     }
-    if (references.hasDynamic) coverage.push({ analyzer: 'js-ts', scope: `dynamic-imports:${module.path}`, status: 'not-analyzed', reason: 'A dynamic import or non-literal require was found.', evidence: [lineEvidence('code', root, module.absPath)] })
-    if (references.hasRuntimeWiring) coverage.push({ analyzer: 'js-ts', scope: `runtime-wiring:${module.path}`, status: 'not-analyzed', reason: 'A possible runtime registration/wiring call was found.', evidence: [lineEvidence('code', root, module.absPath)] })
+    if (references.hasLiteralDynamic || references.hasDynamic) coverage.push({ analyzer: 'js-ts', scope: `dynamic-imports:${module.path}`, status: references.hasDynamic ? 'not-analyzed' : 'complete', reason: references.hasDynamic ? 'A non-literal dynamic import was found; the target is unresolved.' : 'Literal dynamic imports were resolved.', evidence: [...references.dynamicEvidence.slice(0, 32)] })
+    if (references.hasUnresolvedRuntimeWiring) coverage.push({ analyzer: 'js-ts', scope: `runtime-wiring:${module.path}`, status: 'not-analyzed', reason: 'A runtime registration/wiring call was found without a statically imported target.', evidence: [lineEvidence('code', root, module.absPath)] })
   }
 
+  if (dynamicCoverageIndex >= 0) coverage[dynamicCoverageIndex] = observedUnresolvedDynamic
+    ? { analyzer: 'js-ts', scope: 'dynamic-imports', status: 'partial', reason: 'Literal dynamic imports are resolved; non-literal import expressions and require calls remain unresolved. Evidence lists representative dynamic loading sites.', evidence: [...observedDynamicEvidence.slice(0, 32)] }
+    : observedLiteralDynamic
+      ? { analyzer: 'js-ts', scope: 'dynamic-imports', status: 'complete', reason: 'All observed dynamic imports used literal targets and were resolved.', evidence: [...observedDynamicEvidence.slice(0, 32)] }
+      : { analyzer: 'js-ts', scope: 'dynamic-imports', status: 'not-applicable', reason: 'No dynamic loading expression was observed.' }
+  const runtimeCoverageIndex = coverage.findIndex((entry) => entry.scope === 'runtime-wiring')
+  if (runtimeCoverageIndex >= 0) coverage[runtimeCoverageIndex] = observedUnresolvedRuntimeWiring
+    ? { analyzer: 'js-ts', scope: 'runtime-wiring', status: 'partial', reason: 'Some configured runtime-wiring calls remain unresolved after static binding analysis.' }
+    : observedRuntimeWiring
+      ? { analyzer: 'js-ts', scope: 'runtime-wiring', status: 'complete', reason: 'All observed configured runtime-wiring calls resolved to static bindings.' }
+      : { analyzer: 'js-ts', scope: 'runtime-wiring', status: 'not-applicable', reason: 'No configured runtime-wiring call was observed.' }
+
   return artifact(root, opts.config, allFiles, [...entities.values()], [...relations.values()], coverage)
 }