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

package/src/runtime/{history-compactor.ts → history-compactor.js}

@@ -37,9 +37,9 @@ const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
  *   are true when a fence or an HTML comment is never closed, so everything after it was swallowed;
  *   `openAt` is the line index where that construct opened (-1 when none is left open)
  */
-function scan(lines: string[]): { kinds: string[]; openFence: boolean; openComment: boolean; openAt: number } {
-  const kinds: string[] = new Array(lines.length);
-  let fence: { ch: string; len: number } | null = null;
+function scan(lines          )                                                                                {
+  const kinds           = new Array(lines.length);
+  let fence                                     = null;
   let comment = false;
   let openedAt = -1;
   for (let i = 0; i < lines.length; i += 1) {
@@ -73,14 +73,14 @@ function scan(lines: string[]): { kinds: string[]; openFence: boolean; openComme
  * exact canonical pointer for this artifact is the pointer; any other line, including one that
  * merely looks like a pointer, moves, so no text is dropped.
  */
-function classify(bodyLines: string[], kinds: string[], canonicalPointer: string): { comments: string[][]; moved: string[]; pointer: string | null } {
-  const comments: string[][] = [];
-  const moved: string[] = [];
-  let pointer: string | null = null;
-  let block: string[] | null = null;
+function classify(bodyLines          , kinds          , canonicalPointer        )                                                                    {
+  const comments             = [];
+  const moved           = [];
+  let pointer                = null;
+  let block                  = null;
   bodyLines.forEach((line, i) => {
     const kind = kinds[i];
-    if (kind === 'comment-cont') { (block as string[]).push(line); return; }
+    if (kind === 'comment-cont') { (block            ).push(line); return; }
     block = null;
     if (kind === 'comment') { block = [line]; comments.push(block); return; }
     if (kind === 'fence') { moved.push(line); return; }
@@ -93,19 +93,19 @@ function classify(bodyLines: string[], kinds: string[], canonicalPointer: string
   return { comments, moved, pointer };
 }
 
-function writeAtomic(fsImpl: any, file: string, content: string): void {
+function writeAtomic(fsImpl     , file        , content        )       {
   fsImpl.mkdirSync(path.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
   try {
     fsImpl.writeFileSync(tmp, content, 'utf8');
     fsImpl.renameSync(tmp, file);
-  } catch (error: any) {
+  } catch (error     ) {
     try { fsImpl.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
     throw error;
   }
 }
 
-function toPosix(p: string): string {
+function toPosix(p        )         {
   return p.split(path.sep).join('/');
 }
 
@@ -119,7 +119,7 @@ function toPosix(p: string): string {
  * a line inside a code fence, and that must not be read as the start of a chunk. The dedupe and the
  * post-write confirmation both use this one predicate.
  */
-function lastChunkIs(archiveText: string, blockLF: string): boolean {
+function lastChunkIs(archiveText        , blockLF        )          {
   const lines = archiveText.replace(/\r\n/g, '\n').split('\n');
   const { kinds } = scan(lines);
   let header = -1;
@@ -135,25 +135,25 @@ function lastChunkIs(archiveText: string, blockLF: string): boolean {
  * @returns {{artifact:string, path:string, archive:string, lines:number}|null} null when there was
  *   nothing to move
  */
-function compactArtifact({ fsImpl, featureDir, file, date }: { fsImpl: any; featureDir: string; file: string; date: string }): { artifact: string; path: string; archive: string; lines: number } | null {
+function compactArtifact({ fsImpl, featureDir, file, date }                                                                 )                                                                            {
   const text = fsImpl.readFileSync(file, 'utf8');
   const crlf = text.includes('\r\n');
   const lines = text.split('\n');
   const { kinds, openFence, openComment, openAt } = scan(lines);
-  const unclosed: string | null = openFence ? 'a code fence' : openComment ? 'an HTML comment' : null;
-  const refuse = (): never => {
+  const unclosed                = openFence ? 'a code fence' : openComment ? 'an HTML comment' : null;
+  const refuse = ()        => {
     throw new Error(`${unclosed} is never closed, so the end of the History section cannot be told`);
   };
-  const start = lines.findIndex((l: string, i: number) => kinds[i] === 'text' && HISTORY_HEADING.test(l));
+  const start = lines.findIndex((l        , i        ) => kinds[i] === 'text' && HISTORY_HEADING.test(l));
   // An unclosed construct swallows everything after it. It matters only when it opens before the
   // History section ends (FR-001): then the section's end cannot be told. A History heading it
   // swallowed is such a case; one that simply is not there, or that closed before the construct
   // opened, is not, and the construct is treated as absent.
   if (start === -1) {
-    if (unclosed && lines.some((l: string, i: number) => i > openAt && HISTORY_HEADING.test(l))) refuse();
+    if (unclosed && lines.some((l        , i        ) => i > openAt && HISTORY_HEADING.test(l))) refuse();
     return null;
   }
-  const section = Number((HISTORY_HEADING.exec(lines[start]) as RegExpExecArray)[1]);
+  const section = Number((HISTORY_HEADING.exec(lines[start])                   )[1]);
   let end = lines.length;
   for (let i = start + 1; i < lines.length; i += 1) {
     if (kinds[i] === 'text' && ANY_H2.test(lines[i])) { end = i; break; }
@@ -172,7 +172,7 @@ function compactArtifact({ fsImpl, featureDir, file, date }: { fsImpl: any; feat
   // Chunks are built with LF and converted to the artifact's own line ending on write, so a CRLF
   // artifact gets a CRLF archive and no file ends up mixed.
   const eol = crlf ? '\r\n' : '\n';
-  const toEol = (t: string) => (crlf ? t.replace(/\n/g, '\r\n') : t);
+  const toEol = (t        ) => (crlf ? t.replace(/\n/g, '\r\n') : t);
   const blockLF = moved.map((l) => l.replace(/\r$/, '')).join('\n');
   const chunk = `## Compacted ${date} from ${rel} §${section}\n\n${blockLF}\n`;
   const existing = fsImpl.existsSync(archiveFile) ? fsImpl.readFileSync(archiveFile, 'utf8') : null;
@@ -213,18 +213,18 @@ function compactArtifact({ fsImpl, featureDir, file, date }: { fsImpl: any; feat
  * @returns {{status:'compacted'|'unchanged'|'partial', moved:Object[], failed:Array<{artifact:string, path:string, message:string}>}}
  *   `partial` means at least one artifact failed
  */
-function compactHistory({ repoRoot, featureDir, paths, date, fsImpl = nodeFs }: { repoRoot: string; featureDir: string; paths: any; date?: string; fsImpl?: any }): { status: 'compacted' | 'unchanged' | 'partial'; moved: any[]; failed: Array<{ artifact: string; path: string; message: string }> } {
+function compactHistory({ repoRoot, featureDir, paths, date, fsImpl = nodeFs }                                                                                   )                                                                                                                                      {
   const stamp = date || new Date().toISOString().slice(0, 10);
-  const moved: any[] = [];
-  const failed: any[] = [];
+  const moved        = [];
+  const failed        = [];
   for (const key of TARGET_KEYS) {
     if (!paths || !paths[key]) continue;
     const file = path.resolve(repoRoot, paths[key]);
     if (!fsImpl.existsSync(file)) continue;
-    let result: any;
+    let result     ;
     try {
       result = compactArtifact({ fsImpl, featureDir, file, date: stamp });
-    } catch (error: any) {
+    } catch (error     ) {
       const name = toPosix(path.relative(featureDir, file));
       failed.push({ artifact: path.basename(file), path: name, message: `could not compact ${name}: ${error.message}; the artifact was left unchanged` });
       continue;

package/src/runtime/{implementation-gate.ts → implementation-gate.js}

@@ -4,12 +4,12 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { readReadinessRecord, newerVersionOf, RECORD_VERSION } = require('./readiness-record.ts');
-const { listCheckouts } = require('./checkouts.ts');
-const { readTaskState } = require('./task-state.ts');
-const { resolveActiveFeature } = require('./feature-resolve.ts');
-const { isSafeSlug } = require('./task-scope.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { readReadinessRecord, newerVersionOf, RECORD_VERSION } = require('./readiness-record.js');
+const { listCheckouts } = require('./checkouts.js');
+const { readTaskState } = require('./task-state.js');
+const { resolveActiveFeature } = require('./feature-resolve.js');
+const { isSafeSlug } = require('./task-scope.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 // The implementation gate: which stage of a workflow needs a READY readiness record before it is
 // handed off, whether a task has one, and the words every refusal uses.
@@ -30,8 +30,8 @@ const NEWER_NEXT = 'run this command with the DoFlow that wrote the record, or u
  * @param {{editTime?: boolean}} [options]
  * @returns {{id: string, readinessTemplate: string, editTimeGate: boolean}|null}
  */
-function gatedStage(stages: any, { editTime = false }: any = {}) {
-  const stage = (stages || []).find((s: any) => s && s.mutatesSource === true
+function gatedStage(stages     , { editTime = false }      = {}) {
+  const stage = (stages || []).find((s     ) => s && s.mutatesSource === true
     && typeof s.readinessTemplate === 'string' && s.readinessTemplate !== ''
     && (!editTime || s.editTimeGate !== false));
   return stage ? { id: stage.id, readinessTemplate: stage.readinessTemplate, editTimeGate: stage.editTimeGate !== false } : null;
@@ -43,12 +43,12 @@ function gatedStage(stages: any, { editTime = false }: any = {}) {
  * @param {{editTime?: boolean}} [options]
  * @returns {Array<string>}
  */
-function heldClasses(engine: any, { editTime = false }: any = {}) {
-  return engine.listClasses().filter((cls: any) => gatedStage(engine.resolveWorkflow(cls).stages, { editTime }) !== null);
+function heldClasses(engine     , { editTime = false }      = {}) {
+  return engine.listClasses().filter((cls     ) => gatedStage(engine.resolveWorkflow(cls).stages, { editTime }) !== null);
 }
 
 /** The command that clears every readiness refusal. */
-function nextCommand({ taskId, slug, template }: any) {
+function nextCommand({ taskId, slug, template }     ) {
   const withSlug = slug && slug !== taskId ? ` --slug=${slug}` : '';
   return `doflow-run readiness --task-class ${template} --task-id ${taskId}${withSlug}`;
 }
@@ -68,7 +68,7 @@ function nextCommand({ taskId, slug, template }: any) {
  *   replace such a record, so the text does not send the caller there
  * @returns {string}
  */
-function refusalText(code: any, { taskId, slug = null, template, record = null, candidates = [], detail = null, file = null, newerVersion = null }: any): string {
+function refusalText(code     , { taskId, slug = null, template, record = null, candidates = [], detail = null, file = null, newerVersion = null }     )         {
   const next = nextCommand({ taskId, slug, template });
   const tail = `Next: ${next}, then gather what it lists until it reports READY. Nothing was changed.`;
   if (code === 'unusable' && newerVersion !== null) {
@@ -103,14 +103,14 @@ function refusalText(code: any, { taskId, slug = null, template, record = null,
  * @param {{repoRoot?: string}} [options]
  * @returns {string}
  */
-function harnessHookNote({ repoRoot = REPO_ROOT }: any = {}): string {
+function harnessHookNote({ repoRoot = REPO_ROOT }      = {})         {
   try {
     const { policies } = JSON.parse(fs.readFileSync(path.join(repoRoot, 'core', 'registry', 'lifecycle.json'), 'utf8'));
-    const { mappings } = policies.find((p: any) => p.id === 'pre-implementation-gate');
+    const { mappings } = policies.find((p     ) => p.id === 'pre-implementation-gate');
     const runs = [];
     const gated = new Map();
     const none = [];
-    for (const [id, m] of (Object.entries(mappings) as [string, any][])) {
+    for (const [id, m] of (Object.entries(mappings)                   )) {
       const prerequisites = Array.isArray(m.prerequisites) ? m.prerequisites : [];
       if (m.status === 'unavailable' || (m.status !== 'supported' && m.status !== 'different')) none.push(id);
       else if (prerequisites.length === 0) runs.push(id);
@@ -129,17 +129,17 @@ function harnessHookNote({ repoRoot = REPO_ROOT }: any = {}): string {
   }
 }
 
-const isDir = (dir: any) => {
+const isDir = (dir     ) => {
   try {
     return fs.statSync(dir).isDirectory();
   } catch {
     return false;
   }
 };
-const folderOf = (root: any, slug: any) => path.join(root, 'agent-docs', 'doflow', slug);
+const folderOf = (root     , slug     ) => path.join(root, 'agent-docs', 'doflow', slug);
 
 /** The branch's feature slug as the resolver names it, or null. */
-function branchFeatureSlug(cwd: any) {
+function branchFeatureSlug(cwd     ) {
   try {
     const found = resolveActiveFeature({ projectRoot: cwd });
     const s = !found.error && found.paths ? found.paths.feature_slug : null;
@@ -155,7 +155,7 @@ function branchFeatureSlug(cwd: any) {
  * @param {{projectRoot: string, taskId?: string|null, slug?: string|null}} options
  * @returns {string|null}
  */
-function featureSlugFor({ projectRoot, taskId = null, slug = null }: any) {
+function featureSlugFor({ projectRoot, taskId = null, slug = null }     ) {
   if (slug) return slug;
   if (isSafeSlug(taskId) && isDir(folderOf(projectRoot, taskId))) return taskId;
   return branchFeatureSlug(projectRoot);
@@ -163,7 +163,7 @@ function featureSlugFor({ projectRoot, taskId = null, slug = null }: any) {
 
 /** The feature a run belongs to: the slug recorded when it started, else its task id when that names
  * a feature folder in the checkout holding the run. */
-function runSlugOf(run: any, root: any) {
+function runSlugOf(run     , root     ) {
   if (run && typeof run.featureSlug === 'string' && run.featureSlug !== '') return run.featureSlug;
   return run && isSafeSlug(run.taskId) && isDir(folderOf(root, run.taskId)) ? run.taskId : null;
 }
@@ -176,7 +176,7 @@ function runSlugOf(run: any, root: any) {
  * @returns {{status: 'found'|'missing'|'ambiguous', file: string|null, root: string|null,
  *   origin: 'current'|'other'|null, candidates: Array<string>}}
  */
-function findRunFile({ stateRoot, taskId, slug, exec }: any) {
+function findRunFile({ stateRoot, taskId, slug, exec }     ) {
   const rel = path.join('.doflow', 'state', 'orchestration', `${taskId}.json`);
   const missing = { status: 'missing', file: null, root: null, origin: null, candidates: [] };
   if (fs.existsSync(path.join(stateRoot, rel))) {
@@ -185,7 +185,7 @@ function findRunFile({ stateRoot, taskId, slug, exec }: any) {
   if (!slug) return missing;
   const checkouts = listCheckouts({ cwd: stateRoot, ...(exec ? { exec } : {}) });
   if (!checkouts.ok || checkouts.sandbox) return missing;
-  const matches = checkouts.others.filter((root: any) => {
+  const matches = checkouts.others.filter((root     ) => {
     const file = path.join(root, rel);
     if (!fs.existsSync(file)) return false;
     try {
@@ -195,13 +195,13 @@ function findRunFile({ stateRoot, taskId, slug, exec }: any) {
     }
   });
   if (matches.length === 0) return missing;
-  if (matches.length > 1) return { ...missing, status: 'ambiguous', candidates: matches.map((root: any) => path.join(root, rel)) };
+  if (matches.length > 1) return { ...missing, status: 'ambiguous', candidates: matches.map((root     ) => path.join(root, rel)) };
   return { status: 'found', file: path.join(matches[0], rel), root: matches[0], origin: 'other', candidates: [] };
 }
 
 /** The slug a refusal's next command names: one whose feature folder exists in this checkout or in
  * the main checkout, which is when `readiness --slug` resolves it the same way the edit hook does. */
-function nextSlugFor({ stateRoot, taskId, slug, exec }: any) {
+function nextSlugFor({ stateRoot, taskId, slug, exec }     ) {
   if (!slug || slug === taskId) return null;
   if (isDir(folderOf(stateRoot, slug))) return slug;
   const checkouts = listCheckouts({ cwd: stateRoot, ...(exec ? { exec } : {}) });
@@ -209,7 +209,7 @@ function nextSlugFor({ stateRoot, taskId, slug, exec }: any) {
 }
 
 /** Why a record cannot be read as an evaluation, or null when it can. */
-function unusableDetail(record: any, now: any) {
+function unusableDetail(record     , now     ) {
   if (!record || typeof record !== 'object' || Array.isArray(record)) return 'not a JSON object';
   if (record.version !== RECORD_VERSION) return `version ${JSON.stringify(record.version)}, this runtime reads ${RECORD_VERSION}`;
   for (const key of ['state', 'taskClass', 'evaluatedAt']) {
@@ -235,11 +235,11 @@ function unusableDetail(record: any, now: any) {
  *   record: Object|null, file: string|null, origin: string|null, candidates: Array<string>,
  *   detail: string|null, nextSlug: string|null, message: string|null}}
  */
-function checkReadiness({ stateRoot, taskId, slug = null, template, now = new Date(), exec }: any) {
+function checkReadiness({ stateRoot, taskId, slug = null, template, now = new Date(), exec }     ) {
   const read = readReadinessRecord({ stateRoot, taskId, slug, exec });
   const newerVersion = read.status === 'found' ? newerVersionOf(read.record) : null;
   const nextSlug = nextSlugFor({ stateRoot, taskId, slug, exec });
-  const result = (code: any, detail: any = null) => ({
+  const result = (code     , detail      = null) => ({
     ok: code === 'ready',
     code,
     record: read.record,
@@ -274,7 +274,7 @@ function checkReadiness({ stateRoot, taskId, slug = null, template, now = new Da
  * @returns {Object} `{applies: false, reason}` or `{applies: true, runTaskId, stage, template, ok, code,
  *   record, message}`
  */
-function verifyReadinessCheck({ stateRoot, taskId, slug = null, now = new Date(), exec }: any) {
+function verifyReadinessCheck({ stateRoot, taskId, slug = null, now = new Date(), exec }     ) {
   let found = findRunFile({ stateRoot, taskId, slug, exec });
   if (found.status === 'missing' && slug && slug !== taskId) found = findRunFile({ stateRoot, taskId: slug, slug, exec });
   if (found.status === 'ambiguous') {
@@ -286,10 +286,10 @@ function verifyReadinessCheck({ stateRoot, taskId, slug = null, now = new Date()
   if (found.status === 'missing') return { applies: false, reason: 'no-run' };
   const run = readTaskState(fs, found.file);
   if (run.state === 'COMPLETED' || run.state === 'REJECTED') return { applies: false, reason: 'run-finished' };
-  const stageNodes = (run.program || []).filter((n: any) => n.type === 'stage');
+  const stageNodes = (run.program || []).filter((n     ) => n.type === 'stage');
   const stage = gatedStage(stageNodes);
   if (!stage) return { applies: false, reason: 'no-gated-stage' };
-  const node = stageNodes.find((n: any) => n.id === stage.id);
+  const node = stageNodes.find((n     ) => n.id === stage.id);
   if (node.status === 'completed' || node.status === 'skipped') return { applies: false, reason: 'gated-stage-done' };
 
   const template = stage.readinessTemplate;

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

@@ -45,7 +45,7 @@
  */
 
 const os = require('node:os');
-const { readLock } = require('../../state/lockfile.ts');
+const { readLock } = require('../../state/lockfile.js');
 
 /** The scopes a report is assembled from. Mirrors `readScopes`'s pair; a finding naming anything
  * else is a caller bug and is reported as such rather than silently counted either way. */
@@ -111,9 +111,9 @@ const REPAIR_REASONS = Object.freeze({
 
 /** The harnesses a lock document pins, and how it pins them. Mirrors `reconcile`'s own reading:
  * a missing lock and a lock with an empty `targets` array are equally unable to repair anything. */
-function scopePin(scope: any, lock: any): any {
+function scopePin(scope     , lock     )      {
   const targets = Array.isArray(lock?.targets)
-    ? lock.targets.map((entry: any) => entry?.harness).filter((harness: any) => typeof harness === 'string' && harness !== '')
+    ? lock.targets.map((entry     ) => entry?.harness).filter((harness     ) => typeof harness === 'string' && harness !== '')
     : [];
   const state = !lock ? 'absent' : (targets.length === 0 ? 'empty' : 'present');
   return { scope, lock: state, pinned: state === 'present', targets, findings: 0, repairable: 0 };
@@ -122,7 +122,7 @@ function scopePin(scope: any, lock: any): any {
 /** Decide one finding against the pins. Repair-path reach is tested before lock reach: a finding
  * no command performs is unreachable for a more fundamental reason than a narrow pin, and naming
  * the pin would imply widening it is the fix. */
-function classify(finding: any, pins: any): any {
+function classify(finding     , pins     )      {
   const pin = pins[finding?.scope];
   if (!pin) return { repairable: false, reason: REPAIR_REASONS.UNKNOWN_SCOPE };
   const declared = finding.repairPath;
@@ -139,7 +139,7 @@ function classify(finding: any, pins: any): any {
 
 /** One sentence a reader meets before the detail, so the gap cannot be missed by someone who does
  * not read the counts. States what is repairable and by what; never suggests a way to widen it. */
-function summarize(total: number, repairable: number): string {
+function summarize(total        , repairable        )         {
   if (total === 0) return 'No findings — repair coverage does not arise.';
   if (repairable === total) {
     return `All ${total} finding(s) are repairable by \`doflow reconcile\`.`;
@@ -164,7 +164,7 @@ function summarize(total: number, repairable: number): string {
  * @throws when a lock file exists but cannot be parsed or validated. Propagated deliberately:
  *   `reconcile` would fail on the same document, so guessing its reach would be fiction.
  */
-function readScopeLocks({ projectRoot, homeDir = os.homedir() }: any, { fsImpl }: any = {}): any {
+function readScopeLocks({ projectRoot, homeDir = os.homedir() }     , { fsImpl }      = {})      {
   return {
     global: readLock({ scope: 'global', homeDir }, { fsImpl }),
     project: readLock({ scope: 'project', projectRoot }, { fsImpl }),
@@ -180,12 +180,12 @@ function readScopeLocks({ projectRoot, homeDir = os.homedir() }: any, { fsImpl }
  *   as `readScopeLocks` returns them. A missing or `null` entry is an unpinned scope.
  * @returns {RepairCoverage}
  */
-function repairCoverage({ findings = [], locks = {} }: any = {}): any {
+function repairCoverage({ findings = [], locks = {} }      = {})      {
   const rows = Array.isArray(findings) ? findings : [];
   const pins = Object.fromEntries(SCOPES.map((scope) => [scope, scopePin(scope, locks?.[scope] ?? null)]));
 
-  const reasons: any = {};
-  const details = rows.map((finding: any) => {
+  const reasons      = {};
+  const details = rows.map((finding     ) => {
     const { repairable, reason } = classify(finding, pins);
     const pin = pins[finding?.scope];
     if (pin) {
@@ -202,7 +202,7 @@ function repairCoverage({ findings = [], locks = {} }: any = {}): any {
     };
   });
 
-  const repairable = details.filter((row: any) => row.repairable).length;
+  const repairable = details.filter((row     ) => row.repairable).length;
   return {
     findings: details.length,
     repairable,

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

@@ -7,7 +7,7 @@
  *
  * Two recorded resources describe the same logical asset when two parts agree: the harness, and the
  * ownership identity the adapter recorded for that resource. That pair is not a new key — it is the
- * stored ownership key (`src/state/index.ts#ownershipKey`, five components) with its two
+ * stored ownership key (`src/state/index.js#ownershipKey`, five components) with its two
  * scope-bearing components dropped: the `scope`, which names itself, and the absolute `target`,
  * which differs between a global and a project copy of the same asset by construction. So this is a
  * projection of a key the ledger already holds, not a value reconstructed from a path; nothing is
@@ -53,7 +53,7 @@
  *   user can hand-edit. `null` is a signal to the caller to report the row as unresolved, never a
  *   value to join or compare against another `null`.
  */
-function deriveAssetIdentity(resource: any): string | null {
+function deriveAssetIdentity(resource     )                {
   if (!resource || typeof resource !== 'object') return null;
   const { harness, ownershipIdentity } = resource;
   if (typeof harness !== 'string' || harness === '') return null;

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

@@ -59,13 +59,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { harnessFor, loadRegistry } = require('../../registry/index.ts');
-const { readScopes } = require('./read-scopes.ts');
-const { deriveAssetIdentity } = require('./identity.ts');
-const { resolveShadowVerdict } = require('./precedence.ts');
-const { inspectSiblings } = require('./siblings.ts');
-const { repairCoverage, readScopeLocks } = require('./coverage.ts');
-const { finishRuntime, usageError } = require('../cli-result.ts');
+const { harnessFor, loadRegistry } = require('../../registry/index.js');
+const { readScopes } = require('./read-scopes.js');
+const { deriveAssetIdentity } = require('./identity.js');
+const { resolveShadowVerdict } = require('./precedence.js');
+const { inspectSiblings } = require('./siblings.js');
+const { repairCoverage, readScopeLocks } = require('./coverage.js');
+const { finishRuntime, usageError } = require('../cli-result.js');
 
 /** The three currency values of IC-002, and never a fourth. The third is not a weaker second: a
  * copy nothing in this scope's plan spoke about has not "diverged", it cannot be judged at all.
@@ -110,14 +110,14 @@ const RECONCILE = 'reconcile';
 const MANUAL = 'manual';
 
 /** Report vocabulary -> registry vocabulary (`scopePrecedence.order` names the global scope `user`). */
-function toRegistryScope(scope: any): any { return scope === 'global' ? 'user' : scope; }
+function toRegistryScope(scope     )      { return scope === 'global' ? 'user' : scope; }
 /** Registry vocabulary -> report vocabulary. The inverse of the above, applied to every scope name
  * `precedence.js` hands back, so a verdict never names a scope the rest of the report does not. */
-function toReportScope(scope: any): any { return scope === 'user' ? 'global' : scope; }
+function toReportScope(scope     )      { return scope === 'user' ? 'global' : scope; }
 
 /** The four fields that identify one recorded resource, and the same four an adapter change carries.
  * Not `ownershipKey` from src/state: that one includes the scope, and a plan change has none. */
-function recordKey(record: any): string {
+function recordKey(record     )         {
   return [record?.harness, record?.assetId, record?.target, record?.ownershipIdentity].join('\u0000');
 }
 
@@ -141,7 +141,7 @@ function recordKey(record: any): string {
  * component boundaries here. A prerequisite is deliberately *not* disqualifying — it says the change
  * cannot yet be applied, not that the plan could not determine it.
  */
-function planBasis(snapshot: any): any {
+function planBasis(snapshot     )      {
   const changes = new Map();
   for (const change of snapshot?.plan?.changes ?? []) {
     if (change && typeof change === 'object') changes.set(recordKey(change), change);
@@ -181,7 +181,7 @@ function planBasis(snapshot: any): any {
  * @returns {boolean} false whenever the destination cannot be read, or the change names no
  *   fingerprint — an absent or unreadable file is no evidence that its content is current.
  */
-function contentAlreadyCurrent(change: any, fsImpl: any): boolean {
+function contentAlreadyCurrent(change     , fsImpl     )          {
   const intended = change?.fingerprint;
   if (typeof intended !== 'string' || intended === '') return false;
   let observed;
@@ -231,7 +231,7 @@ function contentAlreadyCurrent(change: any, fsImpl: any): boolean {
  *   `null` for the other two values — a copy that was judged needs no basis, and a diverged one's
  *   remedy is the restore `remedyFor` already states.
  */
-function currencyOf(resource: any, basis: any, fsImpl: any = fs): any {
+function currencyOf(resource     , basis     , fsImpl      = fs)      {
   const recorded = resource?.fingerprint;
   if (typeof recorded !== 'string' || recorded === '') {
     return {
@@ -294,13 +294,13 @@ function currencyOf(resource: any, basis: any, fsImpl: any = fs): any {
 }
 
 /** The literal command that would converge one scope. Text only — this verb never runs it. */
-function reconcileCommand(scope: any, projectRoot: any): string {
+function reconcileCommand(scope     , projectRoot     )         {
   return scope === 'global' ? 'doflow reconcile -g' : `doflow reconcile ${projectRoot}`;
 }
 
 /** One copy of a logical asset, as IC-002 requires: where it is, and how current it is — plus, where
  * it could not be judged at all, what would give a later run a basis for judging it. */
-function copyEntry(resource: any, scope: any, basis: any, fsImpl: any): any {
+function copyEntry(resource     , scope     , basis     , fsImpl     )      {
   const currency = currencyOf(resource, basis, fsImpl);
   return {
     scope,
@@ -321,9 +321,9 @@ function copyEntry(resource: any, scope: any, basis: any, fsImpl: any): any {
  * @returns {{groups: Map<string, Object>, unidentified: Array<Object>}} `unidentified` holds one
  *   row per resource whose identity could not be derived — never grouped, since `null` is not a key.
  */
-function groupByIdentity(snapshots: any, fsImpl: any): any {
+function groupByIdentity(snapshots     , fsImpl     )      {
   const groups = new Map();
-  const unidentified: any[] = [];
+  const unidentified        = [];
   for (const snapshot of snapshots) {
     const basis = planBasis(snapshot);
     for (const resource of snapshot.resources ?? []) {
@@ -351,15 +351,15 @@ function groupByIdentity(snapshots: any, fsImpl: any): any {
 /** The harness's recorded precedence block, or `null` when it declares none — the fifth IC-003
  * state (the question has not been asked), which `precedence.js` must see as an absence rather than
  * as an empty object it could misread as a block with no mode. */
-function precedenceFor(registry: any, harness: any): any {
+function precedenceFor(registry     , harness     )      {
   try { return harnessFor(registry, harness).scopePrecedence ?? null; }
   catch { return null; }
 }
 
 /** Every unmanaged entry sharing a directory with one of this asset's copies, attributed to the
  * scope whose copy put it in view. Never carries a currency (data model: `UNMANAGED_CANDIDATE`). */
-function unmanagedFor(copies: any, candidatesByTarget: any): any[] {
-  const found: any[] = [];
+function unmanagedFor(copies     , candidatesByTarget     )        {
+  const found        = [];
   for (const copy of copies) {
     for (const candidate of candidatesByTarget[copy.location] ?? []) {
       found.push({ ...candidate, scope: copy.scope });
@@ -371,8 +371,8 @@ function unmanagedFor(copies: any, candidatesByTarget: any): any[] {
 /** The literal actions that would resolve this asset's findings, in the order a reader should take
  * them. One object per asset (IC-002's "the remedy"), holding every step rather than the first, so
  * an asset that is both diverged and shadowed does not have half its remedy silently dropped. */
-function remedyFor({ copies, verdict, unmanaged, projectRoot }: any): any {
-  const actions: any[] = [];
+function remedyFor({ copies, verdict, unmanaged, projectRoot }     )      {
+  const actions        = [];
   for (const copy of copies) {
     if (copy.currency === CURRENCY.DIVERGED) {
       actions.push({
@@ -393,7 +393,7 @@ function remedyFor({ copies, verdict, unmanaged, projectRoot }: any): any {
     }
   }
   if (verdict?.shadowed && verdict.winner) {
-    const losers = copies.filter((copy: any) => copy.scope !== verdict.winner).map((copy: any) => copy.location);
+    const losers = copies.filter((copy     ) => copy.scope !== verdict.winner).map((copy     ) => copy.location);
     actions.push({
       finding: FINDING_KINDS.SHADOW,
       action: `edit the copy the harness actually loads — the ${verdict.winner} one — or delete the `
@@ -404,7 +404,7 @@ function remedyFor({ copies, verdict, unmanaged, projectRoot }: any): any {
   if (verdict?.shadowed && !verdict.winner) {
     actions.push({
       finding: FINDING_KINDS.WITHHELD_VERDICT,
-      action: `keep exactly one copy — ${copies.map((copy: any) => copy.location).join(' or ')} — because `
+      action: `keep exactly one copy — ${copies.map((copy     ) => copy.location).join(' or ')} — because `
         + `${verdict.withheldReason}, so which one takes effect cannot be stated`,
       command: null,
     });
@@ -449,8 +449,8 @@ function remedyFor({ copies, verdict, unmanaged, projectRoot }: any): any {
  *   finding about it. The harness is in the key because a directory two harnesses both load
  *   wholesale makes the same file operative twice, which is two facts.
  */
-function findingsFor({ identity, harness, copies, verdict, unmanaged }: any, seenUnmanaged: any): any[] {
-  const findings: any[] = [];
+function findingsFor({ identity, harness, copies, verdict, unmanaged }     , seenUnmanaged     )        {
+  const findings        = [];
   for (const copy of copies) {
     if (copy.currency === CURRENCY.DIVERGED) {
       findings.push({ id: identity, kind: FINDING_KINDS.DIVERGENCE, harness, scope: copy.scope, repairPath: RECONCILE });
@@ -484,7 +484,7 @@ function findingsFor({ identity, harness, copies, verdict, unmanaged }: any, see
  * A restriction to named harnesses is named in the sentence, because the sentence is where a reader
  * decides whether to act. "nothing requires attention" read off a run restricted to one harness — or
  * to a harness that is not installed — would otherwise be taken for a statement about the install. */
-function summarize({ findings, assets, unidentified, targets }: any): string {
+function summarize({ findings, assets, unidentified, targets }     )         {
   const counts = new Map();
   for (const finding of findings) counts.set(finding.kind, (counts.get(finding.kind) ?? 0) + 1);
   const subject = `${assets.length} logical asset(s)${targets ? ` recorded for ${targets.join(', ')}` : ''}`;
@@ -531,7 +531,7 @@ function summarize({ findings, assets, unidentified, targets }: any): string {
  *   exists but cannot be read is the same class as a ledger that cannot: the report would have to
  *   invent the selection the plan is computed from.
  */
-function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks, fsImpl }: any = {}): any {
+function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks, fsImpl }      = {})      {
   const loaded = registry ?? loadRegistry({ repoRoot });
   const requested = Array.isArray(targets) && targets.length > 0 ? targets : undefined;
   // Validated before anything is read, so an unknown harness fails as the argument error it is
@@ -550,12 +550,12 @@ function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks,
 
   const { groups, unidentified } = groupByIdentity(scopes, fsImpl ?? fs);
   const siblings = inspectSiblings({
-    resources: scopes.flatMap((snapshot: any) => snapshot.resources ?? []),
+    resources: scopes.flatMap((snapshot     ) => snapshot.resources ?? []),
     ...(fsImpl ? { fsImpl } : {}),
   });
 
-  const assets: any[] = [];
-  const findings: any[] = [];
+  const assets        = [];
+  const findings        = [];
   // One finding per unmanaged file across the whole report, not per asset that lists it (FR-007;
   // see the header's note 3). Assets are walked in identity order, so which entry carries the
   // finding is deterministic.
@@ -563,7 +563,7 @@ function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks,
   for (const identity of [...groups.keys()].sort()) {
     const { harness, assetId, copies } = groups.get(identity);
     // Both crossings of the vocabulary seam, in one place: in, then straight back out.
-    const raw = resolveShadowVerdict(copies.map((copy: any) => toRegistryScope(copy.scope)), precedenceFor(loaded, harness));
+    const raw = resolveShadowVerdict(copies.map((copy     ) => toRegistryScope(copy.scope)), precedenceFor(loaded, harness));
     const verdict = raw && {
       presentAt: raw.presentAt.map(toReportScope),
       shadowed: raw.shadowed,
@@ -603,7 +603,7 @@ function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks,
     status: findings.length === 0 ? 'CLEAN' : 'FINDINGS',
     exitCode: findings.length === 0 ? 0 : 1,
     summary: summarize({ findings, assets, unidentified, targets: requested }),
-    scopes: scopes.map((snapshot: any) => ({
+    scopes: scopes.map((snapshot     ) => ({
       scope: snapshot.scope,
       root: snapshot.scopeRoot,
       present: snapshot.recorded,
@@ -618,7 +618,7 @@ function buildInventoryReport({ repoRoot, projectRoot, targets, registry, locks,
 
 /** Human rendering. The same facts as `--json`, in the same order, so neither shape is the one that
  * tells the truth. */
-function printReport(report: any): void {
+function printReport(report     )       {
   console.log('\nDoFlow cross-scope inventory:');
   console.log('═'.repeat(78));
   console.log(report.summary);
@@ -679,7 +679,7 @@ function printReport(report: any): void {
  *   question from the one the caller asked.
  * @returns {number} the exit status, already set on the process
  */
-function handleInventoryCommand({ repoRoot, projectRoot, targets, json = false, global: globalScope = false }: any = {}): any {
+function handleInventoryCommand({ repoRoot, projectRoot, targets, json = false, global: globalScope = false }      = {})      {
   if (globalScope) {
     return usageError('inventory', '-g/--global is not accepted: this verb reads both scopes in one '
       + 'invocation, which is its entire purpose. Re-run without the flag.', json);
@@ -691,7 +691,7 @@ function handleInventoryCommand({ repoRoot, projectRoot, targets, json = false,
   } catch (error) {
     // IC-001 assigns an unreadable registry, an unparseable ledger and an undeclared harness alike
     // to exit 2. A scope with nothing recorded never reaches here — `readScopes` returns it empty.
-    return usageError('inventory', (error as any).message, json, error);
+    return usageError('inventory', (error       ).message, json, error);
   }
 
   if (json) console.log(JSON.stringify(report, null, 2));