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

package/src/runtime/scaffold/{generate.ts → generate.js}

@@ -58,9 +58,9 @@
 
 const nodeFs = require('node:fs');
 const path = require('node:path');
-const { finishRuntime } = require('../cli-result.ts');
-const { resolveActiveFeature } = require('../feature-resolve.ts');
-const { parseRequirement, parseDesign, parsePlan } = require('./artifacts.ts');
+const { finishRuntime } = require('../cli-result.js');
+const { resolveActiveFeature } = require('../feature-resolve.js');
+const { parseRequirement, parseDesign, parsePlan } = require('./artifacts.js');
 const {
   EXTENSION_LANGUAGE,
   PROSE_EXTENSIONS,
@@ -71,14 +71,14 @@ const {
   snake,
   EMITTERS,
   repoLanguage,
-} = require('./languages.ts');
+} = require('./languages.js');
 const {
   FINGERPRINT_MARKER,
   FINGERPRINT_RE,
   sha256,
   compose,
   inspectExisting,
-} = require('./fingerprint.ts');
+} = require('./fingerprint.js');
 
 // `handleScaffoldCommand` reads through the plain `fs` binding it had when it lived in bin/doflow.js;
 // aliased to the `node:fs` module this file already imports as `nodeFs`.
@@ -102,7 +102,7 @@ const MANIFEST_NAME = 'MANIFEST.md';
  * One suffix on everything rather than a per-toolchain exclusion list, because the invariant worth
  * having is stronger than "no runner we currently know about picks this up": nothing in the
  * scaffold is loadable by any toolchain until a human deliberately drops the suffix. The mirrored
- * layout stays legible either way — `src/runtime/scaffold/generate.ts.stub` reads as exactly what it is.
+ * layout stays legible either way — `src/runtime/scaffold/generate.js.stub` reads as exactly what it is.
  *
  * Part 2's `contracts/` frames deliberately do not carry it: `default/` exists to be compiled
  * against, and its tree contains no directory a test runner sweeps.
@@ -111,16 +111,16 @@ const STUB_SUFFIX = '.stub';
 
 /** The three chain artifacts, in the order a reader meets them. All three are required: a scaffold
  * missing one of them is a scaffold with no traceability, no shape, or no file list. */
-const ARTIFACTS: readonly string[] = Object.freeze(['requirement.md', 'design.md', 'plan.md']);
+const ARTIFACTS                    = Object.freeze(['requirement.md', 'design.md', 'plan.md']);
 
 /**
  * Uniform exit codes, matching design §4.2's contract for every DoFlow verb.
  * `1` is "a finding the caller must act on" — which includes an unparseable artifact, so a caller
  * that only checks for a crash still sees the difference between a full and a partial scaffold.
  */
-const EXIT: Readonly<Record<string, number>> = Object.freeze({ OK: 0, FINDING: 1, USAGE: 2 });
+const EXIT                                   = Object.freeze({ OK: 0, FINDING: 1, USAGE: 2 });
 
