@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.5

package/src/runtime/inventory/{precedence.ts → precedence.js}

@@ -63,9 +63,9 @@
  * @returns {ShadowVerdict|null} `null` when `presentScopes` carries no usable scope name — there is
  *   no asset to resolve a verdict for. Otherwise a `ShadowVerdict`.
  */
-function resolveShadowVerdict(presentScopes: any, precedence: any): any {
+function resolveShadowVerdict(presentScopes     , precedence     )      {
   const scopes = Array.isArray(presentScopes)
-    ? [...new Set(presentScopes.filter((scope: any) => typeof scope === 'string' && scope !== ''))]
+    ? [...new Set(presentScopes.filter((scope     ) => typeof scope === 'string' && scope !== ''))]
     : [];
   if (scopes.length === 0) return null;
 

package/src/runtime/inventory/{read-scopes.ts → read-scopes.js}

@@ -41,11 +41,11 @@
  */
 
 const os = require('node:os');
-const { registryLifecycleView, LIFECYCLE_HARNESSES } = require('../../lifecycle/view.ts');
-const { readLock } = require('../../state/lockfile.ts');
-const { stateRoot, readLedger } = require('../../state/index.ts');
-const { recordedMcpSelections } = require('../../install/mcp.ts');
-const { readInstallManifest } = require('../../install/manifest.ts');
+const { registryLifecycleView, LIFECYCLE_HARNESSES } = require('../../lifecycle/view.js');
+const { readLock } = require('../../state/lockfile.js');
+const { stateRoot, readLedger } = require('../../state/index.js');
+const { recordedMcpSelections } = require('../../install/mcp.js');
+const { readInstallManifest } = require('../../install/manifest.js');
 
 /**
  * @typedef {Object} ScopeSnapshot The `SCOPE_SNAPSHOT` entity of the feature's data model.
@@ -68,7 +68,7 @@ const { readInstallManifest } = require('../../install/manifest.ts');
  */
 
 /** @returns {ScopeSnapshot} */
-function snapshot(scope: any, view: any, targets: any): any {
+function snapshot(scope     , view     , targets     )      {
   const { ledger } = view;
   const wanted = new Set(targets);
   return {
@@ -77,7 +77,7 @@ function snapshot(scope: any, view: any, targets: any): any {
     stateRoot: view.stateRoot,
     recorded: ledger.resources.length > 0 || Object.keys(ledger.targets).length > 0,
     targets,
-    resources: ledger.resources.filter((resource: any) => wanted.has(resource?.harness)),
+    resources: ledger.resources.filter((resource     ) => wanted.has(resource?.harness)),
     ledger,
     plan: view.plan,
   };
@@ -104,7 +104,7 @@ function snapshot(scope: any, view: any, targets: any): any {
  *   computed from a selection nobody can read, so a currency judgement derived from it would be
  *   fiction. `reconcile` fails on the same document.
  */
-function readScopes({ registry, repoRoot, projectRoot, targets = LIFECYCLE_HARNESSES, locks }: any): any {
+function readScopes({ registry, repoRoot, projectRoot, targets = LIFECYCLE_HARNESSES, locks }     )      {
   const wanted = [...new Set(targets)];
   const resolved = locks ?? {
     // The global lock root is the home directory, the same root design R7 keeps out of this
@@ -112,7 +112,7 @@ function readScopes({ registry, repoRoot, projectRoot, targets = LIFECYCLE_HARNE
     global: readLock({ scope: 'global' }),
     project: readLock({ scope: 'project', projectRoot }),
   };
-  const read = (scope: any) => {
+  const read = (scope     ) => {
     // Each scope's own ledger, at the root the view itself reads it from.
     const ledger = readLedger(scope === 'global'
       ? stateRoot({ scope: 'global', homeDir: os.homedir() }) : stateRoot({ scope: 'project', projectRoot }));

package/src/runtime/inventory/{siblings.ts → siblings.js}

@@ -88,8 +88,8 @@ const WHOLESALE_ASSETS = Object.freeze({
 
 /** Whether this harness loads this asset's native directory wholesale. `Array.isArray` also guards
  * a harness id that collides with an `Object.prototype` key. */
-function loadsWholesale(harness: any, assetId: any): boolean {
-  const assets = (WHOLESALE_ASSETS as any)[harness];
+function loadsWholesale(harness     , assetId     )          {
+  const assets = (WHOLESALE_ASSETS       )[harness];
   return Array.isArray(assets) && assets.includes(assetId);
 }
 
@@ -98,7 +98,7 @@ function loadsWholesale(harness: any, assetId: any): boolean {
  * subdirectory holding managed assets is recognised as structure, not as a foreign entry); only
  * resources whose harness loads them wholesale contribute a `wholesale` target, and only a
  * directory with at least one of those is ever read. */
-function groupByParentDir(resources: any): any {
+function groupByParentDir(resources     )      {
   const byDir = new Map();
   const managedDirs = new Set();
   for (const resource of resources ?? []) {
@@ -119,10 +119,10 @@ function groupByParentDir(resources: any): any {
 /** Whether a directory entry is part of the managed tree's own structure — it is, or contains at
  * some depth, the parent directory of a managed resource. Scans `managedDirs`, which is bounded by
  * the number of managed resources rather than by directory size (R6). */
-function holdsManagedAsset(candidatePath: any, managedDirs: any): boolean {
+function holdsManagedAsset(candidatePath     , managedDirs     )          {
   const prefix = candidatePath + path.sep;
   for (const dir of managedDirs) {
-    if (dir === candidatePath || (dir as string).startsWith(prefix)) return true;
+    if (dir === candidatePath || (dir          ).startsWith(prefix)) return true;
   }
   return false;
 }
@@ -152,13 +152,13 @@ function holdsManagedAsset(candidatePath: any, managedDirs: any): boolean {
  * beside eight reported siblings invited the reading that eight more had been hidden. IC-002's
  * final field is dropped with it (task F.3); see `index.js#buildInventoryReport`.
  */
-function inspectSiblings({ resources, fsImpl = fs }: any = {}): any {
+function inspectSiblings({ resources, fsImpl = fs }      = {})      {
   const { byDir, managedDirs } = groupByParentDir(resources);
-  const candidatesByTarget: any = {};
+  const candidatesByTarget      = {};
   let directoriesInspected = 0;
 
   for (const [dir, { basenames, wholesale }] of byDir) {
-    if ((wholesale as any[]).length === 0) continue; // name-resolved: never read, not even to count.
+    if ((wholesale         ).length === 0) continue; // name-resolved: never read, not even to count.
 
     let entries;
     try {
@@ -168,12 +168,12 @@ function inspectSiblings({ resources, fsImpl = fs }: any = {}): any {
     }
     directoriesInspected += 1;
 
-    const unmanaged: any[] = [];
+    const unmanaged        = [];
     for (const entry of entries) {
-      const name = (entry as any).name;
-      if ((basenames as Set<string>).has(name)) continue; // the managed file itself.
-      const entryPath = path.join(dir as string, name);
-      const isDirectory = (entry as any).isDirectory?.() === true;
+      const name = (entry       ).name;
+      if ((basenames               ).has(name)) continue; // the managed file itself.
+      const entryPath = path.join(dir          , name);
+      const isDirectory = (entry       ).isDirectory?.() === true;
       if (isDirectory && holdsManagedAsset(entryPath, managedDirs)) continue; // managed structure.
       unmanaged.push({ name, path: entryPath, parentDir: dir, kind: isDirectory ? 'directory' : 'file' });
     }
@@ -181,8 +181,8 @@ function inspectSiblings({ resources, fsImpl = fs }: any = {}): any {
 
     // Attributed per managed target rather than shared, so each candidate names the harness and
     // asset whose wholesale load is the reason it is operative at all.
-    for (const { target, harness, assetId } of (wholesale as any[])) {
-      candidatesByTarget[target] = unmanaged.map((found: any) => ({ ...found, harness, assetId }));
+    for (const { target, harness, assetId } of (wholesale         )) {
+      candidatesByTarget[target] = unmanaged.map((found     ) => ({ ...found, harness, assetId }));
     }
   }
 

package/src/runtime/knowledge/{chunker.ts → chunker.js}

@@ -15,10 +15,10 @@ const HARD_MAX_CHUNK_CHARS = 1200;
 /** Split raw markdown into chunks: {id, path, section, text}. Ids are stable path+ordinal pairs,
  * not content hashes — the index manifest owns content addressing, and a chunk whose text changed
  * should keep its identity so diffs are legible. */
-function chunkMarkdown(rawText: any, { path: filePath }: { path?: string } = {}): any[] {
+function chunkMarkdown(rawText     , { path: filePath }                    = {})        {
   const { body, title } = stripFrontmatter(String(rawText ?? ''));
   const sections = splitSections(body);
-  const chunks: any[] = [];
+  const chunks        = [];
   let ordinal = 0;
   for (const section of sections) {
     for (const piece of packSection(section.text)) {
@@ -35,7 +35,7 @@ function chunkMarkdown(rawText: any, { path: filePath }: { path?: string } = {})
   return chunks;
 }
 
-function stripFrontmatter(text: string): { body: string; title: string | null } {
+function stripFrontmatter(text        )                                         {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
   if (!match) return { body: text, title: null };
   const meta = match[1];
@@ -44,10 +44,10 @@ function stripFrontmatter(text: string): { body: string; title: string | null }
 }
 
 /** Heading-bounded sections; a leading H1 is metadata (the title), not a section boundary. */
-function splitSections(body: string): Array<{ heading: string | null; text: string }> {
+function splitSections(body        )                                                  {
   const lines = body.split(/\r?\n/);
-  const sections: Array<{ heading: string | null; text: string }> = [];
-  let current: { heading: string | null; lines: string[] } = { heading: null, lines: [] };
+  const sections                                                  = [];
+  let current                                              = { heading: null, lines: [] };
   const flush = () => {
     if (current.lines.some((l) => l.trim() !== '')) {
       sections.push({ heading: current.heading, text: current.lines.join('\n') });
@@ -68,9 +68,9 @@ function splitSections(body: string): Array<{ heading: string | null; text: stri
 
 /** Group a section's blocks (paragraphs, lists, fenced code) into chunks near the target size.
  * A block larger than the hard max (a long code fence) stands alone rather than being cut. */
-function packSection(text: string): string[] {
+function packSection(text        )           {
   const blocks = splitBlocks(text).filter((b) => b.trim() !== '');
-  const packed: string[] = [];
+  const packed           = [];
   let buffer = '';
   for (const block of blocks) {
     if (block.length > HARD_MAX_CHUNK_CHARS) {
@@ -91,11 +91,11 @@ function packSection(text: string): string[] {
 }
 
 /** Split into blocks at blank lines, keeping fenced code blocks intact across their blank lines. */
-function splitBlocks(text: string): string[] {
+function splitBlocks(text        )           {
   const lines = text.split(/\r?\n/);
-  const blocks: string[] = [];
-  let buffer: string[] = [];
-  let fence: string | null = null;
+  const blocks           = [];
+  let buffer           = [];
+  let fence                = null;
   for (const line of lines) {
     const opening = /^\s*(```|~~~)/.exec(line);
     if (fence) {

package/src/runtime/knowledge/{hybrid.ts → hybrid.js}

@@ -11,9 +11,9 @@ const path = require('node:path');
  * @param {{ k?: number }} [options]
  * @returns {Array<{ id: string, rrfScore: number }>}
  */
-function reciprocalRankFusion(rankedLists: any[][], { k = 60 }: { k?: number } = {}): any[] {
-  const scores = new Map<string, number>();
-  const items = new Map<string, any>();
+function reciprocalRankFusion(rankedLists         , { k = 60 }                 = {})        {
+  const scores = new Map                ();
+  const items = new Map             ();
 
   for (const list of rankedLists) {
     if (!Array.isArray(list)) continue;
@@ -32,7 +32,7 @@ function reciprocalRankFusion(rankedLists: any[][], { k = 60 }: { k?: number } =
     }
   }
 
-  const fused: any[] = [];
+  const fused        = [];
   for (const [id, rrfScore] of scores.entries()) {
     fused.push({
       ...items.get(id),
@@ -41,7 +41,7 @@ function reciprocalRankFusion(rankedLists: any[][], { k = 60 }: { k?: number } =
     });
   }
 
-  fused.sort((a: any, b: any) => b.rrfScore - a.rrfScore || (a.id < b.id ? -1 : 1));
+  fused.sort((a     , b     ) => b.rrfScore - a.rrfScore || (a.id < b.id ? -1 : 1));
   return fused;
 }
 
@@ -51,7 +51,7 @@ function reciprocalRankFusion(rankedLists: any[][], { k = 60 }: { k?: number } =
  * @param {string} [projectRoot]
  * @returns {{ file: string, line?: number, endLine?: number }}
  */
-function normalizeLocator(raw: any, projectRoot: string = process.cwd()): { file: string; line?: number; endLine?: number } {
+function normalizeLocator(raw     , projectRoot         = process.cwd())                                                    {
   if (!raw) return { file: '' };
   if (typeof raw === 'string') {
     const match = raw.match(/^([^:]+)(?::(\d+))?(?::(\d+))?$/);
@@ -97,22 +97,22 @@ function fuseHybridResults({
   projectRoot = process.cwd(),
   maxSnippetLines = 50,
   fsImpl = fs,
-}: {
-  lexicalResults?: any[];
-  semanticResults?: any[];
-  k?: number;
-  topN?: number;
-  projectRoot?: string;
-  maxSnippetLines?: number;
-  fsImpl?: any;
-} = {}): any[] {
-  const normLex = (Array.isArray(lexicalResults) ? lexicalResults : []).map((item: any, idx: number) => {
+}   
+                         
+                          
+             
+                
+                       
+                           
+               
+  = {})        {
+  const normLex = (Array.isArray(lexicalResults) ? lexicalResults : []).map((item     , idx        ) => {
     const loc = normalizeLocator(item.locator || item.path || item.file, projectRoot);
     const id = `${loc.file}:${loc.line || 1}`;
     return { ...item, id, locator: loc, sourceList: 'lexical', originalRank: idx };
   });
 
-  const normSem = (Array.isArray(semanticResults) ? semanticResults : []).map((item: any, idx: number) => {
+  const normSem = (Array.isArray(semanticResults) ? semanticResults : []).map((item     , idx        ) => {
     const loc = normalizeLocator(item.locator || item.path || item.file, projectRoot);
     const id = `${loc.file}:${loc.line || 1}`;
     return { ...item, id, locator: loc, sourceList: 'semantic', originalRank: idx };

package/src/runtime/knowledge/{index-store.ts → index-store.js}

@@ -11,23 +11,23 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { chunkMarkdown } = require('./chunker.ts');
+const { chunkMarkdown } = require('./chunker.js');
 
 const INDEX_VERSION = 1;
 const MANIFEST_FILE = 'manifest.json';
 const CHUNKS_FILE = 'chunks.jsonl';
 
-function sha256(buffer: any): string {
+function sha256(buffer     )         {
   return crypto.createHash('sha256').update(buffer).digest('hex');
 }
 
 /** Every .md file under the corpus root, as sorted relative paths (deterministic builds). */
-function listMarkdownFiles(corpusDir: string, { fsImpl = fs }: { fsImpl?: any } = {}): string[] {
-  const out: string[] = [];
-  const walk = (dir: string) => {
-    let entries: any[];
+function listMarkdownFiles(corpusDir        , { fsImpl = fs }                   = {})           {
+  const out           = [];
+  const walk = (dir        ) => {
+    let entries       ;
     try { entries = fsImpl.readdirSync(dir, { withFileTypes: true }); } catch { return; }
-    entries.sort((a: any, b: any) => (a.name < b.name ? -1 : 1));
+    entries.sort((a     , b     ) => (a.name < b.name ? -1 : 1));
     for (const entry of entries) {
       const abs = path.join(dir, entry.name);
       if (entry.isDirectory()) walk(abs);
@@ -38,22 +38,22 @@ function listMarkdownFiles(corpusDir: string, { fsImpl = fs }: { fsImpl?: any }
   return out.sort((a, b) => (a < b ? -1 : 1));
 }
 
-function readManifest(indexDir: string, { fsImpl = fs }: { fsImpl?: any } = {}): any {
+function readManifest(indexDir        , { fsImpl = fs }                   = {})      {
   try {
     return JSON.parse(fsImpl.readFileSync(path.join(indexDir, MANIFEST_FILE), 'utf8'));
   } catch { return null; }
 }
 
-function loadChunksByPath(indexDir: string, { fsImpl = fs }: { fsImpl?: any } = {}): Map<string, any[]> {
-  const byPath = new Map<string, any[]>();
-  let raw: string;
+function loadChunksByPath(indexDir        , { fsImpl = fs }                   = {})                     {
+  const byPath = new Map               ();
+  let raw        ;
   try { raw = fsImpl.readFileSync(path.join(indexDir, CHUNKS_FILE), 'utf8'); } catch { return byPath; }
   for (const line of raw.split('\n')) {
     if (!line.trim()) continue;
-    let chunk: any;
+    let chunk     ;
     try { chunk = JSON.parse(line); } catch { continue; }
     if (!byPath.has(chunk.path)) byPath.set(chunk.path, []);
-    byPath.get(chunk.path)!.push(chunk);
+    byPath.get(chunk.path) .push(chunk);
   }
   return byPath;
 }
@@ -61,22 +61,22 @@ function loadChunksByPath(indexDir: string, { fsImpl = fs }: { fsImpl?: any } =
 /** Build (or incrementally refresh) the index. Files whose digest already sits in the manifest
  * reuse their stored chunks byte-for-byte; only changed or new files are re-chunked. Returns
  * {files, chunks, rebuilt[], reusedCount}. */
-function buildIndex({ corpusDir, indexDir, fsImpl = fs }: { corpusDir: string; indexDir: string; fsImpl?: any } = {} as any): any {
+function buildIndex({ corpusDir, indexDir, fsImpl = fs }                                                        = {}       )      {
   const relPaths = listMarkdownFiles(corpusDir, { fsImpl });
   const previous = readManifest(indexDir, { fsImpl });
   const previousFiles = previous?.files ?? {};
   const reusableChunks = loadChunksByPath(indexDir, { fsImpl });
 
-  const files: Record<string, any> = {};
-  const allChunks: any[] = [];
-  const rebuilt: string[] = [];
+  const files                      = {};
+  const allChunks        = [];
+  const rebuilt           = [];
   let reusedCount = 0;
   for (const rel of relPaths) {
     const content = fsImpl.readFileSync(path.join(corpusDir, rel), 'utf8');
     const digest = sha256(Buffer.from(content, 'utf8'));
     const prior = previousFiles[rel];
     if (prior && prior.digest === digest && reusableChunks.has(rel)) {
-      const chunks = reusableChunks.get(rel)!;
+      const chunks = reusableChunks.get(rel) ;
       files[rel] = { digest, chunks: chunks.length };
       allChunks.push(...chunks);
       reusedCount += 1;
@@ -89,7 +89,7 @@ function buildIndex({ corpusDir, indexDir, fsImpl = fs }: { corpusDir: string; i
   }
 
   fsImpl.mkdirSync(indexDir, { recursive: true });
-  const body = allChunks.map((chunk: any) => JSON.stringify(chunk)).join('\n') + (allChunks.length ? '\n' : '');
+  const body = allChunks.map((chunk     ) => JSON.stringify(chunk)).join('\n') + (allChunks.length ? '\n' : '');
   const tmpChunks = `${path.join(indexDir, CHUNKS_FILE)}.${process.pid}.tmp`;
   fsImpl.writeFileSync(tmpChunks, body, 'utf8');
   fsImpl.renameSync(tmpChunks, path.join(indexDir, CHUNKS_FILE));
@@ -108,11 +108,11 @@ function buildIndex({ corpusDir, indexDir, fsImpl = fs }: { corpusDir: string; i
 
 /** Load the index for querying. Returns null when absent/malformed; staleness is the caller's
  * policy decision (see ensureFreshIndex), never a silent assumption here. */
-function loadIndex({ indexDir, fsImpl = fs }: { indexDir: string; fsImpl?: any } = {} as any): any {
+function loadIndex({ indexDir, fsImpl = fs }                                     = {}       )      {
   const manifest = readManifest(indexDir, { fsImpl });
   if (!manifest || manifest.version !== INDEX_VERSION) return null;
-  const chunks: any[] = [];
-  let raw: string;
+  const chunks        = [];
+  let raw        ;
   try { raw = fsImpl.readFileSync(path.join(indexDir, CHUNKS_FILE), 'utf8'); } catch { return null; }
   for (const line of raw.split('\n')) {
     if (!line.trim()) continue;
@@ -123,7 +123,7 @@ function loadIndex({ indexDir, fsImpl = fs }: { indexDir: string; fsImpl?: any }
 
 /** True when every corpus file's current digest matches the manifest. Missing extra corpus files
  * (present on disk, absent from the manifest) also count as stale — they are not yet searchable. */
-function isFresh({ corpusDir, indexDir, fsImpl = fs }: { corpusDir: string; indexDir: string; fsImpl?: any } = {} as any): boolean {
+function isFresh({ corpusDir, indexDir, fsImpl = fs }                                                        = {}       )          {
   const manifest = readManifest(indexDir, { fsImpl });
   if (!manifest) return false;
   const relPaths = listMarkdownFiles(corpusDir, { fsImpl });

package/src/runtime/knowledge/{retrieval.ts → retrieval.js}

@@ -10,9 +10,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { buildIndex, loadIndex, isFresh } = require('./index-store.ts');
-const { finishRuntime, usageError, captureCaught } = require('../cli-result.ts');
-const { resolveRunsLocation } = require('../trace/ledger.ts');
+const { buildIndex, loadIndex, isFresh } = require('./index-store.js');
+const { finishRuntime, usageError, captureCaught } = require('../cli-result.js');
+const { resolveRunsLocation } = require('../trace/ledger.js');
 
 const BM25_K1 = 1.5;
 const BM25_B = 0.75;
@@ -22,7 +22,7 @@ const STOPWORDS = new Set([
   'do', 'does', 'did', 'how', 'what', 'when', 'which', 'who', 'why', 'not', 'no', 'yes', 'can',
 ]);
 
-function tokenize(text: any): string[] {
+function tokenize(text     )           {
   return String(text ?? '')
     .toLowerCase()
     .split(/[^a-z0-9]+/)
@@ -31,24 +31,24 @@ function tokenize(text: any): string[] {
 
 /** Deterministic BM25 (Okapi) over preloaded chunks. Corpus sizes here are thousands of chunks at
  * most, so scoring at query time from plain arrays beats maintaining incremental postings. */
-function bm25Rank(queryText: string, chunks: any[], { k = 5 }: { k?: number } = {}): any[] {
+function bm25Rank(queryText        , chunks       , { k = 5 }                 = {})        {
   const queryTerms = [...new Set(tokenize(queryText))];
   if (!queryTerms.length || !chunks.length) return [];
-  const docTokens = chunks.map((chunk: any) => tokenize(`${chunk.title ?? ''} ${chunk.text}`));
-  const avgLen = docTokens.reduce((sum: number, tokens: string[]) => sum + tokens.length, 0) / docTokens.length || 1;
+  const docTokens = chunks.map((chunk     ) => tokenize(`${chunk.title ?? ''} ${chunk.text}`));
+  const avgLen = docTokens.reduce((sum        , tokens          ) => sum + tokens.length, 0) / docTokens.length || 1;
 
-  const df = new Map<string, number>();
+  const df = new Map                ();
   for (const term of queryTerms) {
     let count = 0;
     for (const tokens of docTokens) if (tokens.includes(term)) count += 1;
     df.set(term, count);
   }
 
-  const scored: Array<{ score: number; chunk: any }> = [];
+  const scored                                       = [];
   for (let i = 0; i < chunks.length; i += 1) {
     const tokens = docTokens[i];
     if (!tokens.length) continue;
-    const tf = new Map<string, number>();
+    const tf = new Map                ();
     for (const token of tokens) tf.set(token, (tf.get(token) ?? 0) + 1);
     let score = 0;
     for (const term of queryTerms) {
@@ -67,17 +67,17 @@ function bm25Rank(queryText: string, chunks: any[], { k = 5 }: { k?: number } =
 /** Registry-derived document graph: every `@file.md` import inside a corpus document is an edge.
  * Guidance's own path-anchor rule makes these resolvable against the corpus root, which turns the
  * content itself into the knowledge graph — no LLM extraction, no external store. */
-function buildImportGraph(corpusDir: string, { fsImpl = fs }: { fsImpl?: any } = {}): Map<string, string[]> {
-  const edges = new Map<string, string[]>();
+function buildImportGraph(corpusDir        , { fsImpl = fs }                   = {})                        {
+  const edges = new Map                  ();
   try { fsImpl.readdirSync(corpusDir); } catch { return edges; }
-  const walk = (dir: string, rel: string) => {
+  const walk = (dir        , rel        ) => {
     for (const entry of fsImpl.readdirSync(dir, { withFileTypes: true })) {
       const abs = path.join(dir, entry.name);
       const relPath = rel ? `${rel}/${entry.name}` : entry.name;
       if (entry.isDirectory()) { walk(abs, relPath); continue; }
       if (!entry.name.toLowerCase().endsWith('.md')) continue;
       const text = (() => { try { return fsImpl.readFileSync(abs, 'utf8'); } catch { return ''; } })();
-      const targets = new Set<string>();
+      const targets = new Set        ();
       for (const match of text.matchAll(/(?:^|\s)@([^\s`]+\.md)\b/g)) {
         const target = path.posix.normalize(match[1].replace(/^\.\//, ''));
         if (target.startsWith('..') || path.isAbsolute(target)) continue;
@@ -93,17 +93,17 @@ function buildImportGraph(corpusDir: string, { fsImpl = fs }: { fsImpl?: any } =
 /** Expand BM25 hits along import edges (1 hop): a linked document is "what to read next" for the
  * question that surfaced its anchor. Graph results are capped separately and never displace
  * lexical hits — they extend the answer instead of reranking it. */
-function expandViaGraph(hits: any[], chunks: any[], graph: Map<string, string[]>, { maxExtra = 3 }: { maxExtra?: number } = {}): any[] {
-  const hitPaths = new Set(hits.map((h: any) => h.path));
-  const seen = new Set<string>();
-  const extras: any[] = [];
+function expandViaGraph(hits       , chunks       , graph                       , { maxExtra = 3 }                        = {})        {
+  const hitPaths = new Set(hits.map((h     ) => h.path));
+  const seen = new Set        ();
+  const extras        = [];
   for (const hit of hits) {
     for (const target of graph.get(hit.path) ?? []) {
       if (hitPaths.has(target) || seen.has(target)) continue;
       seen.add(target);
-      const linkedChunks = chunks.filter((c: any) => c.path === target);
+      const linkedChunks = chunks.filter((c     ) => c.path === target);
       if (!linkedChunks.length) continue;
-      const best = linkedChunks.reduce((a: any, b: any) => (b.text.length > a.text.length ? b : a));
+      const best = linkedChunks.reduce((a     , b     ) => (b.text.length > a.text.length ? b : a));
       extras.push({
         path: best.path,
         title: best.title,
@@ -119,18 +119,18 @@ function expandViaGraph(hits: any[], chunks: any[], graph: Map<string, string[]>
 
 /** Ensure the on-disk index matches the corpus, rebuilding only what changed, then rank.
  * Returns {results, rebuilt}. A missing corpus is the caller's usage problem, thrown loudly. */
-function searchGuidance({ corpusDir, indexDir, query, k = 5, fsImpl = fs }: { corpusDir: string; indexDir: string; query: string; k?: number; fsImpl?: any } = {} as any): any {
+function searchGuidance({ corpusDir, indexDir, query, k = 5, fsImpl = fs }                                                                                   = {}       )      {
   if (!fsImpl.existsSync(corpusDir)) {
     throw new Error(`No guidance tree found at '${corpusDir}' — run \`doflow install\` first`);
   }
-  let rebuiltFiles: string[] | null = null;
+  let rebuiltFiles                  = null;
   if (!isFresh({ corpusDir, indexDir, fsImpl })) {
     const build = buildIndex({ corpusDir, indexDir, fsImpl });
     rebuiltFiles = build.rebuilt;
   }
   const loaded = loadIndex({ indexDir, fsImpl });
   if (!loaded) throw new Error(`Index at '${indexDir}' is unreadable after rebuild`);
-  const ranked = bm25Rank(query, loaded.chunks, { k }).map((hit: any) => ({
+  const ranked = bm25Rank(query, loaded.chunks, { k }).map((hit     ) => ({
     path: hit.path,
     title: hit.title,
     score: Number(hit.score.toFixed(4)),
@@ -145,7 +145,7 @@ function searchGuidance({ corpusDir, indexDir, query, k = 5, fsImpl = fs }: { co
  * code from this install, knowledge from the project being worked on. The `.doflow` root is
  * $DOFLOW_CONFIG_DIR, else the nearest one above `stateRoot` that holds a guidance tree, else the
  * home install; the index is kept beside the corpus chosen. */
-function handleRetrieveCommand({ query, top, json = false, stateRoot }: { query?: any; top?: any; json?: boolean; stateRoot?: any } = {}): any {
+function handleRetrieveCommand({ query, top, json = false, stateRoot }                                                              = {})      {
   const { configDir } = resolveRunsLocation({ start: stateRoot, containing: 'guidance' });
   const corpusDir = path.join(configDir, 'guidance');
   const indexDir = path.join(configDir, 'index', 'guidance');
@@ -161,13 +161,13 @@ function handleRetrieveCommand({ query, top, json = false, stateRoot }: { query?
     } else if (!results.length) {
       console.log('[OK] No matching guidance found.');
     } else {
-      results.forEach((result: any, i: number) => {
+      results.forEach((result     , i        ) => {
         console.log(`${i + 1}. [${result.score}] ${result.path}${result.title ? ` — ${result.title}` : ''}`);
         console.log(`   ${result.snippet}`);
       });
     }
     return finishRuntime(0);
-  } catch (error: any) {
+  } catch (error     ) {
     captureCaught(error, 'retrieve', 1);
     console.error(`[ERROR] retrieve: ${error.message}`);
     return finishRuntime(1);
@@ -178,7 +178,7 @@ const {
   reciprocalRankFusion,
   normalizeLocator,
   fuseHybridResults,
-} = require('./hybrid.ts');
+} = require('./hybrid.js');
 
 module.exports = {
   bm25Rank,

package/src/runtime/{leak-scan.ts → leak-scan.js}

@@ -4,7 +4,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { finishRuntime, usageError } = require('./cli-result.ts');
+const { finishRuntime, usageError } = require('./cli-result.js');
 
 /**
  * Reports DoFlow's own process vocabulary appearing in files that ship to people who never used
@@ -44,7 +44,7 @@ const DEFAULT_EXCLUDED_SEGMENTS = ['agent-docs'];
 // here as an exported Set that nothing read, including no test: a second place to keep the list
 // correct, with nothing to notice when the two disagreed.
 
-function isExcluded(relPath: string, excludedSegments: string[]): boolean {
+function isExcluded(relPath        , excludedSegments          )          {
   const segments = relPath.split(path.sep);
   return excludedSegments.some((seg) => segments.includes(seg));
 }
@@ -58,7 +58,7 @@ function isExcluded(relPath: string, excludedSegments: string[]): boolean {
  *
  * @returns {{relative: string, content: string}|{relative: string, reason: string}}
  */
-function readScannable(target: string, root: string, excluded: string[], impl: any): { relative: string; content?: string; reason?: string } {
+function readScannable(target        , root        , excluded          , impl     )                                                          {
   const absolute = path.isAbsolute(target) ? target : path.join(root, target);
   const relative = path.relative(root, absolute);
 
@@ -77,8 +77,8 @@ function readScannable(target: string, root: string, excluded: string[], impl: a
 }
 
 /** Every pattern match in one file's lines, as finding records. */
-function findLeaksInLines(lines: string[], relative: string): any[] {
-  const findings: any[] = [];
+function findLeaksInLines(lines          , relative        )        {
+  const findings        = [];
   for (let i = 0; i < lines.length; i += 1) {
     for (const rule of LEAK_PATTERNS) {
       const match = lines[i].match(rule.pattern);
@@ -104,14 +104,14 @@ function findLeaksInLines(lines: string[], relative: string): any[] {
  * @param {Object} [options.fsImpl] injectable fs, for tests
  * @returns {{findings: Array, scanned: string[], unscanned: Array}}
  */
-function scanPaths({ paths: targets, repoRoot, excludedSegments, fsImpl }: any = {}): { findings: any[]; scanned: string[]; unscanned: any[] } {
+function scanPaths({ paths: targets, repoRoot, excludedSegments, fsImpl }      = {})                                                           {
   const impl = fsImpl || fs;
   const root = repoRoot || process.cwd();
   const excluded = excludedSegments || DEFAULT_EXCLUDED_SEGMENTS;
 
-  const findings: any[] = [];
-  const scanned: string[] = [];
-  const unscanned: any[] = [];
+  const findings        = [];
+  const scanned           = [];
+  const unscanned        = [];
 
   for (const target of targets || []) {
     if (typeof target !== 'string' || target.trim() === '') continue;
@@ -123,7 +123,7 @@ function scanPaths({ paths: targets, repoRoot, excludedSegments, fsImpl }: any =
     }
 
     scanned.push(read.relative);
-    findings.push(...findLeaksInLines((read.content as string).split('\n'), read.relative));
+    findings.push(...findLeaksInLines((read.content          ).split('\n'), read.relative));
   }
 
   return { findings, scanned, unscanned };
@@ -140,14 +140,14 @@ function scanPaths({ paths: targets, repoRoot, excludedSegments, fsImpl }: any =
  * @param {string} [options.repoRoot]
  * @returns {number} exit code
  */
-function handleLeakScanCommand({ paths: targets, exclude, json = false, repoRoot }: any = {}): number {
+function handleLeakScanCommand({ paths: targets, exclude, json = false, repoRoot }      = {})         {
   if (!Array.isArray(targets) || targets.length === 0) {
     return usageError('leak-scan', '--path is required (repeatable): the files to scan', json);
   }
 
   // `--exclude` extends the built-in artifact-directory exclusion rather than replacing it: a
   // caller narrowing the scan should not be able to accidentally widen it back over agent-docs/.
-  const extra = Array.isArray(exclude) ? exclude.filter((e: any) => typeof e === 'string' && e.trim() !== '') : [];
+  const extra = Array.isArray(exclude) ? exclude.filter((e     ) => typeof e === 'string' && e.trim() !== '') : [];
   const excludedSegments = [...DEFAULT_EXCLUDED_SEGMENTS, ...extra];
 
   const result = scanPaths({ paths: targets, repoRoot, excludedSegments });