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

package/src/install/{backup-set.ts → backup-set.js}

@@ -11,25 +11,25 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../install/backup-set.ts')` keeps working while the tree is still `.js`. The
+// caller's `require('../install/backup-set.js')` keeps working while the tree is still `.js`. The
 // `./backup` require carries `.ts` because backup migrated in the same slice.
 const fs = require('node:fs');
 const path = require('node:path');
-const { BackupError, scopeRelative } = require('./backup.ts');
+const { BackupError, scopeRelative } = require('./backup.js');
 
 const REASON_ORDER = ['change', 'companion', 'relocated-from', 'tombstone', 'snapshot', 'record'];
 
-function byCodePoint(a: string, b: string): number {
+function byCodePoint(a        , b        )         {
   if (a === b) return 0;
   return a < b ? -1 : 1;
 }
 
 /** What a set entry is on disk now, following links. */
-function statEntry(file: string, fsImpl: any): { kind: string; size: number | null; mode: number | null } {
+function statEntry(file        , fsImpl     )                                                             {
   let stat;
   try {
     stat = fsImpl.statSync(file);
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return { kind: 'absent', size: null, mode: null };
     throw new BackupError(`could not read ${file}: ${err.code || err.message}`);
   }
@@ -37,19 +37,19 @@ function statEntry(file: string, fsImpl: any): { kind: string; size: number | nu
   return { kind: 'other', size: null, mode: null };
 }
 
-function isAtOrUnder(file: string, root: string): boolean {
+function isAtOrUnder(file        , root        )          {
   const resolved = path.resolve(root);
   return file === resolved || file.startsWith(resolved.endsWith(path.sep) ? resolved : resolved + path.sep);
 }
 
 /** Candidates (absolute path -> harnesses and reasons) into a BackupSet, after the exclusions.
  * A path in `records` is kept even under an excluded root. */
-function toBackupSet(candidates: Map<string, any>, { scope, scopeRoot, exclude, excluded, records = [], fsImpl }: any): any {
+function toBackupSet(candidates                  , { scope, scopeRoot, exclude, excluded, records = [], fsImpl }     )      {
   const root = path.resolve(scopeRoot);
-  const kept = new Set(records.map((file: string) => path.resolve(file)));
+  const kept = new Set(records.map((file        ) => path.resolve(file)));
   const entries = [];
   for (const file of [...candidates.keys()].sort(byCodePoint)) {
-    if (!kept.has(file) && exclude.some((x: string) => isAtOrUnder(file, x))) {
+    if (!kept.has(file) && exclude.some((x        ) => isAtOrUnder(file, x))) {
       excluded.push({ path: file, reason: 'doflow-state' });
       continue;
     }
@@ -67,15 +67,15 @@ function toBackupSet(candidates: Map<string, any>, { scope, scopeRoot, exclude,
     scope,
     scopeRoot: root,
     entries,
-    excluded: excluded.sort((a: any, b: any) => byCodePoint(a.path, b.path)),
+    excluded: excluded.sort((a     , b     ) => byCodePoint(a.path, b.path)),
     count: entries.length,
     existing: files.length,
     absent: entries.filter((e) => e.kind === 'absent').length,
-    bytes: files.reduce((sum, e) => sum + (e.size as number), 0),
+    bytes: files.reduce((sum, e) => sum + (e.size          ), 0),
   };
 }
 
-function addCandidate(candidates: Map<string, any>, file: string, harness: string | null, reason: string): void {
+function addCandidate(candidates                  , file        , harness               , reason        )       {
   const key = path.resolve(file);
   if (!candidates.has(key)) candidates.set(key, { harnesses: new Set(), reasons: new Set() });
   const item = candidates.get(key);
@@ -92,13 +92,13 @@ function addCandidate(candidates: Map<string, any>, file: string, harness: strin
  * it writes back (backup.ts mergeRestoredLedger). They join only a set that holds some file already,
  * so a run that backs up nothing still backs up nothing.
  */
-function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }: any): any {
+function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }     )      {
   const candidates = new Map();
   const mcpOnly = new Map();
   const resources = plan.ledger?.resources ?? [];
   const tombstones = plan.ledger?.tombstones ?? [];
   // A retained or released change gives up a ledger row and touches no file.
-  const changes = plan.changes.filter((change: any) => change.retained !== true && change.release !== true);
+  const changes = plan.changes.filter((change     ) => change.retained !== true && change.release !== true);
 
   for (const change of changes) {
     const target = path.resolve(change.target);
@@ -121,7 +121,7 @@ function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [],
     }
   }
 
-  const owned = new Set(resources.filter((r: any) => typeof r.target === 'string').map((r: any) => path.resolve(r.target)));
+  const owned = new Set(resources.filter((r     ) => typeof r.target === 'string').map((r     ) => path.resolve(r.target)));
   for (const tombstone of tombstones) {
     if (tombstone.sweptAt || typeof tombstone.fromTarget !== 'string') continue;
     if (owned.has(path.resolve(tombstone.fromTarget)) || !fsImpl.existsSync(tombstone.fromTarget)) continue;
@@ -137,7 +137,7 @@ function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [],
 
 /** A BackupSet of the given absolute paths, for the pre-rollback snapshot. `records` as for
  * backupSetFromPlan: a restored ledger is snapshotted too, so the snapshot rolls back as a whole. */
-function backupSetFromPaths({ items, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }: any): any {
+function backupSetFromPaths({ items, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }     )      {
   const candidates = new Map();
   for (const item of items) {
     if (item.harnesses.length === 0) addCandidate(candidates, item.path, null, 'snapshot');

package/src/install/{backup.ts → backup.js}

@@ -13,18 +13,18 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../install/backup.ts')` keeps working while the tree is still `.js`. The
-// `./paths` require already carries `.ts` (paths migrated first); `../helper/git.ts` is `.ts` too.
+// caller's `require('../install/backup.js')` keeps working while the tree is still `.js`. The
+// `./paths` require already carries `.ts` (paths migrated first); `../helper/git.js` is `.ts` too.
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
 const { execFileSync } = require('node:child_process');
-const { sourceCommit: gitSourceCommit } = require('../helper/git.ts');
+const { sourceCommit: gitSourceCommit } = require('../helper/git.js');
 const {
   legacyBackupReadRoot, isLegacyBackupReadRoot, scopeRootFromCanonicalBackupRoot,
-} = require('./paths.ts');
-const { validateLedger } = require('../state/index.ts');
+} = require('./paths.js');
+const { validateLedger } = require('../state/index.js');
 
 /** Where a listed/restorable backup was found. 'current' = the canonical `.doflow/backups` root the
  * installer writes to; 'legacy' = the pre-7de6d5f `.claude/backups` root, readable only. Callers
@@ -34,7 +34,7 @@ const BACKUP_ORIGIN_LEGACY = 'legacy';
 
 /** The roots a READ (list/restore) consults for a scope, canonical first, legacy second.
  * Order is the precedence rule too: an id present in both resolves to the canonical copy. */
-function backupReadRoots(backupRoot: string): Array<{ root: string; origin: string }> {
+function backupReadRoots(backupRoot        )                                          {
   const roots = [{ root: path.resolve(backupRoot), origin: BACKUP_ORIGIN_CURRENT }];
   const scopeRoot = scopeRootFromCanonicalBackupRoot(backupRoot);
   if (scopeRoot) {
@@ -47,16 +47,16 @@ function backupReadRoots(backupRoot: string): Array<{ root: string; origin: stri
 /** Writes and deletes are canonical-only. The legacy root holds restore points DoFlow no longer
  * manages and may be a user's sole recovery material, so a mutating call aimed at it is a bug to
  * surface, not a path to follow. */
-function assertMutableBackupRoot(backupRoot: string, operation: string): void {
+function assertMutableBackupRoot(backupRoot        , operation        )       {
   if (isLegacyBackupReadRoot(backupRoot)) {
     throw new Error(`Refusing to ${operation} in the legacy backup root (read-only): ${backupRoot}`);
   }
 }
 
-function pad2(n: number): string { return String(n).padStart(2, '0'); }
+function pad2(n        )         { return String(n).padStart(2, '0'); }
 
 /** `<op>_YYYY-MM-DD_HH-MM-SS`, using a caller-supplied Date (never `new Date()` internally — keeps this testable/deterministic). */
-function backupId(op: string, date: Date): string {
+function backupId(op        , date      )         {
   const y = date.getFullYear();
   const mo = pad2(date.getMonth() + 1);
   const d = pad2(date.getDate());
@@ -78,8 +78,8 @@ const DEFAULT_BACKUP_RETENTION = 3;
 
 /** A backup could not be written completely. The caller stops before changing anything. */
 class BackupError extends Error {
-  declare code: string;
-  constructor(message: string) {
+                       
+  constructor(message        ) {
     super(message);
     this.name = 'BackupError';
     this.code = 'backup-failed';
@@ -87,14 +87,14 @@ class BackupError extends Error {
 }
 
 /** POSIX path of `p` relative to `scopeRoot`, or null when `p` is not strictly inside it. */
-function scopeRelative(scopeRoot: string, p: string): string | null {
+function scopeRelative(scopeRoot        , p        )                {
   const rel = path.relative(scopeRoot, p);
   if (!rel || path.isAbsolute(rel) || rel.split(path.sep)[0] === '..') return null;
   return rel.split(path.sep).join('/');
 }
 
 /** Manifest JSON: two-space indentation, except one compact line per `files` and `excluded` element. */
-function serializeManifest(manifest: Record<string, any>): string {
+function serializeManifest(manifest                     )         {
   const body = Object.entries(manifest).map(([key, value]) => {
     if ((key === 'files' || key === 'excluded') && Array.isArray(value) && value.length > 0) {
       return `  ${JSON.stringify(key)}: [\n${value.map((v) => `    ${JSON.stringify(v)}`).join(',\n')}\n  ]`;
@@ -104,7 +104,7 @@ function serializeManifest(manifest: Record<string, any>): string {
   return `{\n${body.join(',\n')}\n}\n`;
 }
 
-function errorCode(err: any): string { return err.code || err.message; }
+function errorCode(err     )         { return err.code || err.message; }
 
 /**
  * Copy the files of a backup set into `<backupRoot>/<id>/` (format 2). Returns null for an empty
@@ -114,14 +114,14 @@ function errorCode(err: any): string { return err.code || err.message; }
 function createFileBackup({
   operation, set, backupRoot, repoRoot, sourceCommit, version, date, restores = null,
   fsImpl = fs, randomHex = () => crypto.randomBytes(4).toString('hex'),
-}: any): null | { id: string; dir: string; files: number; existed: number; absent: number; bytes: number } {
+}     )                                                                                                    {
   assertMutableBackupRoot(backupRoot, 'create a backup');
   if (set.entries.length === 0) return null;
 
   const base = backupId(operation, date);
   const tmpDir = path.join(backupRoot, `${TEMP_PREFIX}${base}-${process.pid}-${randomHex()}`);
   let tmpCreated = false;
-  const writeFailure = (err: any) => new BackupError(`could not write ${backupRoot}: ${errorCode(err)}`);
+  const writeFailure = (err     ) => new BackupError(`could not write ${backupRoot}: ${errorCode(err)}`);
 
   try {
     try {
@@ -137,11 +137,11 @@ function createFileBackup({
     const summary = { files: 0, existed: 0, absent: 0, bytes: 0 };
     let external = 0;
     for (const entry of set.entries) {
-      const record: any = entry.rel !== null ? { path: entry.rel } : { path: entry.path, outside: true };
+      const record      = entry.rel !== null ? { path: entry.rel } : { path: entry.path, outside: true };
       let stat = null;
       try {
         stat = fsImpl.statSync(entry.path);
-      } catch (err: any) {
+      } catch (err     ) {
         if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') {
           throw new BackupError(`could not read ${entry.path}: ${errorCode(err)}`);
         }
@@ -172,21 +172,21 @@ function createFileBackup({
       files.push(record);
     }
 
-    const manifest: any = {
+    const manifest      = {
       id: base,
       operation,
       timestamp: date.toISOString(),
       source_path: repoRoot,
       source_commit: sourceCommit ?? gitSourceCommit(repoRoot),
       type: 'files',
-      tools_affected: [...new Set(set.entries.flatMap((e: any) => e.harnesses))].sort(),
+      tools_affected: [...new Set(set.entries.flatMap((e     ) => e.harnesses))].sort(),
       format: 2,
       doflow_version: version,
       scope: set.scope,
       scope_root: set.scopeRoot,
       restores,
       summary,
-      excluded: set.excluded.map((x: any) => {
+      excluded: set.excluded.map((x     ) => {
         const rel = scopeRelative(set.scopeRoot, x.path);
         return rel !== null ? { path: rel, reason: x.reason } : { path: x.path, outside: true, reason: x.reason };
       }),
@@ -209,7 +209,7 @@ function createFileBackup({
           fsImpl.writeFileSync(manifestPath, serializeManifest(manifest));
         }
         fsImpl.renameSync(tmpDir, dir);
-      } catch (err: any) {
+      } catch (err     ) {
         if (RENAME_COLLISION_CODES.has(err.code) && fsImpl.existsSync(dir)) continue;
         throw writeFailure(err);
       }
@@ -224,17 +224,17 @@ function createFileBackup({
   }
 }
 
-function defaultIsAlive(pid: number): boolean {
+function defaultIsAlive(pid        )          {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
     return true;
-  } catch (err: any) {
+  } catch (err     ) {
     return err.code === 'EPERM';
   }
 }
 
-function isStaleTemp(dir: string, { now, fsImpl, isAlive, hostname }: any): boolean {
+function isStaleTemp(dir        , { now, fsImpl, isAlive, hostname }     )          {
   let owner = null;
   try { owner = JSON.parse(fsImpl.readFileSync(path.join(dir, OWNER_FILE), 'utf8')); } catch { /* no owner */ }
   if (!owner || typeof owner !== 'object') {
@@ -248,7 +248,7 @@ function isStaleTemp(dir: string, { now, fsImpl, isAlive, hostname }: any): bool
  * Remove `.tmp-*` directories left in `backupRoot` by runs that died: the owner process is gone on
  * this host, or the temp is older than 24 hours. Returns how many were removed.
  */
-function sweepStaleTemps(backupRoot: string, { now = Date.now(), fsImpl = fs, isAlive = defaultIsAlive, hostname = os.hostname() }: any = {}): number {
+function sweepStaleTemps(backupRoot        , { now = Date.now(), fsImpl = fs, isAlive = defaultIsAlive, hostname = os.hostname() }      = {})         {
   assertMutableBackupRoot(backupRoot, 'clean up backups');
   if (!fsImpl.existsSync(backupRoot)) return 0;
   let removed = 0;
@@ -269,8 +269,8 @@ function sweepStaleTemps(backupRoot: string, { now = Date.now(), fsImpl = fs, is
  * not know), 'full' or 'partial' (1.19, typed the way restoreBackup reads them), or 'incomplete'
  * (no manifest, or one that does not parse). `manifest` is the parsed object, or null.
  */
-function classifyBackupDir(dir: string, { fsImpl = fs }: any = {}): { kind: string; manifest: any } {
-  let manifest: any = null;
+function classifyBackupDir(dir        , { fsImpl = fs }      = {})                                  {
+  let manifest      = null;
   try { manifest = JSON.parse(fsImpl.readFileSync(path.join(dir, MANIFEST_FILE), 'utf8')); } catch { /* incomplete */ }
   if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) return { kind: 'incomplete', manifest: null };
   const { format } = manifest;
@@ -286,7 +286,7 @@ const ID_TIME = /^.+?_(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})(?:-(\d+))?
  * Ordering key of a backup directory: the manifest timestamp, else the time in its id (local
  * time, as backupId writes it), else its mtime. Retention and listing share it.
  */
-function sortKey(dir: string, { fsImpl = fs, manifest }: any = {}): { id: string; time: number; suffix: number } {
+function sortKey(dir        , { fsImpl = fs, manifest }      = {})                                               {
   const id = path.basename(dir);
   const m = manifest === undefined ? classifyBackupDir(dir, { fsImpl }).manifest : manifest;
   const match = ID_TIME.exec(id);
@@ -303,7 +303,7 @@ function sortKey(dir: string, { fsImpl = fs, manifest }: any = {}): { id: string
 }
 
 /** Newest first; ties go to the larger `-n` suffix, then the id in descending order. */
-function compareSortKeys(a: { id: string; time: number; suffix: number }, b: { id: string; time: number; suffix: number }): number {
+function compareSortKeys(a                                              , b                                              )         {
   if (a.time !== b.time) return b.time - a.time;
   if (a.suffix !== b.suffix) return b.suffix - a.suffix;
   if (a.id === b.id) return 0;
@@ -311,7 +311,7 @@ function compareSortKeys(a: { id: string; time: number; suffix: number }, b: { i
 }
 
 /** Bytes of the regular files under `dir`, never following a link; null when any read fails. */
-function backupSize(dir: string, { fsImpl = fs }: any = {}): number | null {
+function backupSize(dir        , { fsImpl = fs }      = {})                {
   try {
     let total = 0;
     const pending = [dir];
@@ -333,7 +333,7 @@ function backupSize(dir: string, { fsImpl = fs }: any = {}): number | null {
 const BYTE_UNITS = ['KiB', 'MiB', 'GiB', 'TiB'];
 
 /** `?` for an unknown size, `<n> B` below 1 KiB, otherwise one decimal in 1024-based units. */
-function formatBytes(n: number | null | undefined): string {
+function formatBytes(n                           )         {
   if (n === null || n === undefined) return '?';
   if (n < 1024) return `${n} B`;
   let value = n / 1024;
@@ -346,14 +346,14 @@ function formatBytes(n: number | null | undefined): string {
 }
 
 /** Security guard: a backup id is a directory *name*, never a path — reject traversal/absolute ids. */
-function assertSafeBackupId(bid: string): void {
+function assertSafeBackupId(bid        )       {
   if (!bid || bid.includes('/') || bid.includes('\\') || bid === '..' || bid.includes('..')) {
     throw new Error(`Invalid backup id: '${bid}'`);
   }
 }
 
 /** Restore a 1.19 backup id into the given tool dirs. dirs = {tool: absDstDir}. */
-function restoreBackup({ bid, backupRoot, dirs, dryRun = false }: any): void {
+function restoreBackup({ bid, backupRoot, dirs, dryRun = false }     )       {
   assertSafeBackupId(bid);
   // An id the user picked from `list-backups` may live in either root, so resolve it the same way
   // the listing found it. Restoring reads the backup and writes only into the tool dirs, so a
@@ -397,24 +397,24 @@ function restoreBackup({ bid, backupRoot, dirs, dryRun = false }: any): void {
 
 /** Raw member lines of a tar.gz archive. A whole-home archive can list far more than the default
  * 1 MiB of output, so the buffer is unbounded. */
-function defaultListTar(archive: string): string[] {
+function defaultListTar(archive        )           {
   return execFileSync('tar', ['-tzf', archive], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: Infinity })
     .split(/\r?\n/);
 }
 
 /** File members of an archive listing, relative to the archive root, without any `..` member. */
-function archiveMembers(lines: string[]): string[] {
+function archiveMembers(lines          )           {
   return lines
     .map((line) => line.replace(/^\.\//, ''))
     .filter((m) => m && m !== '.' && !m.endsWith('/') && !m.split('/').includes('..'));
 }
 
 /** Paths, relative to `root`, of the regular files under it; links are not followed. */
-function regularFilesUnder(root: string, fsImpl: any): string[] {
-  const files: string[] = [];
+function regularFilesUnder(root        , fsImpl     )           {
+  const files           = [];
   const pending = [''];
   while (pending.length > 0) {
-    const rel = pending.pop() as string;
+    const rel = pending.pop()          ;
     for (const e of fsImpl.readdirSync(path.join(root, rel), { withFileTypes: true })) {
       const child = path.join(rel, e.name);
       if (e.isDirectory()) pending.push(child);
@@ -425,7 +425,7 @@ function regularFilesUnder(root: string, fsImpl: any): string[] {
 }
 
 /** Why a format-2 entry cannot be restored, or null when it can. */
-function refusalOf(entry: any, target: string, { scope, scopeRoot, bkDir, fsImpl }: any): string | null {
+function refusalOf(entry     , target        , { scope, scopeRoot, bkDir, fsImpl }     )                {
   const raw = entry.path;
   if (entry.outside === true) {
     if (!path.isAbsolute(raw)) return 'unsafe path';
@@ -451,7 +451,7 @@ function refusalOf(entry: any, target: string, { scope, scopeRoot, bkDir, fsImpl
  * tool through restoreBackup; its snapshot lists the files that restore will overwrite.
  * Reads only.
  */
-function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTargets, dirs, ledgerFile = null, fsImpl = fs, listTar = defaultListTar }: any): any {
+function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTargets, dirs, ledgerFile = null, fsImpl = fs, listTar = defaultListTar }     )      {
   assertSafeBackupId(bid);
   const found = backupReadRoots(backupRoot).find((r) => fsImpl.existsSync(path.join(r.root, bid)));
   if (!found) throw new Error(`Backup not found: ${bid}`);
@@ -461,7 +461,7 @@ function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTarge
     throw new Error(`Backup ${bid} was made by a newer DoFlow (format ${manifest.format}); this version cannot restore it`);
   }
 
-  const plan: any = {
+  const plan      = {
     bid,
     origin: found.origin,
     bkDir,
@@ -484,7 +484,7 @@ function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTarge
       // writes, so --target narrows it with the files and never skips it.
       const isLedger = ledger !== null && entry.outside !== true && typeof entry.path === 'string' && entry.path !== ''
         && path.resolve(scopeRoot, entry.path) === ledger;
-      if (!isLedger && explicitTargets && !harnesses.some((h: string) => wanted.has(h))) {
+      if (!isLedger && explicitTargets && !harnesses.some((h        ) => wanted.has(h))) {
         plan.untargeted += 1;
         continue;
       }
@@ -505,12 +505,12 @@ function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTarge
       }
       plan.restore.push({ path: target, stored: path.resolve(bkDir, entry.stored), mode: entry.mode, size: entry.size, harnesses, ...(isLedger ? { ledger: true } : {}) });
     }
-    plan.snapshot = plan.restore.map((item: any) => ({ path: item.path, harnesses: item.harnesses }));
+    plan.snapshot = plan.restore.map((item     ) => ({ path: item.path, harnesses: item.harnesses }));
     return plan;
   }
 
   const tools = [];
-  for (const tool of wanted as Set<string>) {
+  for (const tool of wanted               ) {
     const dstDir = dirs[tool];
     if (!dstDir) continue;
     if (plan.type === 'full') {
@@ -536,21 +536,21 @@ function planRestore({ bid, backupRoot, scope, scopeRoot, targets, explicitTarge
  * up) stay as they are; restoring the whole old ledger would make DoFlow forget files and entries it
  * still has on disk. With no current ledger the backup's is taken whole.
  */
-function mergeRestoredLedger(backup: any, current: any, restored: Set<string>): any {
+function mergeRestoredLedger(backup     , current     , restored             )      {
   if (!current) return backup;
-  const at = (target: any) => typeof target === 'string' && restored.has(path.resolve(target));
+  const at = (target     ) => typeof target === 'string' && restored.has(path.resolve(target));
   return {
     ...current,
-    resources: [...current.resources.filter((r: any) => !at(r.target)), ...backup.resources.filter((r: any) => at(r.target))],
+    resources: [...current.resources.filter((r     ) => !at(r.target)), ...backup.resources.filter((r     ) => at(r.target))],
     tombstones: [
-      ...(current.tombstones ?? []).filter((t: any) => !at(t.fromTarget)),
-      ...(backup.tombstones ?? []).filter((t: any) => at(t.fromTarget)),
+      ...(current.tombstones ?? []).filter((t     ) => !at(t.fromTarget)),
+      ...(backup.tombstones ?? []).filter((t     ) => at(t.fromTarget)),
     ],
   };
 }
 
 /** The bytes a ledger restore item writes: the backup's ledger merged onto the current one. */
-function restoredLedgerBytes(item: any, restored: Set<string>, fsImpl: any): Buffer {
+function restoredLedgerBytes(item     , restored             , fsImpl     )         {
   const backup = validateLedger(JSON.parse(fsImpl.readFileSync(item.stored, 'utf8')));
   const current = fsImpl.existsSync(item.path) ? validateLedger(JSON.parse(fsImpl.readFileSync(item.path, 'utf8'))) : null;
   return Buffer.from(`${JSON.stringify(validateLedger(mergeRestoredLedger(backup, current, restored)), null, 2)}\n`);
@@ -563,17 +563,17 @@ function restoredLedgerBytes(item: any, restored: Set<string>, fsImpl: any): Buf
  * files written back before it (mergeRestoredLedger). It never deletes a file and never writes
  * outside `plan.restore`. A 1.19 plan goes through restoreBackup unchanged.
  */
-function executeRestore(plan: any, { backupRoot, dryRun = false, fsImpl = fs }: any): any {
+function executeRestore(plan     , { backupRoot, dryRun = false, fsImpl = fs }     )      {
   if (plan.format !== 2) {
-    const toolDirs = Object.fromEntries(plan.v1.tools.map((t: any) => [t.tool, t.dstDir]));
+    const toolDirs = Object.fromEntries(plan.v1.tools.map((t     ) => [t.tool, t.dstDir]));
     restoreBackup({ bid: plan.bid, backupRoot, dirs: toolDirs, dryRun });
-    return { restored: plan.v1.tools.map((t: any) => t.tool), failed: [], absent: [], refused: [], untargeted: 0, legacy: true };
+    return { restored: plan.v1.tools.map((t     ) => t.tool), failed: [], absent: [], refused: [], untargeted: 0, legacy: true };
   }
 
   const restored = [];
   const failed = [];
-  const files = new Set<string>();
-  const items = [...plan.restore.filter((item: any) => !item.ledger), ...plan.restore.filter((item: any) => item.ledger)];
+  const files = new Set        ();
+  const items = [...plan.restore.filter((item     ) => !item.ledger), ...plan.restore.filter((item     ) => item.ledger)];
   for (const item of items) {
     if (dryRun) {
       restored.push(item.path);
@@ -587,7 +587,7 @@ function executeRestore(plan: any, { backupRoot, dryRun = false, fsImpl = fs }:
       let isLink = false;
       try {
         isLink = fsImpl.lstatSync(item.path).isSymbolicLink();
-      } catch (err: any) {
+      } catch (err     ) {
         if (err.code !== 'ENOENT') throw err;
       }
       if (isLink) {
@@ -613,11 +613,11 @@ function executeRestore(plan: any, { backupRoot, dryRun = false, fsImpl = fs }:
 
 /** One `{ row, key }` per backup dir under `root`, tagged with where it came from. Dot-named
  * directories (temps of a run in progress) and symlinks are not backups. */
-function readBackupRows(root: string, origin: string): Array<{ key: any; row: any }> {
+function readBackupRows(root        , origin        )                                {
   if (!fs.existsSync(root)) return [];
   return fs.readdirSync(root, { withFileTypes: true })
-    .filter((e: any) => e.isDirectory() && !e.name.startsWith('.'))
-    .map((e: any) => {
+    .filter((e     ) => e.isDirectory() && !e.name.startsWith('.'))
+    .map((e     ) => {
       const bkDir = path.join(root, e.name);
       const { kind, manifest: m } = classifyBackupDir(bkDir);
       const key = sortKey(bkDir, { manifest: m });
@@ -641,7 +641,7 @@ function readBackupRows(root: string, origin: string): Array<{ key: any; row: an
  * manifest is missing), `complete` and `bytes` (null when unreadable), and are ordered by the
  * same key retention uses.
  */
-function listBackups(backupRoot: string): any[] {
+function listBackups(backupRoot        )        {
   const found = [];
   const seen = new Set();
   for (const { root, origin } of backupReadRoots(backupRoot)) {
@@ -663,10 +663,10 @@ function listBackups(backupRoot: string): any[] {
  * nothing; `reserve` makes room for a backup the real run would add, and `kept` then counts it.
  * Never reaches the legacy `.claude/backups` root: those may be a user's only restore points.
  */
-function applyRetention({ backupRoot, keep, protect = [], reserve = 0, dryRun = false, now = Date.now(), fsImpl = fs }: any): any {
+function applyRetention({ backupRoot, keep, protect = [], reserve = 0, dryRun = false, now = Date.now(), fsImpl = fs }     )      {
   assertMutableBackupRoot(backupRoot, 'prune backups');
   if (!Number.isInteger(keep) || keep < 0) throw new Error(`Backup retention must be a non-negative whole number, got ${keep}`);
-  const result: any = { keep, kept: 0, removed: [], wouldRemove: [], failed: [], sweptTemps: 0 };
+  const result      = { keep, kept: 0, removed: [], wouldRemove: [], failed: [], sweptTemps: 0 };
 
   // Only DoFlow backups count: a directory with a readable manifest, or one named like a backup id
   // (a 1.19 or interrupted backup can lack a manifest). Anything else in the root is not ours to
@@ -701,7 +701,7 @@ function applyRetention({ backupRoot, keep, protect = [], reserve = 0, dryRun =
     try {
       fsImpl.rmSync(dir, { recursive: true, force: true });
       result.removed.push(id);
-    } catch (err: any) {
+    } catch (err     ) {
       result.failed.push({ id, error: err.message });
     }
   }
@@ -710,7 +710,7 @@ function applyRetention({ backupRoot, keep, protect = [], reserve = 0, dryRun =
 }
 
 /** The parenthesised end of a retention line: the `--prune` value given, or the default. */
-function retentionNote(prune: number | null | undefined, keep: number): string {
+function retentionNote(prune                           , keep        )         {
   if (prune === null || prune === undefined) return `keeping the newest ${keep}; --prune N changes this`;
   if (prune === 0) return '--prune 0 keeps every backup';
   return `--prune ${keep}`;

package/src/install/{context.ts → context.js}

@@ -5,27 +5,27 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../install/context.ts')` keeps working while the tree is still `.js`.
+// caller's `require('../install/context.js')` keeps working while the tree is still `.js`.
 const path = require('node:path');
-const { sourceCommit: gitSourceCommit } = require('../helper/git.ts');
+const { sourceCommit: gitSourceCommit } = require('../helper/git.js');
 
-interface ResolveContextInput {
-  repoRoot: string;
-  global: boolean;
-  projectRoot: string;
-  targets: string[];
-  dirs: Record<string, string>;
-  sourceCommit?: string;
-  managedResources?: object[];
-}
+                               
+                   
+                  
+                      
+                    
+                               
+                        
+                              
+ 
 
 /**
  * `sourceCommit` lets a caller (bin/doflow.js) pass an already-resolved commit instead of this
  * module spawning its own `git rev-parse`; omit it to resolve here (e.g. tests calling this module
  * directly). Returns a plain properties object (used by both the text and --json renderers).
  */
-function resolveContext({ repoRoot, global, projectRoot, targets, dirs, sourceCommit, managedResources }: ResolveContextInput): any {
-  const context: any = {
+function resolveContext({ repoRoot, global, projectRoot, targets, dirs, sourceCommit, managedResources }                     )      {
+  const context      = {
     scope: global ? 'global' : 'project',
     scopeRoot: global ? path.dirname(dirs.claude) : path.resolve(projectRoot),
     targets,
@@ -41,12 +41,12 @@ function resolveContext({ repoRoot, global, projectRoot, targets, dirs, sourceCo
 }
 
 /** Human-readable "Resolved context" block, printed to stderr (keeps stdout clean like sync.sh's log()). */
-function printContext(ctx: any): void {
+function printContext(ctx     )       {
   const lines = [
     '[CONTEXT] Resolved install context',
     `  scope         : ${ctx.scope}  (root: ${ctx.scopeRoot})`,
     `  targets       : ${ctx.targets.join(', ')}`,
-    ...ctx.targets.map((t: string) => `    ${t.padEnd(7)}-> ${ctx.dirs[t]}`),
+    ...ctx.targets.map((t        ) => `    ${t.padEnd(7)}-> ${ctx.dirs[t]}`),
     `  repo root     : ${ctx.repoRoot}`,
     `  source commit : ${ctx.sourceCommit}`,
     `  node          : ${ctx.nodeVersion}`,