-const STATUS: Readonly<Record<string, string>> = Object.freeze({
+const STATUS                                   = Object.freeze({
   COMPLETE: 'COMPLETE',
   INCOMPLETE: 'INCOMPLETE',
   BLOCKED: 'BLOCKED',
@@ -136,16 +136,16 @@ const STATUS: Readonly<Record<string, string>> = Object.freeze({
 // `scaffold-languages.js` and `scaffold-artifacts.js` respectively — required above. What is left
 // here is generic and used only by the generator below.
 
-function readIfPresent(file: string, fsImpl: any): string | null {
+function readIfPresent(file        , fsImpl     )                {
   try {
     return fsImpl.readFileSync(file, 'utf8');
-  } catch (error: any) {
+  } catch (error     ) {
     if (error && ['ENOENT', 'ENOTDIR', 'EISDIR'].includes(error.code)) return null;
     throw error;
   }
 }
 
-function isDirectory(file: string, fsImpl: any): boolean {
+function isDirectory(file        , fsImpl     )          {
   try {
     return fsImpl.statSync(file).isDirectory();
   } catch {
@@ -154,11 +154,11 @@ function isDirectory(file: string, fsImpl: any): boolean {
 }
 
 /** Table cells are pipe-delimited; an unescaped pipe in a task description would shear the row. */
-const cell = (text: any): string => String(text ?? '').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ').trim();
+const cell = (text     )         => String(text ?? '').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ').trim();
 
 /** Sorts by a string key without depending on locale collation, which varies by platform and would
  * make "re-running produces no diff" false across machines. */
-const byKey = (key: (a: any) => any) => (a: any, b: any) => (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
+const byKey = (key                 ) => (a     , b     ) => (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
 
 // ---------------------------------------------------------------------------------------------
 // Generator
@@ -178,10 +178,10 @@ const byKey = (key: (a: any) => any) => (a: any, b: any) => (key(a) < key(b) ? -
  * @param {Object} fsImpl
  * @returns {{ sources: Array<Object>, notEvaluated: Array<Object>, texts: Object }}
  */
-function readArtifacts(featureDir: string, fsImpl: any): { sources: any[]; notEvaluated: any[]; texts: Record<string, string | null> } {
-  const sources: any[] = [];
-  const notEvaluated: any[] = [];
-  const texts: Record<string, string | null> = {};
+function readArtifacts(featureDir        , fsImpl     )                                                                                {
+  const sources        = [];
+  const notEvaluated        = [];
+  const texts                                = {};
   for (const name of ARTIFACTS) {
     const text = readIfPresent(path.join(featureDir, name), fsImpl);
     texts[name] = text;
@@ -199,11 +199,11 @@ function readArtifacts(featureDir: string, fsImpl: any): { sources: any[]; notEv
  * @param {Object} texts keyed by artifact name, from `readArtifacts`
  * @returns {{ requirement: Object, design: Object, plan: Object, notEvaluated: Array<Object> }}
  */
-function parseArtifacts(texts: Record<string, string | null>): { requirement: any; design: any; plan: any; notEvaluated: any[] } {
+function parseArtifacts(texts                               )                                                                    {
   const requirement = texts['requirement.md'] ? parseRequirement(texts['requirement.md']) : { requirements: new Map(), criteria: [], gaps: [] };
   const design = texts['design.md'] ? parseDesign(texts['design.md']) : { components: new Map(), gaps: [] };
   const plan = texts['plan.md'] ? parsePlan(texts['plan.md']) : { tasks: [], gaps: [] };
-  const notEvaluated: any[] = [];
+  const notEvaluated        = [];
   for (const gap of [...requirement.gaps, ...design.gaps, ...plan.gaps]) {
     notEvaluated.push({ what: `${gap.artifact} → ${gap.what}`, why: gap.why });
   }
@@ -217,27 +217,27 @@ function parseArtifacts(texts: Record<string, string | null>): { requirement: an
  * @param {Object} design from `parseArtifacts`
  * @returns {{ requirementsForStory: Map, componentsForRequirement: Map, traceTask: Function }}
  */
-function buildTraceabilityIndex(requirement: any, design: any): { requirementsForStory: Map<string, any[]>; componentsForRequirement: Map<string, any[]>; traceTask: (task: any) => any } {
-  const requirementsForStory = new Map<string, any[]>();
+function buildTraceabilityIndex(requirement     , design     )                                                                                                                            {
+  const requirementsForStory = new Map               ();
   for (const req of requirement.requirements.values()) {
     for (const story of req.stories) {
       if (!requirementsForStory.has(story)) requirementsForStory.set(story, []);
-      requirementsForStory.get(story)!.push(req);
+      requirementsForStory.get(story) .push(req);
     }
   }
-  const componentsForRequirement = new Map<string, any[]>();
+  const componentsForRequirement = new Map               ();
   for (const component of design.components.values()) {
     for (const id of component.serves) {
       if (!componentsForRequirement.has(id)) componentsForRequirement.set(id, []);
-      componentsForRequirement.get(id)!.push(component);
+      componentsForRequirement.get(id) .push(component);
     }
   }
 
-  function traceTask(task: any): any {
-    const reqs = [...new Set(task.stories.flatMap((s: string) => requirementsForStory.get(s) || []))]
-      .sort(byKey((r: any) => r.id));
-    const comps = [...new Set(reqs.flatMap((r: any) => componentsForRequirement.get(r.id) || []))]
-      .sort(byKey((c: any) => c.id));
+  function traceTask(task     )      {
+    const reqs = [...new Set(task.stories.flatMap((s        ) => requirementsForStory.get(s) || []))]
+      .sort(byKey((r     ) => r.id));
+    const comps = [...new Set(reqs.flatMap((r     ) => componentsForRequirement.get(r.id) || []))]
+      .sort(byKey((c     ) => c.id));
     return { requirements: reqs, components: comps };
   }
 
@@ -249,9 +249,9 @@ function buildTraceabilityIndex(requirement: any, design: any): { requirementsFo
  * @param {Array<Object>} tasks from `plan.tasks`
  * @returns {{ byPath: Map<string, Array<Object>>, skipped: Array<Object> }}
  */
-function groupTasksByFile(tasks: any[]): { byPath: Map<string, any[]>; skipped: any[] } {
-  const byPath = new Map<string, any[]>();
-  const skipped: any[] = [];
+function groupTasksByFile(tasks       )                                                 {
+  const byPath = new Map               ();
+  const skipped        = [];
   for (const task of tasks) {
     if (task.files.length === 0) {
       skipped.push({ item: `task ${task.id}`, why: 'no `files:` field — nothing to mirror', benign: false });
@@ -259,7 +259,7 @@ function groupTasksByFile(tasks: any[]): { byPath: Map<string, any[]>; skipped:
     }
     for (const file of task.files) {
       if (!byPath.has(file)) byPath.set(file, []);
-      byPath.get(file)!.push(task);
+      byPath.get(file) .push(task);
     }
   }
   return { byPath, skipped };
@@ -277,14 +277,14 @@ function groupTasksByFile(tasks: any[]): { byPath: Map<string, any[]>; skipped:
  * @param {Function} options.traceTask from `buildTraceabilityIndex`
  * @returns {{ planned: Map<string, Object>, skipped: Array<Object>, shapeUndeclared: Array<Object> }}
  */
-function planSourceStubs({ byPath, scaffoldDir, repoRoot, fsImpl, slug, message, traceTask }: any): { planned: Map<string, any>; skipped: any[]; shapeUndeclared: any[] } {
-  const planned = new Map<string, any>();   // relative-to-scaffoldDir path → { body, header, kind, from }
-  const skipped: any[] = [];
-  const shapeUndeclared: any[] = [];
+function planSourceStubs({ byPath, scaffoldDir, repoRoot, fsImpl, slug, message, traceTask }     )                                                                        {
+  const planned = new Map             ();   // relative-to-scaffoldDir path → { body, header, kind, from }
+  const skipped        = [];
+  const shapeUndeclared        = [];
 
-  for (const [file, owners] of [...byPath.entries()].sort(byKey((e: any) => e[0]))) {
+  for (const [file, owners] of [...byPath.entries()].sort(byKey((e     ) => e[0]))) {
     const ext = path.extname(file).toLowerCase();
-    const label = `${file} (${owners.map((t: any) => t.id).join(', ')})`;
+    const label = `${file} (${owners.map((t     ) => t.id).join(', ')})`;
 
     if (file.endsWith('/') || isDirectory(path.join(repoRoot, file), fsImpl)) {
       skipped.push({ item: label, why: 'names a directory, not a file — no single signature to emit', benign: true });
@@ -321,34 +321,34 @@ function planSourceStubs({ byPath, scaffoldDir, repoRoot, fsImpl, slug, message,
     }
 
     const emitter = EMITTERS[languageId];
-    const trace = owners.map((t: any) => ({ task: t, ...traceTask(t) }));
-    const reqs = [...new Set(trace.flatMap((t: any) => t.requirements))].sort(byKey((r: any) => r.id));
-    const comps = [...new Set(trace.flatMap((t: any) => t.components))].sort(byKey((c: any) => c.id));
-    const declared = comps.flatMap((c: any) => c.declared.map((d: any) => ({ ...d, component: c.id })));
+    const trace = owners.map((t     ) => ({ task: t, ...traceTask(t) }));
+    const reqs = [...new Set(trace.flatMap((t     ) => t.requirements))].sort(byKey((r     ) => r.id));
+    const comps = [...new Set(trace.flatMap((t     ) => t.components))].sort(byKey((c     ) => c.id));
+    const declared = comps.flatMap((c     ) => c.declared.map((d     ) => ({ ...d, component: c.id })));
 
     const header = [
       `doflow scaffold — generated from ${slug}'s requirement.md, design.md and plan.md.`,
       'Signatures and stubs only. Do not implement here; this tree is never promoted automatically.',
       '',
       `intended path: ${file}`,
-      ...owners.map((t: any) => `task:          ${t.id} — ${t.description}`),
+      ...owners.map((t     ) => `task:          ${t.id} — ${t.description}`),
       ...(reqs.length
-        ? reqs.map((r: any) => `requirement:   ${r.id} — ${r.summary}`)
+        ? reqs.map((r     ) => `requirement:   ${r.id} — ${r.summary}`)
         : ['requirement:   none — no user story on the owning task resolves to a requirement']),
       ...(comps.length
-        ? comps.map((c: any) => `component:     ${c.id} — ${c.name} (design.md §3)`)
+        ? comps.map((c     ) => `component:     ${c.id} — ${c.name} (design.md §3)`)
         : ['component:     none — no design component serves this task\'s requirements']),
     ];
 
-    const bodyParts: string[] = [''];
+    const bodyParts           = [''];
     if (declared.length) {
-      header.push(`shape:         declared in design.md §4 (${[...new Set(declared.map((d: any) => d.component))].join(', ')}), quoted below`);
+      header.push(`shape:         declared in design.md §4 (${[...new Set(declared.map((d     ) => d.component))].join(', ')}), quoted below`);
       for (const decl of declared) {
         const lines = decl.block.split('\n');
         const shown = lines.slice(0, 40);
         bodyParts.push([
           emitter.line(`declared interface — design.md "${decl.heading}", verbatim:`),
-          ...shown.map((l: string) => emitter.line(`  ${l}`.replace(/\s+$/, ''))),
+          ...shown.map((l        ) => emitter.line(`  ${l}`.replace(/\s+$/, ''))),
           ...(lines.length > shown.length ? [emitter.line(`  … ${lines.length - shown.length} more lines in design.md`)] : []),
           '',
         ].join('\n'));
@@ -371,7 +371,7 @@ function planSourceStubs({ byPath, scaffoldDir, repoRoot, fsImpl, slug, message,
     bodyParts.push(emitter.module({ symbol, message, pkg: pkg || 'scaffold' }));
     planned.set(path.join('src', file) + STUB_SUFFIX, {
       content: compose(emitter, header, `${bodyParts.join('\n')}\n`),
-      from: owners.map((t: any) => t.id).join(', '),
+      from: owners.map((t     ) => t.id).join(', '),
       shape: declared.length ? 'declared interface + placeholder signature' : 'placeholder signature',
     });
   }
@@ -389,10 +389,10 @@ function planSourceStubs({ byPath, scaffoldDir, repoRoot, fsImpl, slug, message,
  * @param {string} options.message the pinned "not implemented" signal
  * @returns {{ planned: Map<string, Object>, skipped: Array<Object>, notEvaluated: Array<Object> }}
  */
-function planTestStubs({ requirement, componentsForRequirement, language, slug, message }: any): { planned: Map<string, any>; skipped: any[]; notEvaluated: any[] } {
-  const planned = new Map<string, any>();
-  const skipped: any[] = [];
-  const notEvaluated: any[] = [];
+function planTestStubs({ requirement, componentsForRequirement, language, slug, message }     )                                                                     {
+  const planned = new Map             ();
+  const skipped        = [];
+  const notEvaluated        = [];
 
   if (requirement.criteria.length > 0) {
     if (!language.id) {
@@ -402,27 +402,27 @@ function planTestStubs({ requirement, componentsForRequirement, language, slug,
       });
     } else {
       const emitter = EMITTERS[language.id];
-      const grouped = new Map<string, any[]>();
+      const grouped = new Map               ();
       for (const criterion of requirement.criteria) {
         const ids = criterion.requirements.length ? criterion.requirements : ['unattributed'];
         for (const id of ids) {
           if (!grouped.has(id)) grouped.set(id, []);
-          grouped.get(id)!.push(criterion);
+          grouped.get(id) .push(criterion);
         }
         if (criterion.requirements.length === 0) {
           skipped.push({ item: `acceptance criterion "${criterion.statement}"`, why: 'names no FR/NFR — stubbed under "unattributed", traceability incomplete', benign: false });
         }
       }
-      for (const [id, cases] of [...grouped.entries()].sort(byKey((e: any) => e[0]))) {
+      for (const [id, cases] of [...grouped.entries()].sort(byKey((e     ) => e[0]))) {
         const req = requirement.requirements.get(id);
-        const comps = (componentsForRequirement.get(id) || []).sort(byKey((c: any) => c.id));
+        const comps = (componentsForRequirement.get(id) || []).sort(byKey((c     ) => c.id));
         const header = [
           `doflow scaffold — test stubs generated from ${slug}'s requirement.md acceptance criteria.`,
           'Each stub fails until implemented, on purpose: a stub that passes asserts nothing and',
           'reads as coverage. Replace the body, do not delete the failure.',
           '',
           `requirement:   ${id}${req ? ` — ${req.summary}` : ' — not present in the requirement index'}`,
-          ...(comps.length ? comps.map((c: any) => `component:     ${c.id} — ${c.name} (design.md §3)`) : []),
+          ...(comps.length ? comps.map((c     ) => `component:     ${c.id} — ${c.name} (design.md §3)`) : []),
           `criteria:      ${cases.length} from requirement.md §6`,
           `language:      ${language.id} (detected from ${language.signal} by command-detect.ts)`,
         ];
@@ -446,21 +446,21 @@ function planTestStubs({ requirement, componentsForRequirement, language, slug,
  * @param {Set<string>} ownedPaths every path a task in this plan already owns
  * @returns {Array<Object>} externalDependencies
  */
-function partitionExternalDependencies(tasks: any[], ownedPaths: Set<string>): any[] {
-  const externalDependencies: any[] = [];
-  const dependencyTasks = new Map<string, any[]>();
+function partitionExternalDependencies(tasks       , ownedPaths             )        {
+  const externalDependencies        = [];
+  const dependencyTasks = new Map               ();
   for (const task of tasks) {
     for (const dep of task.dependsOn) {
       if (!dependencyTasks.has(dep)) dependencyTasks.set(dep, []);
-      dependencyTasks.get(dep)!.push(task);
+      dependencyTasks.get(dep) .push(task);
     }
   }
-  for (const [dep, owners] of [...dependencyTasks.entries()].sort(byKey((e: any) => e[0]))) {
+  for (const [dep, owners] of [...dependencyTasks.entries()].sort(byKey((e     ) => e[0]))) {
     const inScope = [...ownedPaths].some((p) => p === dep || p.startsWith(`${dep.replace(/\/$/, '')}/`));
-    const docs = [...new Set(owners.map((t: any) => t.externalContract).filter(Boolean))];
+    const docs = [...new Set(owners.map((t     ) => t.externalContract).filter(Boolean))];
     externalDependencies.push({
       dependency: dep,
-      tasks: owners.map((t: any) => t.id).sort(),
+      tasks: owners.map((t     ) => t.id).sort(),
       disposition: inScope
         ? 'in scope — a task in this plan owns it, no contract frame needed'
         : docs.length === 1
@@ -482,12 +482,12 @@ function partitionExternalDependencies(tasks: any[], ownedPaths: Set<string>): a
  * @param {Object} options.fsImpl
  * @returns {{ written: Array<string>, unchanged: Array<string>, preserved: Array<Object> }}
  */
-function applyPlannedFiles({ planned, blocked, scaffoldDir, fsImpl }: any): { written: string[]; unchanged: string[]; preserved: any[] } {
-  const written: string[] = [];
-  const unchanged: string[] = [];
-  const preserved: any[] = [];
+function applyPlannedFiles({ planned, blocked, scaffoldDir, fsImpl }     )                                                               {
+  const written           = [];
+  const unchanged           = [];
+  const preserved        = [];
 
-  function place(relative: string, content: string): void {
+  function place(relative        , content        )       {
     const target = path.join(scaffoldDir, relative);
     const existing = readIfPresent(target, fsImpl);
     if (existing !== null) {
@@ -507,7 +507,7 @@ function applyPlannedFiles({ planned, blocked, scaffoldDir, fsImpl }: any): { wr
   }
 
   if (blocked.length === 0) {
-    for (const [relative, entry] of [...planned.entries()].sort(byKey((e: any) => e[0]))) {
+    for (const [relative, entry] of [...planned.entries()].sort(byKey((e     ) => e[0]))) {
       place(relative, entry.content);
     }
   }
@@ -524,14 +524,14 @@ function applyPlannedFiles({ planned, blocked, scaffoldDir, fsImpl }: any): { wr
  * @param {Object} options.fsImpl
  * @returns {Array<string>} orphans
  */
-function findOrphans({ scaffoldDir, planned, fsImpl }: any): string[] {
-  const orphans: string[] = [];
-  (function scan(dir: string, prefix: string) {
-    let entries: any[];
+function findOrphans({ scaffoldDir, planned, fsImpl }     )           {
+  const orphans           = [];
+  (function scan(dir        , prefix        ) {
+    let entries       ;
     try {
       entries = fsImpl.readdirSync(dir, { withFileTypes: true });
     } catch { return; }
-    for (const entry of entries.sort(byKey((e: any) => e.name))) {
+    for (const entry of entries.sort(byKey((e     ) => e.name))) {
       const relative = prefix ? path.join(prefix, entry.name) : entry.name;
       if (entry.isDirectory()) { scan(path.join(dir, entry.name), relative); continue; }
       if (relative === MANIFEST_NAME || planned.has(relative)) continue;
@@ -554,8 +554,8 @@ function findOrphans({ scaffoldDir, planned, fsImpl }: any): string[] {
  * @param {number} options.plannedSize
  * @returns {{ status: string }}
  */
-function classifyRunStatus({ blocked, notEvaluated, skipped, plannedSize }: any): { status: string } {
-  const realGaps = [...notEvaluated, ...skipped.filter((s: any) => !s.benign)];
+function classifyRunStatus({ blocked, notEvaluated, skipped, plannedSize }     )                     {
+  const realGaps = [...notEvaluated, ...skipped.filter((s     ) => !s.benign)];
   const status = blocked.length
     ? STATUS.BLOCKED
     : realGaps.length || plannedSize === 0
@@ -579,14 +579,14 @@ function classifyRunStatus({ blocked, notEvaluated, skipped, plannedSize }: any)
  * @param {Object} options
  * @returns {{ stateSummary: string, summary: string }}
  */
-function buildSummaries({ status, blocked, planned, shapeUndeclared, preserved, skipped, notEvaluated, externalDependencies, written, unchanged }: any): { stateSummary: string; summary: string } {
-  const blockedWhy = blocked.map((b: any) => b.what).join(', ');
+function buildSummaries({ status, blocked, planned, shapeUndeclared, preserved, skipped, notEvaluated, externalDependencies, written, unchanged }     )                                            {
+  const blockedWhy = blocked.map((b     ) => b.what).join(', ');
 
   const stateSummary = status === STATUS.BLOCKED
     ? `BLOCKED — ${blockedWhy} could not be read or parsed; no scaffold written`
     : `${status} — ${planned.size} file(s), ${shapeUndeclared.length} of them with no shape declared in design.md, `
       + `${preserved.length} preserved (hand-edited), ${skipped.length} skipped `
-      + `(${skipped.filter((s: any) => !s.benign).length} of them a real gap), ${notEvaluated.length} not evaluated, `
+      + `(${skipped.filter((s     ) => !s.benign).length} of them a real gap), ${notEvaluated.length} not evaluated, `
       + `${externalDependencies.length} dependency reference(s) routed to the contract-frame case`;
 
   const summary = status === STATUS.BLOCKED
@@ -601,7 +601,7 @@ function buildSummaries({ status, blocked, planned, shapeUndeclared, preserved,
  * @param {Object} options
  * @returns {Object} result
  */
-function buildResult({ status, slug, featureDir, scaffoldDir, repoRoot, language, sources, planned, written, unchanged, preserved, skipped, shapeUndeclared, notEvaluated, externalDependencies, orphans, stateSummary, summary }: any): any {
+function buildResult({ status, slug, featureDir, scaffoldDir, repoRoot, language, sources, planned, written, unchanged, preserved, skipped, shapeUndeclared, notEvaluated, externalDependencies, orphans, stateSummary, summary }     )      {
   return {
     status,
     exitCode: status === STATUS.COMPLETE ? EXIT.OK : EXIT.FINDING,
@@ -616,10 +616,10 @@ function buildResult({ status, slug, featureDir, scaffoldDir, repoRoot, language
     generated: [...planned.keys()].sort(),
     written: written.sort(),
     unchanged: unchanged.sort(),
-    preserved: preserved.sort(byKey((p: any) => p.path)),
-    skipped: skipped.sort(byKey((s: any) => s.item)),
-    shapeUndeclared: shapeUndeclared.sort(byKey((s: any) => s.path)),
-    notEvaluated: notEvaluated.sort(byKey((n: any) => n.what)),
+    preserved: preserved.sort(byKey((p     ) => p.path)),
+    skipped: skipped.sort(byKey((s     ) => s.item)),
+    shapeUndeclared: shapeUndeclared.sort(byKey((s     ) => s.path)),
+    notEvaluated: notEvaluated.sort(byKey((n     ) => n.what)),
     externalDependencies,
     orphans: orphans.sort(),
     stateSummary,
@@ -639,7 +639,7 @@ function buildResult({ status, slug, featureDir, scaffoldDir, repoRoot, language
  * @param {Object} options.fsImpl
  * @returns {Object} result
  */
-function writeManifest({ result, planned, scaffoldDir, fsImpl }: any): any {
+function writeManifest({ result, planned, scaffoldDir, fsImpl }     )      {
   const manifest = renderManifest(result, planned);
   const manifestTarget = path.join(scaffoldDir, MANIFEST_NAME);
   const existingManifest = readIfPresent(manifestTarget, fsImpl);
@@ -672,12 +672,12 @@ function writeManifest({ result, planned, scaffoldDir, fsImpl }: any): any {
  * @param {Object} [options.fsImpl] injection seam for tests; same contract as `node:fs`
  * @returns {Object} result — see `summary`, `status` and `exitCode`
  */
-function generateScaffold(options: any = {}): any {
+function generateScaffold(options      = {})      {
   const fsImpl = options.fsImpl || nodeFs;
   const repoRoot = path.resolve(options.repoRoot || process.cwd());
   const featureDir = options.featureDir ? path.resolve(options.featureDir) : null;
 
-  const usage = (message: string): any => ({
+  const usage = (message        )      => ({
     status: STATUS.USAGE, exitCode: EXIT.USAGE, ok: false, summary: message,
     featureDir, scaffoldDir: null, manifestPath: null,
     generated: [], written: [], unchanged: [], preserved: [], skipped: [], notEvaluated: [],
@@ -696,7 +696,7 @@ function generateScaffold(options: any = {}): any {
   const notEvaluated = [...artifactsNotEvaluated, ...parseGapsNotEvaluated];
 
   const blocked = notEvaluated.filter(
-    (n: any) => ARTIFACTS.includes(n.what) || n.what.startsWith('plan.md → task list'),
+    (n     ) => ARTIFACTS.includes(n.what) || n.what.startsWith('plan.md → task list'),
   );
 
   const { requirementsForStory, componentsForRequirement, traceTask } = buildTraceabilityIndex(requirement, design);
@@ -743,9 +743,9 @@ function generateScaffold(options: any = {}): any {
  * the second run of an unchanged plan produce a diff — losing the idempotency the whole artifact is
  * reviewed on.
  */
-function renderManifest(result: any, planned: Map<string, any>): string {
-  const lines: string[] = [];
-  const table = (headers: string[], rows: any[][], empty: string) => {
+function renderManifest(result     , planned                  )         {
+  const lines           = [];
+  const table = (headers          , rows         , empty        ) => {
     if (rows.length === 0) { lines.push(empty, ''); return; }
     lines.push(`| ${headers.join(' | ')} |`, `|${headers.map(() => '---').join('|')}|`);
     for (const r of rows) lines.push(`| ${r.map(cell).join(' | ')} |`);
@@ -754,7 +754,7 @@ function renderManifest(result: any, planned: Map<string, any>): string {
 
   lines.push(`# Scaffold manifest — ${result.slug}`, '');
   lines.push(
-    'Generated by DoFlow\'s scaffold generator (`src/runtime/scaffold/generate.ts`) from this feature\'s own',
+    'Generated by DoFlow\'s scaffold generator (`src/runtime/scaffold/generate.js`) from this feature\'s own',
     '`requirement.md`, `design.md` and `plan.md`. Signatures, types and failing stubs only — no',
     'implementation logic, by design. Nothing here is written into the source tree; promoting any of',
     'it is a deliberate act.',
@@ -768,23 +768,23 @@ function renderManifest(result: any, planned: Map<string, any>): string {
 
   lines.push('## Source artifacts', '');
   table(['Artifact', 'Read', 'SHA-256'],
-    result.sources.map((s: any) => [s.name, s.present ? 'yes' : 'NOT FOUND', s.sha256 || '—']),
+    result.sources.map((s     ) => [s.name, s.present ? 'yes' : 'NOT FOUND', s.sha256 || '—']),
     '_None read._');
 
   lines.push('## Generated', '');
   table(['Path', 'Derived from', 'Shape'],
-    result.generated.map((p: string) => [p, planned.get(p).from, planned.get(p).shape]),
+    result.generated.map((p        ) => [p, planned.get(p).from, planned.get(p).shape]),
     '_Nothing generated._');
 
   lines.push('## Emitted without a declared shape', '');
   lines.push('These files exist and are traceable, but `design.md` §4 never declared an interface for',
     'them, so their signature is a placeholder rather than a contract. Reviewing the placeholder as',
     'if it were the designed API is the mistake this section exists to prevent.', '');
-  table(['Path', 'Why'], result.shapeUndeclared.map((s: any) => [s.path, s.why]),
+  table(['Path', 'Why'], result.shapeUndeclared.map((s     ) => [s.path, s.why]),
     '_Every emitted file has a declared shape behind it._');
 
   lines.push('## Preserved — edited by hand, not overwritten', '');
-  table(['Path', 'Why'], result.preserved.map((p: any) => [p.path, p.why]),
+  table(['Path', 'Why'], result.preserved.map((p     ) => [p.path, p.why]),
     '_No hand-edited files detected._');
 
   lines.push('## Skipped', '');
@@ -794,14 +794,14 @@ function renderManifest(result: any, planned: Map<string, any>): string {
     '"Gap" separates the two kinds. A markdown file has no signature to emit and skipping it costs',
     'nothing; a source file in a language this generator cannot emit is work that silently did not',
     'happen, and it is what holds the status below `COMPLETE`.', '');
-  table(['Item', 'Gap', 'Why'], result.skipped.map((s: any) => [s.item, s.benign ? 'no' : 'YES', s.why]),
+  table(['Item', 'Gap', 'Why'], result.skipped.map((s     ) => [s.item, s.benign ? 'no' : 'YES', s.why]),
     '_Nothing skipped._');
 
   lines.push('## Not evaluated', '');
   lines.push('Things this run could not judge either way. These, together with every skip marked as a',
     'gap above, are why the status is not `COMPLETE`. None of them is a claim that the underlying',
     'item is fine.', '');
-  table(['What', 'Why'], result.notEvaluated.map((n: any) => [n.what, n.why]),
+  table(['What', 'Why'], result.notEvaluated.map((n     ) => [n.what, n.why]),
     '_Everything the artifacts declared was evaluated._');
 
   lines.push('## External dependencies', '');
@@ -810,13 +810,13 @@ function renderManifest(result: any, planned: Map<string, any>): string {
     'nested `.git` boundaries, non-local vendors and `external-contract:` targets; this generator reports',
     'the partition rather than deriving the boundaries a second way.', '');
   table(['Dependency', 'Named by', 'Disposition'],
-    result.externalDependencies.map((d: any) => [d.dependency, d.tasks.join(', '), d.disposition]),
+    result.externalDependencies.map((d     ) => [d.dependency, d.tasks.join(', '), d.disposition]),
     '_No task declares a `depends-on:` value._');
 
   if (result.orphans.length) {
     lines.push('## Orphaned', '');
     lines.push('Generated by an earlier run and no longer implied by the plan. Reported, never deleted.', '');
-    table(['Path'], result.orphans.map((p: string) => [p]), '');
+    table(['Path'], result.orphans.map((p        ) => [p]), '');
   }
 
   const body = `\n${lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
@@ -846,7 +846,7 @@ function renderManifest(result: any, planned: Map<string, any>): string {
  * @param {string|null} [options.slug] explicit feature override
  * @returns {number} process exit code
  */
-function handleScaffoldCommand({ json = false, projectRoot, slug = null }: any = {}): number {
+function handleScaffoldCommand({ json = false, projectRoot, slug = null }      = {})         {
   const root = projectRoot || process.cwd();
   const feature = resolveActiveFeature({ projectRoot: root, slug });
   if (feature.error) {
@@ -870,10 +870,10 @@ function handleScaffoldCommand({ json = false, projectRoot, slug = null }: any =
 
   // A reader who cannot see the gaps reads the tree as the whole shape of the plan, so the
   // negative space is printed at the same level as the counts rather than left to the manifest.
-  const sections: [string, string[]][] = [
-    ['Skipped', (result.skipped || []).map((s: any) => `${s.item}${s.benign ? '' : '  [GAP]'} — ${s.why}`)],
-    ['Not evaluated', (result.notEvaluated || []).map((n: any) => `${n.what} — ${n.why}`)],
-    ['Preserved (hand-edited, not overwritten)', (result.preserved || []).map((p: any) => `${p.path} — ${p.why}`)],
+  const sections                       = [
+    ['Skipped', (result.skipped || []).map((s     ) => `${s.item}${s.benign ? '' : '  [GAP]'} — ${s.why}`)],
+    ['Not evaluated', (result.notEvaluated || []).map((n     ) => `${n.what} — ${n.why}`)],
+    ['Preserved (hand-edited, not overwritten)', (result.preserved || []).map((p     ) => `${p.path} — ${p.why}`)],
     ['Orphaned (no longer implied by the plan)', result.orphans || []],
   ];
   for (const [title, lines] of sections) {