@rahmantech/knl-view 0.2.0 → 0.3.1

package/server/graph/modules_catalog.js

@@ -0,0 +1,329 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { knlGlobalDir } from '../config.js'
+
+export const SUPPORTED_ECOSYSTEMS = new Set(['npm', 'go', 'cargo', 'pypi'])
+
+/**
+ * Validate that a module name does not contain traversal tokens, null bytes, or invalid paths.
+ */
+export function isValidModuleName(name) {
+  if (!name || typeof name !== 'string') return false
+  if (name.includes('\0')) return false
+  const segments = name.replace(/\\/g, '/').split('/')
+  for (const seg of segments) {
+    if (seg === '.' || seg === '..' || !seg) return false
+  }
+  return true
+}
+
+/**
+ * Returns the path to the global modules catalog directory (~/.knlview/modules).
+ */
+export function modulesCatalogDir(home = null, options = {}) {
+  const base = knlGlobalDir(home, options)
+  return path.join(base, 'modules')
+}
+
+/**
+ * Default global AnchorDB model name for an ecosystem.
+ */
+export function defaultEcosystemModel(ecosystem) {
+  const eco = String(ecosystem || '').toLowerCase()
+  if (!SUPPORTED_ECOSYSTEMS.has(eco)) {
+    throw new Error(`Unsupported ecosystem "${ecosystem}". Supported: ${[...SUPPORTED_ECOSYSTEMS].join(', ')}`)
+  }
+  return `modules-${eco}`
+}
+
+export function formatModuleKey(pkgName, version) {
+  return `${pkgName}@${version}`
+}
+
+export function formatExternalPackageNodeId(ecosystem, pkgName, version) {
+  return `ext:${ecosystem}/${pkgName}@${version}`
+}
+
+export function formatExternalSymbolNodeId(ecosystem, pkgName, version, symbol) {
+  return `ext:${ecosystem}/${pkgName}@${version}#${symbol}`
+}
+
+/**
+ * Read the catalog for a specific ecosystem ('npm', 'go', 'cargo', 'pypi').
+ */
+export async function readModulesCatalog(ecosystem, options = {}) {
+  const eco = String(ecosystem || '').toLowerCase()
+  if (!SUPPORTED_ECOSYSTEMS.has(eco)) return {}
+  const dir = modulesCatalogDir(options.home, options)
+  const file = path.join(dir, `${eco}.json`)
+  try {
+    const raw = await fs.readFile(file, 'utf8')
+    const parsed = JSON.parse(raw)
+    return parsed && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Check if a module version is already indexed in the catalog.
+ */
+export async function isModuleSynced(ecosystem, pkgName, version, options = {}) {
+  const catalog = await readModulesCatalog(ecosystem, options)
+  const key = formatModuleKey(pkgName, version)
+  return Boolean(catalog[key]?.syncedAt)
+}
+
+/**
+ * Record discovered modules and symbols to ~/.knlview/modules/<ecosystem>.json.
+ * Stores lightweight metadata and symbolCount to avoid bloat in the local JSON catalog.
+ */
+export async function updateModulesCatalog(ecosystem, entries, options = {}) {
+  const eco = String(ecosystem || '').toLowerCase()
+  if (!SUPPORTED_ECOSYSTEMS.has(eco)) return
+  if (!entries || !Object.keys(entries).length) return
+  const dir = modulesCatalogDir(options.home, options)
+  const file = path.join(dir, `${eco}.json`)
+  try {
+    await fs.mkdir(dir, { recursive: true })
+    const existing = await readModulesCatalog(eco, options)
+    for (const [key, item] of Object.entries(entries)) {
+      const prev = existing[key] || {}
+      const symbolCount = item.symbolCount !== undefined
+        ? item.symbolCount
+        : Array.isArray(item.symbols)
+          ? item.symbols.length
+          : (prev.symbolCount || 0)
+
+      existing[key] = {
+        name: item.name,
+        version: item.version,
+        ecosystem: eco,
+        model: item.model || prev.model || defaultEcosystemModel(eco),
+        nodeId: item.nodeId || prev.nodeId || formatExternalPackageNodeId(eco, item.name, item.version),
+        symbolCount,
+        syncedAt: item.syncedAt || prev.syncedAt || Date.now()
+      }
+    }
+    await fs.writeFile(file, JSON.stringify(existing, null, 2) + '\n', 'utf8')
+  } catch {
+    // Fail gracefully: catalog is an informational index, never fatal.
+  }
+}
+
+/**
+ * Detect project dependency versions from on-disk manifests:
+ * package.json, go.mod, Cargo.toml, requirements.txt.
+ */
+export async function detectProjectManifests(rootAbs) {
+  const manifests = {
+    npm: {},
+    go: {},
+    cargo: {},
+    pypi: {}
+  }
+
+  // 1. npm (package.json)
+  try {
+    const pkgRaw = await fs.readFile(path.join(rootAbs, 'package.json'), 'utf8')
+    const pkg = JSON.parse(pkgRaw)
+    const all = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies }
+    for (const [name, ver] of Object.entries(all)) {
+      if (typeof ver === 'string') {
+        manifests.npm[name] = ver.replace(/^[\^~>=<]/, '').trim() || 'latest'
+      }
+    }
+  } catch {}
+
+  // 2. Go (go.mod)
+  try {
+    const text = await fs.readFile(path.join(rootAbs, 'go.mod'), 'utf8')
+    const singleMatch = text.matchAll(/^require\s+([^\s()]+)\s+([^\s()]+)/gm)
+    for (const m of singleMatch) manifests.go[m[1]] = m[2]
+    const blockMatch = text.match(/require\s*\(([\s\S]*?)\)/m)
+    if (blockMatch) {
+      for (const line of blockMatch[1].split('\n')) {
+        const parts = line.trim().split(/\s+/)
+        if (parts.length >= 2 && !parts[0].startsWith('//')) {
+          manifests.go[parts[0]] = parts[1]
+        }
+      }
+    }
+  } catch {}
+
+  // 3. Rust (Cargo.toml)
+  try {
+    const text = await fs.readFile(path.join(rootAbs, 'Cargo.toml'), 'utf8')
+    let inDeps = false
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim()
+      if (
+        trimmed.startsWith('[dependencies]') ||
+        trimmed.startsWith('[dev-dependencies]') ||
+        trimmed.startsWith('[build-dependencies]')
+      ) {
+        inDeps = true
+        continue
+      }
+      if (trimmed.startsWith('[')) {
+        inDeps = false
+        continue
+      }
+      if (inDeps && trimmed && !trimmed.startsWith('#')) {
+        const eqIdx = trimmed.indexOf('=')
+        if (eqIdx > 0) {
+          const name = trimmed.slice(0, eqIdx).trim()
+          const val = trimmed.slice(eqIdx + 1).trim()
+          let ver = 'unknown'
+          const strMatch = val.match(/^"([^"]+)"/)
+          if (strMatch) ver = strMatch[1]
+          const objMatch = val.match(/version\s*=\s*"([^"]+)"/)
+          if (objMatch) ver = objMatch[1]
+          manifests.cargo[name] = ver
+        }
+      }
+    }
+  } catch {}
+
+  // 4. Python (requirements.txt)
+  try {
+    const reqText = await fs.readFile(path.join(rootAbs, 'requirements.txt'), 'utf8')
+    for (const line of reqText.split('\n')) {
+      const trimmed = line.trim()
+      if (!trimmed || trimmed.startsWith('#')) continue
+      const m = trimmed.match(/^([a-zA-Z0-9_.-]+)(?:[=<>~!\s]*([a-zA-Z0-9_.-]+))?/)
+      if (m) manifests.pypi[m[1].toLowerCase()] = m[2] || 'unknown'
+    }
+  } catch {}
+
+  return manifests
+}
+
+/**
+ * Resolve the directory of an installed external module on disk.
+ * Supports npm (node_modules), Go (GOPATH/pkg/mod or vendor), Cargo (cargo cache or vendor),
+ * and Python (venv site-packages).
+ */
+export async function resolveModuleLocation(ecosystem, moduleName, options = {}) {
+  const eco = String(ecosystem || '').toLowerCase()
+  if (!SUPPORTED_ECOSYSTEMS.has(eco) || !isValidModuleName(moduleName)) return null
+  const root = path.resolve(options.projectRoot || process.cwd())
+  const manifests = options.manifests || await detectProjectManifests(root)
+
+  if (eco === 'npm') {
+    // 1. Check node_modules in projectRoot and walk up if necessary
+    let curr = root
+    let foundDir = null
+    while (true) {
+      const baseModules = path.join(curr, 'node_modules')
+      const candidate = path.resolve(baseModules, moduleName)
+      if (candidate.startsWith(baseModules + path.sep)) {
+        try {
+          const stat = await fs.stat(candidate)
+          if (stat.isDirectory()) {
+            foundDir = candidate
+            break
+          }
+        } catch {}
+      }
+      const parent = path.dirname(curr)
+      if (parent === curr) break
+      curr = parent
+    }
+
+    let version = manifests.npm[moduleName] || 'unknown'
+    if (foundDir) {
+      try {
+        const pkgText = await fs.readFile(path.join(foundDir, 'package.json'), 'utf8')
+        const pkg = JSON.parse(pkgText)
+        if (pkg.version) version = pkg.version
+      } catch {}
+      return { location: foundDir, version, name: moduleName, ecosystem: eco }
+    }
+  } else if (eco === 'go') {
+    // 1. Check local vendor
+    const vendorBase = path.join(root, 'vendor')
+    const vendorDir = path.resolve(vendorBase, moduleName)
+    if (vendorDir.startsWith(vendorBase + path.sep)) {
+      try {
+        const stat = await fs.stat(vendorDir)
+        if (stat.isDirectory()) {
+          return { location: vendorDir, version: manifests.go[moduleName] || 'vendor', name: moduleName, ecosystem: eco }
+        }
+      } catch {}
+    }
+
+    // 2. Check GOPATH
+    const gopath = process.env.GOPATH || path.join(options.home || process.env.HOME || '', 'go')
+    const version = manifests.go[moduleName]
+    if (version) {
+      const modBase = path.join(gopath, 'pkg', 'mod')
+      const modDir = path.resolve(modBase, `${moduleName}@${version}`)
+      if (modDir.startsWith(modBase + path.sep)) {
+        try {
+          const stat = await fs.stat(modDir)
+          if (stat.isDirectory()) {
+            return { location: modDir, version, name: moduleName, ecosystem: eco }
+          }
+        } catch {}
+      }
+    }
+  } else if (eco === 'cargo') {
+    // 1. Check local vendor
+    const vendorBase = path.join(root, 'vendor')
+    const vendorDir = path.resolve(vendorBase, moduleName)
+    if (vendorDir.startsWith(vendorBase + path.sep)) {
+      try {
+        const stat = await fs.stat(vendorDir)
+        if (stat.isDirectory()) {
+          return { location: vendorDir, version: manifests.cargo[moduleName] || 'vendor', name: moduleName, ecosystem: eco }
+        }
+      } catch {}
+    }
+
+    // 2. Check cargo registry cache (~/.cargo/registry/src)
+    const cargoHome = process.env.CARGO_HOME || path.join(options.home || process.env.HOME || '', '.cargo')
+    const regSrc = path.join(cargoHome, 'registry', 'src')
+    const version = manifests.cargo[moduleName]
+    try {
+      const registries = await fs.readdir(regSrc)
+      for (const reg of registries) {
+        const targetPrefix = version ? `${moduleName}-${version}` : `${moduleName}-`
+        const regDir = path.join(regSrc, reg)
+        const entries = await fs.readdir(regDir)
+        const match = entries.find((e) => version ? e === targetPrefix : e.startsWith(targetPrefix))
+        if (match) {
+          const location = path.resolve(regDir, match)
+          if (location.startsWith(regDir + path.sep)) {
+            const matchedVersion = version || match.slice(moduleName.length + 1)
+            return { location, version: matchedVersion, name: moduleName, ecosystem: eco }
+          }
+        }
+      }
+    } catch {}
+  } else if (eco === 'pypi') {
+    const version = manifests.pypi[moduleName.toLowerCase()] || 'unknown'
+    // 1. Check .venv and venv site-packages
+    const venvDirs = ['.venv', 'venv']
+    for (const venv of venvDirs) {
+      const libDir = path.join(root, venv, 'lib')
+      try {
+        const pyDirs = await fs.readdir(libDir)
+        for (const py of pyDirs) {
+          const spBase = path.join(libDir, py, 'site-packages')
+          const sp = path.resolve(spBase, moduleName)
+          if (sp.startsWith(spBase + path.sep)) {
+            try {
+              const stat = await fs.stat(sp)
+              if (stat.isDirectory()) {
+                return { location: sp, version, name: moduleName, ecosystem: eco }
+              }
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  }
+
+  return null
+}

package/server/graph/sources.js

@@ -27,8 +27,7 @@ import { createPathMatcher } from '../config.js'
 
 export const SOURCE_RELATIONS = ['imports', 'imported_by']
 export const SOURCE_TOMBSTONE = 2
-// OpStatus on the wire: 1 = Active, 2 = Archived (TOMBSTONE).
-export const OP_ACTIVE = 1
+// OpStatus on the wire: 2 = Archived (TOMBSTONE).
 export const OP_ARCHIVED = 2
 // Symbol layer, same AnchorDB model as the files: a file defines symbols,
 // symbols call symbols. Mirrored both directions like imports, for the same

package/server/graph/syntax.js

@@ -78,12 +78,14 @@ function firstDescendant(node, type) {
 function specsFromTree(grammar, tree) {
   const specs = []
   const names = []
+  const bindings = []
   const visit = (node) => {
     if (grammar === 'javascript' || grammar === 'typescript' || grammar === 'tsx') {
       if (node.type === 'import_statement' || node.type === 'export_statement') {
         const source = node.childForFieldName('source')
         const fragment = source && firstDescendant(source, 'string_fragment')
-        if (fragment) specs.push(fragment.text)
+        const specText = fragment ? fragment.text : null
+        if (specText) specs.push(specText)
         // Local binding names a qualified call may be addressed through:
         // the default import, the namespace alias, and each named import.
         for (let i = 0; i < node.childCount; i++) {
@@ -91,17 +93,25 @@ function specsFromTree(grammar, tree) {
           if (clause.type !== 'import_clause') continue
           for (let j = 0; j < clause.childCount; j++) {
             const part = clause.child(j)
-            if (part.type === 'identifier') names.push(part.text)
-            else if (part.type === 'namespace_import') {
+            if (part.type === 'identifier') {
+              names.push(part.text)
+              if (specText) bindings.push({ name: part.text, spec: specText })
+            } else if (part.type === 'namespace_import') {
               for (let k = 0; k < part.childCount; k++) {
-                if (part.child(k).type === 'identifier') names.push(part.child(k).text)
+                if (part.child(k).type === 'identifier') {
+                  names.push(part.child(k).text)
+                  if (specText) bindings.push({ name: part.child(k).text, spec: specText })
+                }
               }
             } else if (part.type === 'named_imports') {
               for (let k = 0; k < part.childCount; k++) {
                 const specifier = part.child(k)
                 if (specifier.type !== 'import_specifier') continue
                 const alias = specifier.childForFieldName('alias') || specifier.childForFieldName('name')
-                if (alias) names.push(alias.text)
+                if (alias) {
+                  names.push(alias.text)
+                  if (specText) bindings.push({ name: alias.text, spec: specText })
+                }
               }
             }
           }
@@ -111,7 +121,8 @@ function specsFromTree(grammar, tree) {
         if (fn && (fn.text === 'require' || fn.text === 'import')) {
           const args = node.childForFieldName('arguments')
           const fragment = args && firstDescendant(args, 'string_fragment')
-          if (fragment) specs.push(fragment.text)
+          const specText = fragment ? fragment.text : null
+          if (specText) specs.push(specText)
           // `const x = require('y')` / `const x = await import('y')`: the
           // declarator name is the binding: the visit starts above it, so
           // walk down from any enclosing declarator via field lookup here.
@@ -119,7 +130,10 @@ function specsFromTree(grammar, tree) {
           while (parent && parent.type === 'await_expression') parent = parent.parent
           if (parent && parent.type === 'variable_declarator') {
             const name = parent.childForFieldName('name')
-            if (name) names.push(name.text)
+            if (name) {
+              names.push(name.text)
+              if (specText) bindings.push({ name: name.text, spec: specText })
+            }
           }
         }
       }
@@ -133,8 +147,9 @@ function specsFromTree(grammar, tree) {
           // The name a qualified call uses: the declared alias, or the last
           // path segment (Go's convention when no alias is given).
           const alias = node.childForFieldName('name')
-          if (alias) names.push(alias.text)
-          else names.push(path.slice(path.lastIndexOf('/') + 1))
+          const name = alias ? alias.text : path.slice(path.lastIndexOf('/') + 1)
+          names.push(name)
+          bindings.push({ name, spec: path })
         }
       }
     } else if (grammar === 'python') {
@@ -144,12 +159,18 @@ function specsFromTree(grammar, tree) {
           if (c.type === 'dotted_name') {
             specs.push(c.text)
             const firstId = c.child(0)
-            if (firstId) names.push(firstId.text)
+            if (firstId) {
+              names.push(firstId.text)
+              bindings.push({ name: firstId.text, spec: c.text })
+            }
           } else if (c.type === 'aliased_import') {
             const name = c.childForFieldName('name')
             const alias = c.childForFieldName('alias')
             if (name) specs.push(name.text)
-            if (alias) names.push(alias.text)
+            if (alias) {
+              names.push(alias.text)
+              bindings.push({ name: alias.text, spec: name ? name.text : alias.text })
+            }
           }
         }
       } else if (node.type === 'import_from_statement') {
@@ -167,10 +188,14 @@ function specsFromTree(grammar, tree) {
           if (c.type === 'dotted_name') {
             names.push(c.text)
             if (modText) specs.push(modText + '.' + c.text)
+            bindings.push({ name: c.text, spec: modText || c.text })
           } else if (c.type === 'aliased_import') {
             const name = c.childForFieldName('name')
             const alias = c.childForFieldName('alias')
-            if (alias) names.push(alias.text)
+            if (alias) {
+              names.push(alias.text)
+              bindings.push({ name: alias.text, spec: modText || (name ? name.text : alias.text) })
+            }
             if (name && modText) specs.push(modText + '.' + name.text)
           }
         }
@@ -182,6 +207,7 @@ function specsFromTree(grammar, tree) {
           if (name) {
             specs.push('./' + name.text)
             names.push(name.text)
+            bindings.push({ name: name.text, spec: './' + name.text })
           }
         }
       } else if (node.type === 'use_declaration') {
@@ -204,16 +230,27 @@ function specsFromTree(grammar, tree) {
             const aliasNode = n.childForFieldName('alias')
             const full = (prefix ? prefix + '::' : '') + (pathNode ? pathNode.text : '')
             specs.push(full)
-            if (aliasNode) names.push(aliasNode.text)
+            const alias = aliasNode ? aliasNode.text : null
+            if (alias) {
+              names.push(alias)
+              const crateName = full.split('::')[0]
+              bindings.push({ name: alias, spec: crateName, full })
+            }
           } else if (n.type === 'scoped_identifier') {
             const full = (prefix ? prefix + '::' : '') + n.text
             specs.push(full)
             const name = n.childForFieldName('name')
-            if (name) names.push(name.text)
+            if (name) {
+              names.push(name.text)
+              const crateName = full.split('::')[0]
+              bindings.push({ name: name.text, spec: crateName, full })
+            }
           } else if (n.type === 'identifier') {
             const full = (prefix ? prefix + '::' : '') + n.text
             specs.push(full)
             names.push(n.text)
+            const crateName = full.split('::')[0]
+            bindings.push({ name: n.text, spec: crateName, full })
           }
         }
         extractRustUse(node.childForFieldName('argument'))
@@ -222,7 +259,7 @@ function specsFromTree(grammar, tree) {
     for (let i = 0; i < node.childCount; i++) visit(node.child(i))
   }
   visit(tree.rootNode)
-  return { specs, names }
+  return { specs, names, bindings }
 }
 
 /**
@@ -262,9 +299,9 @@ export async function extractCode(ext, content) {
   const parser = parserFor(grammar, lang)
   const tree = parser.parse(content)
   try {
-    const { specs: imports, names: importNames } = specsFromTree(grammar, tree)
+    const { specs: imports, names: importNames, bindings: importBindings } = specsFromTree(grammar, tree)
     const { symbols, calls } = structureFromTree(grammar, tree)
-    return { imports, importNames, symbols, calls }
+    return { imports, importNames, importBindings, symbols, calls }
   } finally {
     tree.delete()
   }

package/server/scaffold.js

@@ -90,9 +90,10 @@ export function buildAgentInstructionBlock(hasGraphify = false) {
 
   return `<!-- knl-view:start -->
 # Knowledge graph tools
-- KNL-View is the primary graph tool. For \`.knowledges\`, source graphs, and project graph questions, read the project's \`knl-view\` skill and use the relevant KNL-View feature first.
+- KNL-View is the primary graph tool. For \`.knowledges\`, source graphs, external module graphs, and project graph questions, read the project's \`knl-view\` skill and use the relevant KNL-View feature first.
 ${fallback}## KNL-View graph access
-- Use the KNL-View feature that fits the task (\`graph trace\`, \`sources trace/sync/collect\`, \`model check/new\`, consensus commands, or the viewer). Do not approximate a supported KNL-View operation with ad-hoc graph queries.
+- Use the KNL-View feature that fits the task (\`graph trace\`, \`sources trace/sync/collect\`, \`modules build-graph/trace/list\`, \`model check/new\`, consensus commands, or the viewer). Do not approximate a supported KNL-View operation with ad-hoc graph queries.
+- For third-party libraries and dependencies (\`node_modules\`, \`go mod\`, \`site-packages\`, \`crates\`): NEVER read raw library files directly. Build and query the module graph on-demand: run \`knl-view modules build-graph <eco>::<module_name>\` (e.g. \`npm::express\`, \`go::github.com/gin-gonic/gin\`), then inspect API definitions and call hierarchies via \`knl-view modules trace <eco>::<module_name> [symbol]\` to save context tokens.
 - Route all graph reads and writes through KNL-View's documented CLI, viewer, or application endpoints. Never connect to AnchorDB directly through AnchorWire, its CLI, direct database endpoints, files, SQL, or custom clients/scripts. If KNL-View cannot perform a requested operation, explain the limitation; do not bypass it.
 - Keep graph work targeted: specify the relevant node/path, direction, and smallest useful hop count; summarize only relevant nodes and edges; avoid dumping whole graphs or large raw JSON.
 - Follow the KNL-View skill's trace-before-edit and \`sources sync\`-after-change rules. Treat edge direction as lineage; do not claim causality without separate evidence.
@@ -196,7 +197,7 @@ async function statOrNull(abs) {
 // structure.
 const SKILL_MD = `---
 name: knl-view
-description: Read and maintain .knowledges knowledge bases. Use whenever a task involves a .knowledges folder, its map.json, or the knl-view viewer.
+description: Read and maintain .knowledges knowledge bases, project source dependency graphs, and on-demand external module boundary graphs (npm, go, cargo, pypi). Use whenever a task involves project architecture, dependencies, third-party libraries, .knowledges, or the knl-view viewer.
 ---
 
 # Knowledges base
@@ -366,6 +367,12 @@ file or symbol is tombstoned (attribute \`tombstone = 2\`) after its
 edges are unlinked; if it comes back, the tombstone lifts and the edges
 are relinked.
 
+External modules graph (third-party dependencies): stored in global AnchorDB
+models per ecosystem (\`modules-npm\`, \`modules-go\`, \`modules-cargo\`, \`modules-pypi\`)
+and cataloged in \`~/.knlview/modules/<eco>.json\`. Built on-demand via
+\`knl-view modules build-graph <eco>::<name>\`, avoiding polluting project models.
+Traceable via \`knl-view modules trace <eco>::<name> [symbol]\`.
+
 Decision history skill: recording architectural decisions is delegated
 to the separate decision-history skill (its decision block format is its
 own domain; this skill never writes decision blocks). If it is not
@@ -454,6 +461,10 @@ this.
 - Before renaming a symbol or moving it to another file: remember its
   record id contains the old name/path. Sync tombstones the stale record
   and creates the new one; trace by the new id afterwards.
+- Before reading raw third-party library source files:
+  run \`knl-view modules build-graph <eco>::<module>\` (e.g. \`npm::express\`, \`go::github.com/gin-gonic/gin\`)
+  to index it on-demand into global AnchorDB model \`modules-<eco>\`, then trace
+  its methods with \`knl-view modules trace <eco>::<module> [symbol]\` to save context tokens.
 - A new architectural decision: trigger the decision-history skill
   (install it first if missing; see "Decision history skill" above).
   The decision block format is that skill's domain; this skill never